Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/sources/formale Sprachen/C/Lyx/src/ (Lyx Textverarbeitung ^©) Datei vom 26.0.1999 mit Größe 85 kB

SSL buffer.C Interaktion und
PortierbarkeitC

/* This file is part of
* ======================================================
*
*           LyX, The Document Processor
*
*      Copyright (C) 1995 Matthias Ettrich
*           Copyright (C) 1995-1998 The LyX Team.
*
*           This file is Copyright (C) 1996-1998
*           Lars Gullik Bjønnes
*
*======================================================
*/
#include <config.h>

#include <stdlib.h>
#include <unistd.h>

#ifdef __GNUG__
#pragma implementation "buffer.h"
#endif

#include "definitions.h"
#include "buffer.h"
#include "bufferlist.h"
#include "lyx_main.h"
#include "lyx_gui_misc.h"
#include "lyxrc.h"
#include "lyxlex.h"
#include "tex-strings.h"
#include "layout.h"
#include "lyx_cb.h"
#include "minibuffer.h"
#include "lyxfont.h"
#include "formulamacro.h"
#include "lyxinset.h"
#include "inseterror.h"
#include "insetlabel.h"
#include "insetref.h"
#include "inseturl.h"
#include "insetinfo.h"
#include "insetquotes.h"
#include "insetlatex.h"
#include "insetlatexaccent.h"
#include "insetbib.h"
#include "insetindex.h"
#include "insetinclude.h"
#include "insettoc.h"
#include "insetlof.h"
#include "insetlot.h"
#include "insetloa.h"
#include "insetparent.h"
#include "insetspecialchar.h"
#include "figinset.h"
#include "filetools.h"
#include "pathstack.h"
#include "LaTeX.h"
#include "Chktex.h"
#include "LyXView.h"
#include "error.h"
#include "LaTeXFeatures.h"
#include "syscall.h"
#include "lyxlib.h"
#include "FileInfo.h"
#include "lyxtext.h"
#include "gettext.h"

// $Id: buffer.C,v 1.12 1998/10/20 12:48:43 lasgoutt Exp $

#if !defined(lint) && !defined(WITH_WARNINGS)
static char vcid[] = "$Id: buffer.C,v 1.12 1998/10/20 12:48:43 lasgoutt Exp $";
#endif /* lint */

// Uncomment this line to enable a workaround for the weird behaviour
// of the cursor between a displayed inset and last character
// at the upper line. (Alejandro 20.9.96)
// #define BREAK_BEFORE_INSET

/* Lars, when changing this file sometime in the future to a list,
* please check out the figinsets-sideeffects described at the
* beginning of figinset.C    Matthias (04.07.1996)
*/

// all these externs should eventually be removed.
extern BufferList bufferlist;
extern void SmallUpdate(signed char);
extern unsigned char GetCurrentTextClass();
extern void BeforeChange();

static const float LYX_FORMAT = 2.15;

extern int tex_code_break_column;

extern void FreeUpdateTimer();

Buffer::Buffer(LString const & file, LyXRC *lyxrc, bool ronly)
{
filename = file;
filepath = OnlyPath(file);
paragraph = NULL;
text = NULL;
the_locking_inset = NULL;
lyx_clean = true;
bak_clean = true;
dvi_clean = false;
dep_clean = NULL;
read_only = ronly;
inset_slept = false;
users = 0;
lyxvc.setBuffer(this);
lyxerr.debug("Buffer::Buffer()");
if (read_only || (lyxrc && lyxrc->use_tempdir)) {
  tmppath = CreateBufferTmpDir();
} else tmppath.clean();
}

Buffer::~Buffer()
{
lyxerr.debug("Buffer::~Buffer()");
// here the buffer should take care that it is
// saved properly, before it goes into the void.

// make sure that views using this buffer
// forgets it.
if (users)
  users->setBuffer(0);

if (!tmppath.empty()) {
  DestroyBufferTmpDir(tmppath);
}

LyXParagraph *par = paragraph;
LyXParagraph *tmppar;
while (par) {
  tmppar = par->next;
  delete par;
  par = tmppar;
}
paragraph = NULL;
delete text;
}

bool Buffer::saveParamsAsDefaults()
{
LString fname = AddName(AddPath(user_lyxdir, "templates/"),
    "defaults.lyx");
Buffer defaults = Buffer(fname);

// Use the current buffer's parameters as default
defaults.params.Copy(params);
// add an empty paragraph. Is this enough?
defaults.paragraph = new LyXParagraph();

return defaults.writeFile(defaults.filename,false);
}

/// Update window titles of all users
// Should work on a list
void Buffer::updateTitles()
{
if (users) users->getOwner()->updateWindowTitle();
}

/// Reset autosave timer of all users
// Should work on a list
void Buffer::resetAutosaveTimers()
{
if (users) users->getOwner()->resetAutosaveTimer();
}

void Buffer::setFileName(LString const & newfile)
{
filename = MakeAbsPath(newfile);
filepath = OnlyPath(filename);
setReadonly(IsFileWriteable(filename) == 0);
updateTitles();
}

void Buffer::InsetUnlock()
{
if (the_locking_inset) {
  if (!inset_slept) the_locking_inset->InsetUnlock();
  the_locking_inset = NULL;
  text->FinishUndo();
  inset_slept = false;
}
}

// Inserts a file into current document
bool Buffer::insertLyXFile(LString const & filen)
//
// (c) CHT Software Service GmbH
// Uwe C. Schroeder
//
// Insert a Lyxformat - file into current buffer
//
// Moved from lyx_cb.C (Lgb)
{
if (filen.empty()) return false;

LString filename = MakeAbsPath(filen);

// check if file exist
FileInfo fi(filename);

if (!fi.exist() || !fi.readable()) {
  WriteAlert(_("Error!"),
      _("Cannot open specified file:"),
      MakeDisplayPath(filename,50));
  return false;
}

BeforeChange();

FilePtr myfile(filename, FilePtr::read);
if (!myfile()) {
  WriteAlert(_("Error!"),
      _("Cannot open specified file:"),
      MakeDisplayPath(filename,50));
  return false;
}
LyXLex lex(NULL, 0);
lex.setFile(myfile);
int c = fgetc(myfile());
ungetc(c, myfile);

bool res = true;

if (c=='#') {
  lyxerr.debug("Will insert file with header");
  res = readFile(lex, text->cursor.par);
} else {
  lyxerr.debug("Will insert file without header");
  res = readLyXformat2(lex, text->cursor.par);
}
resize();
return res;
}

//
// Uwe C. Schroeder
// changed to be public and have one parameter
// if par = NULL normal behavior
// else insert behavior
// Returns false if "\the_end" is not read for formats >= 2.13. (Asger)
bool Buffer::readLyXformat2(LyXLex &lex, LyXParagraph *par)
{
LString tmptok;
Inset *inset = 0;
int pos = 0;
int tmpret, tmpret2;
char depth = 0; // signed or unsigned?
LyXParagraph::footnote_flag footnoteflag = LyXParagraph::NO_FOOTNOTE;
LyXParagraph::footnote_kind footnotekind = LyXParagraph::FOOTNOTE;
bool the_end_read = false;

LyXParagraph *return_par = NULL;
LyXFont font = LyXFont(LyXFont::ALL_INHERIT);

// If we are inserting, we cheat and get a token in advance
bool has_token = false;
LString pretoken;

if(!par) {
  par = new LyXParagraph();
} else {
  text->BreakParagraph();
  return_par = text->FirstParagraph();
  pos=0;
  markDirty();
  // We don't want to adopt the parameters from the
  // document we insert, so we skip until the text begins:
  while (lex.IsOK()) {
   lex.nextToken();
   pretoken = lex.GetString();
   if (pretoken == "\\layout") {
    has_token = true;
    break;
   }
  }
}

while (lex.IsOK()) {
  if (has_token) {
   has_token = false;
  } else {
   lex.nextToken();
   pretoken = lex.GetString();
  }

  // Profiling show this should give a lot: (Asger)
  LString const token = pretoken;

  if (token.empty())
   continue;
  else if (token[0] != '\\') {
   int n = token.length();
   for (int i=0; i < n; i++) {
    par->InsertChar(pos, token[i]);
    par->SetFont(pos, font);
    pos++;
   }
  } else if (token == "\\i") {
   inset = new InsetLatexAccent;
   inset->Read(lex);
   par->InsertChar(pos, LYX_META_INSET);

   par->InsertInset(pos, inset);
   par->SetFont(pos, font);
   pos++;
  } else if (token == "\\layout") {
   if (!return_par)
    return_par = par;
   else
    par = new LyXParagraph(par);
   pos = 0;
   lex.EatLine();
   par->layout =
    lyxstyle.NumberOfLayout(params.textclass,
       lex.GetString());
   if (par->layout == -1) // layout not found
    // use default layout "Standard" (0)
    par->layout = 0;
   // Test whether the layout is obsolete.
   LyXLayout* layout = lyxstyle.Style(params.textclass,
          par->layout);
   if (!layout->obsoleted_by.empty())
    par->layout =
     lyxstyle.NumberOfLayout(params.textclass,
        layout->obsoleted_by);
   par->footnoteflag = footnoteflag;
   par->footnotekind = footnotekind;
   par->depth = depth;
   font = LyXFont(LyXFont::ALL_INHERIT);
  } else if (token == "\\end_float") {
   if (!return_par)
    return_par = par;
   else
    par = new LyXParagraph(par);
   footnotekind = LyXParagraph::FOOTNOTE;
   footnoteflag = LyXParagraph::NO_FOOTNOTE;
   pos = 0;
   lex.EatLine();
   par->layout = LYX_DUMMY_LAYOUT;
   font = LyXFont(LyXFont::ALL_INHERIT);
  } else if (token == "\\begin_float") {
   tmpret = lex.FindToken(string_footnotekinds);
   if (tmpret == -1) tmpret++;
   if (tmpret != LYX_LAYOUT_DEFAULT)
    footnotekind = (LyXParagraph::footnote_kind)tmpret; // bad
   if (footnotekind == LyXParagraph::FOOTNOTE
       || footnotekind == LyXParagraph::MARGIN)
    footnoteflag = LyXParagraph::CLOSED_FOOTNOTE;
   else
    footnoteflag = LyXParagraph::OPEN_FOOTNOTE;
  } else if (token == "\\begin_deeper") {
   depth++;
  } else if (token == "\\end_deeper") {
   if (!depth) {
    lex.printError("\\end_deeper: "
            "depth is already null");
   }
   else
    depth--;
  } else if (token == "\\begin_preamble") {
   params.readPreamble(lex);
  } else if (token == "\\textclass") {
   lex.EatLine();
   params.textclass = lyxstyle.NumberOfClass(lex.GetString());
   if (params.textclass == -1) {
    lex.printError("Unknown textclass `$$Token'");
    params.textclass = 0;
   }
   if (!lyxstyle.Load(params.textclass)) {
    // if the textclass wasn't loaded properly
    // we need to either substitute another
    // or stop loading the file.
    // I can substitute but I don't see how I can
    // stop loading... ideas??  ARRae980418
    WriteAlert(_("Textclass Loading Error!"),
               LString(_("Can't load textclass ")) +
        lyxstyle.NameOfClass(params.textclass),
        _("-- substituting default"));
    params.textclass = 0;
   }
  } else if (token == "\\options") {
   lex.EatLine();
   params.options = lex.GetString();
  } else if (token == "\\language") {
   params.readLanguage(lex);
  } else if (token == "\\fontencoding") {
   lex.EatLine();
  } else if (token == "\\inputencoding") {
   lex.EatLine();
   params.inputenc = lex.GetString();
  } else if (token == "\\graphics") {
   params.readGraphicsDriver(lex);
  } else if (token == "\\fontscheme") {
   lex.EatLine();
   params.fonts = lex.GetString();
  } else if (token == "\\noindent") {
   par->noindent = true;
  } else if (token == "\\fill_top") {
   par->added_space_top = VSpace::VFILL;
  } else if (token == "\\fill_bottom") {
   par->added_space_bottom = VSpace::VFILL;
  } else if (token == "\\line_top") {
   par->line_top = true;
  } else if (token == "\\line_bottom") {
   par->line_bottom = true;
  } else if (token == "\\pagebreak_top") {
   par->pagebreak_top = true;
  } else if (token == "\\pagebreak_bottom") {
   par->pagebreak_bottom = true;
  } else if (token == "\\start_of_appendix") {
   par->start_of_appendix = true;
  } else if (token == "\\paragraph_separation") {
   tmpret = lex.FindToken(string_paragraph_separation);
   if (tmpret == -1) tmpret++;
   if (tmpret != LYX_LAYOUT_DEFAULT)
    params.paragraph_separation = tmpret;
  } else if (token == "\\defskip") {
   lex.nextToken();
   params.defskip = VSpace(lex.GetString());
  } else if (token == "\\no_isolatin1") {
   lex.nextToken();
  } else if (token == "\\no_babel") {
   lex.nextToken();
  } else if (token == "\\no_epsfig") {
   lex.nextToken();
  } else if (token == "\\epsfig") { // obsolete
   // Indeed it is obsolete, but we HAVE to be backwards
   // compatible until 0.14, because otherwise all figures
   // in existing documents are irretrivably lost. (Asger)
   params.readGraphicsDriver(lex);
  } else if (token == "\\quotes_language") {
   tmpret = lex.FindToken(string_quotes_language);
   if (tmpret == -1) tmpret++;
   if (tmpret != LYX_LAYOUT_DEFAULT) {
    InsetQuotes::quote_language tmpl =
     InsetQuotes::EnglishQ;
    switch(tmpret) {
    case 0:
     tmpl = InsetQuotes::EnglishQ;
     break;
    case 1:
     tmpl = InsetQuotes::SwedishQ;
     break;
    case 2:
     tmpl = InsetQuotes::GermanQ;
     break;
    case 3:
     tmpl = InsetQuotes::PolishQ;
     break;
    case 4:
     tmpl = InsetQuotes::FrenchQ;
     break;
    case 5:
     tmpl = InsetQuotes::DanishQ;
     break;
    }
    params.quotes_language = tmpl;
   }
  } else if (token == "\\quotes_times") {
   lex.nextToken();
   switch(lex.GetInteger()) {
   case 1:
    params.quotes_times = InsetQuotes::SingleQ;
    break;
   case 2:
    params.quotes_times = InsetQuotes::DoubleQ;
    break;
   }
                } else if (token == "\\papersize") {
                        if (format > 2.13)
                                tmpret = lex.FindToken(string_papersize);
                        else
                                tmpret = lex.FindToken(string_oldpapersize);
   if (tmpret == -1)
                                tmpret++;
                        else
                                params.papersize2 = tmpret;
                } else if (token == "\\paperpackage") {
   tmpret = lex.FindToken(string_paperpackages);
   if (tmpret == -1) {
                                tmpret++;
                                params.paperpackage = PACKAGE_NONE;
                        } else
                                params.paperpackage = tmpret;
  } else if (token == "\\use_geometry") {
   lex.nextToken();
   params.use_geometry = lex.GetInteger();
  } else if (token == "\\use_amsmath") {
   lex.nextToken();
   params.use_amsmath = lex.GetInteger();
  } else if (token == "\\paperorientation") {
   tmpret = lex.FindToken(string_orientation);
   if (tmpret == -1) tmpret++;
   if (tmpret != LYX_LAYOUT_DEFAULT)
    params.orientation = tmpret;
  } else if (token == "\\paperwidth") {
   lex.next();
   params.paperwidth = lex.GetString();
  } else if (token == "\\paperheight") {
   lex.next();
   params.paperheight = lex.GetString();
  } else if (token == "\\leftmargin") {
   lex.next();
   params.leftmargin = lex.GetString();
  } else if (token == "\\topmargin") {
   lex.next();
   params.topmargin = lex.GetString();
  } else if (token == "\\rightmargin") {
   lex.next();
   params.rightmargin = lex.GetString();
  } else if (token == "\\bottommargin") {
   lex.next();
   params.bottommargin = lex.GetString();
  } else if (token == "\\headheight") {
   lex.next();
   params.headheight = lex.GetString();
  } else if (token == "\\headsep") {
   lex.next();
   params.headsep = lex.GetString();
  } else if (token == "\\footskip") {
   lex.next();
   params.footskip = lex.GetString();
  } else if (token == "\\paperfontsize") {
   lex.nextToken();
   params.fontsize = lex.GetString();
   params.fontsize.strip();
  } else if (token == "\\papercolumns") {
   lex.nextToken();
   params.columns = lex.GetInteger();
  } else if (token == "\\papersides") {
   lex.nextToken();
   params.sides = lex.GetInteger();
  } else if (token == "\\paperpagestyle") {
          lex.nextToken();
   params.pagestyle = lex.GetString();
   params.pagestyle.strip();
  } else if (token == "\\bullet") {
   lex.nextToken();
   int index = lex.GetInteger();
   lex.nextToken();
   int temp_int = lex.GetInteger();
   params.user_defined_bullets[index].setFont(temp_int);
   params.temp_bullets[index].setFont(temp_int);
   lex.nextToken();
   temp_int = lex.GetInteger();
   params.user_defined_bullets[index].setCharacter(temp_int);
   params.temp_bullets[index].setCharacter(temp_int);
   lex.nextToken();
   temp_int = lex.GetInteger();
   params.user_defined_bullets[index].setSize(temp_int);
   params.temp_bullets[index].setSize(temp_int);
   lex.nextToken();
   LString temp_str = lex.GetString();
   if (temp_str != "\\end_bullet") {
    // this element isn't really necessary for
    // parsing but is easier for humans
    // to understand bullets. Put it back and
    // set a debug message?
    lex.printError("\\end_bullet expected, got" + temp_str);
    //how can I put it back?
   }
  } else if (token == "\\bulletLaTeX") {
   lex.nextToken();
   int index = lex.GetInteger();
   lex.next();
   LString temp_str = lex.GetString(), sum_str;
   while (temp_str != "\\end_bullet") {
    // this loop structure is needed when user
    // enters an empty string since the first
    // thing returned will be the \\end_bullet
    // OR
    // if the LaTeX entry has spaces. Each element
    // therefore needs to be read in turn
    sum_str += temp_str;
    lex.next();
    temp_str = lex.GetString();
   }
   params.user_defined_bullets[index].setText(sum_str);
   params.temp_bullets[index].setText(sum_str);
  } else if (token == "\\secnumdepth") {
   lex.nextToken();
   params.secnumdepth = lex.GetInteger();
  } else if (token == "\\tocdepth") {
   lex.nextToken();
   params.tocdepth = lex.GetInteger();
  } else if (token == "\\baselinestretch") { // now obsolete
   lex.nextToken(); // should not be used directly
   // anymore.
   // Will probably keep a kind of support just for
   // compability.
   params.spacing.set(Spacing::Other, lex.GetFloat());
  } else if (token == "\\spacing") {
   lex.next();
   LString tmp = lex.GetString().strip();
   if (tmp == "single") {
    params.spacing.set(Spacing::Single);
   } else if (tmp == "onehalf") {
    params.spacing.set(Spacing::Onehalf);
   } else if (tmp == "double") {
    params.spacing.set(Spacing::Double);
   } else if (tmp == "other") {
    lex.next();
    params.spacing.set(Spacing::Other,
         lex.GetFloat());
   } else {
    lex.printError("Unknown spacing token: '$$Token'");
   }
  } else if (token == "\\float_placement") {
   lex.nextToken();
   params.float_placement = lex.GetString();
  } else if (token == "\\cursor") {
   // this is obsolete, so we just skip it.
   lex.nextToken();
  } else if (token == "\\family") {
   lex.next();
   font.setLyXFamily(lex.GetString());
  } else if (token == "\\series") {
   lex.next();
   font.setLyXSeries(lex.GetString());
  } else if (token == "\\shape") {
   lex.next();
   font.setLyXShape(lex.GetString());
  } else if (token == "\\size") {
   lex.next();
   font.setLyXSize(lex.GetString());
  } else if (token == "\\latex") {
   lex.next();
   LString tok = lex.GetString();
   // This is dirty, but gone with LyX3. (Asger)
   if (tok == "no_latex")
    font.setLatex(LyXFont::OFF);
   else if (tok == "latex")
    font.setLatex(LyXFont::ON);
   else if (tok == "default")
    font.setLatex(LyXFont::INHERIT);
   else
    lex.printError("Unknown LaTeX font flag "
            "`$$Token'");
  } else if (token == "\\emph") {
   lex.next();
   font.setEmph(font.setLyXMisc(lex.GetString()));
  } else if (token == "\\bar") {
   lex.next();
   LString tok = lex.GetString();
   // This is dirty, but gone with LyX3. (Asger)
   if (tok == "under")
    font.setUnderbar(LyXFont::ON);
   else if (tok == "no")
    font.setUnderbar(LyXFont::OFF);
   else if (tok == "default")
    font.setUnderbar(LyXFont::INHERIT);
   else
    lex.printError("Unknown bar font flag "
            "`$$Token'");
  } else if (token == "\\noun") {
   lex.next();
   font.setNoun(font.setLyXMisc(lex.GetString()));
  } else if (token == "\\color") {
   lex.next();
   font.setLyXColor(lex.GetString());
  } else if (token == "\\align") {
   tmpret = lex.FindToken(string_align);
   if (tmpret == -1) tmpret++;
   if (tmpret != LYX_LAYOUT_DEFAULT) {
    tmpret2 = 1;
    for (; tmpret>0; tmpret--)
     tmpret2 = tmpret2 * 2;
    par->align = tmpret2;
   }
  } else if (token == "\\added_space_top"){
   lex.nextToken();
   par->added_space_top = lex.GetString();
  } else if (token == "\\added_space_bottom") {
   lex.nextToken();
   par->added_space_bottom = lex.GetString();
                } else if (token == "\\pextra_type") {
                        lex.nextToken();
                        par->pextra_type = lex.GetInteger();
                } else if (token == "\\pextra_width") {
                        lex.nextToken();
   par->pextra_width = lex.GetString();
                } else if (token == "\\pextra_widthp") {
                        lex.nextToken();
   par->pextra_widthp = lex.GetString();
                } else if (token == "\\pextra_alignment") {
                        lex.nextToken();
                        par->pextra_alignment = lex.GetInteger();
                } else if (token == "\\pextra_hfill") {
                        lex.nextToken();
                        par->pextra_hfill = lex.GetInteger();
                } else if (token == "\\pextra_start_minipage") {
                        lex.nextToken();
                        par->pextra_start_minipage = lex.GetInteger();
  } else if (token == "\\labelwidthstring") {
   lex.EatLine();
   par->labelwidthstring = lex.GetString();
   /* do not delete this token, it is still needed! */
  } else if (token == "\\end_inset") {
   /* simple ignore this. The insets do not have
*  to read this */
   // but insets should read it, it is a part of
   //the inset isn't it? Lgb.
  } else if (token == "\\begin_inset") {
   lex.next();
   tmptok = lex.GetString();
   /* test the different insets */
   if (tmptok == "Quotes") {
    inset = new InsetQuotes;
    inset->Read(lex);
    par->InsertChar(pos, LYX_META_INSET);
    par->InsertInset(pos, inset);
    par->SetFont(pos, font);
    pos++;
   } else if (tmptok == "Latex") {
    // This one is on its way out
    lex.EatLine();
    tmptok = lex.GetString().strip();
    //lyxerr.print(LString(tmptok[0]));
    if (tmptok[0] == '\\') {
     // then this latex is a
     // latex command
     InsetCommand *tmpinset =
      new InsetCommand();
     tmpinset->scanCommand(tmptok);
     inset = tmpinset;
    } else {
     // This should not use InsetLaTexDel
     // it should rather insert text into
     // the paragraph and mark it as tex.
     inset = new InsetLatex(tmptok);
    }
    par->InsertChar(pos, LYX_META_INSET);
    par->InsertInset(pos, inset);
    par->SetFont(pos, font);
    pos++;
   } else if (tmptok == "LatexDel") {
    // This one is on its way out...
    lex.EatLine();
    tmptok = lex.GetString().strip();
    //lyxerr.print(LString(tmptok[0]));
    if (tmptok == "\\tableofcontents") {
     inset = new InsetTOC(this);
    } else if (tmptok == "\\listoffigures") {
     inset = new InsetLOF(this);
    } else if (tmptok == "\\listoftables") {
     inset = new InsetLOT(this);
    } else if (tmptok == "\\listofalgorithms") {
     inset = new InsetLOA(this);
    } else if (tmptok.contains("\\ref{")
        || tmptok.contains("\\pageref{")) {
     LString cont,opt,tmptmptok,cmdname;
     lex.next();
     while(lex.IsOK() && lex.GetString() != "\\end_inset" ) {
      lex.next();
     }
     lex.next();
     while(lex.IsOK()) {
      tmptmptok=lex.GetString();
      if(tmptmptok[0] == '\\') {
       if( tmptmptok == "\\backslash")
        opt += '\\';
       else
        break;
      }
      else
       opt += tmptmptok;
      opt += ' ';
      lex.next();
     }
     while(lex.IsOK() && lex.GetString() != "\\end_inset" ) {
      lex.next();
     }
     lex.next();
     while(lex.IsOK()) {
      tmptmptok=lex.GetString();
      if(tmptmptok[0] == '\\') {
       if( tmptmptok == "\\backslash")
        cont += '\\';
       else
        break;
      }
      else
       cont += tmptmptok;
      cont += ' ';
      lex.next();
     }
     while(lex.IsOK() && lex.GetString() != "\\end_inset" ) {
      lex.next();
     }
     cmdname = "\\";
     if(tmptok.contains("\\ref{"))
      cmdname += LString("ref");
     else
      cmdname += LString("pageref");
     cont.strip();
     opt.strip();
     cmdname += "["  + cont  + "]";
     cmdname += "{"  + opt + "}";
     inset = new InsetRef(cmdname,this);
    } else if (tmptok.contains("\\url{")
        || tmptok.contains("\\htmlurl{")) {
     LString cont,opt,tmptmptok,cmdname;
     lex.next();
     while(lex.IsOK() && lex.GetString() != "\\end_inset" ) {
      lex.next();
     }
     lex.next();
     while(lex.IsOK()) {
      tmptmptok=lex.GetString();
      if(tmptmptok[0] == '\\') {
       if( tmptmptok == "\\backslash")
        opt += '\\';
       else
        break;
      }
      else
       opt += tmptmptok;
      opt += ' ';
      lex.next();
     }
     while(lex.IsOK() && lex.GetString() != "\\end_inset" ) {
      lex.next();
     }
     lex.next();
     while(lex.IsOK()) {
      tmptmptok=lex.GetString();
      if(tmptmptok[0] == '\\') {
       if( tmptmptok == "\\backslash")
        cont += '\\';
       else
        break;
      }
      else
       cont += tmptmptok;
      cont += ' ';
      lex.next();
     }
     while(lex.IsOK() && lex.GetString() != "\\end_inset" ) {
      lex.next();
     }
     if(tmptok.contains("\\url{"))
      cmdname = LString("url");
     else
      cmdname = LString("htmlurl");
     cont.strip();
     opt.strip();
     inset = new InsetUrl(cmdname,cont,opt);
    } else if (tmptok[0] == '\\') {
     // then this latex del is a
     // latex command
     InsetCommand *tmpinset =
      new InsetCommand();
     tmpinset->scanCommand(tmptok);
     inset = tmpinset;
    }
    par->InsertChar(pos, LYX_META_INSET);
    par->InsertInset(pos, inset);
    par->SetFont(pos, font);
    pos++;
   } else if (tmptok == "\\i") {
    inset = new InsetLatexAccent;
    inset->Read(lex);
    par->InsertChar(pos, LYX_META_INSET);
    par->InsertInset(pos, inset);
    par->SetFont(pos, font);
    pos++;
   } else if (tmptok == "FormulaMacro") {
    inset = new InsetFormulaMacro;
    inset->Read(lex);
    par->InsertChar(pos, LYX_META_INSET);
    par->InsertInset(pos, inset);
    par->SetFont(pos, font);
    pos++;
   } else if (tmptok == "Formula") {
    inset = new InsetFormula;
    inset->Read(lex);
    par->InsertChar(pos, LYX_META_INSET);
    par->InsertInset(pos, inset);
    par->SetFont(pos, font);
    pos++;
   } else if (tmptok == "Figure") {
    inset = new InsetFig(100,100, this);
    inset->Read(lex);
    par->InsertChar(pos, LYX_META_INSET);
    par->InsertInset(pos, inset);
    par->SetFont(pos, font);
    pos++;
   } else if (tmptok == "Label") {
    // Kept for compability. Remove in 0.13.
    if (lex.EatLine()) {
     LString tmp;
     tmp += "\\label{";
     tmp += lex.GetString();
     tmp += '}';
     inset = new InsetLabel(tmp);
     par->InsertChar(pos, LYX_META_INSET);
     par->InsertInset(pos, inset);
     par->SetFont(pos, font);
     pos++;
    }
   } else if (tmptok == "Info") {
    inset = new InsetInfo;
    inset->Read(lex);
    par->InsertChar(pos, LYX_META_INSET);
    par->InsertInset(pos, inset);
    par->SetFont(pos, font);
    pos++;
   } else if (tmptok == "Include") {
    inset = new InsetInclude(LString(), this);
    inset->Read(lex);
    par->InsertChar(pos, LYX_META_INSET);
    par->InsertInset(pos, inset);
    par->SetFont(pos, font);
    pos++;
   } else if (tmptok == "LatexCommand") {
    InsetCommand inscmd;
    inscmd.Read(lex);
    if (inscmd.getCmdName()=="cite") {
     inset = new InsetCitation(inscmd.getContents(), inscmd.getOptions());
    } else if (inscmd.getCmdName()=="bibitem") {
     lex.printError("Wrong place for bibitem");
     inset = inscmd.Clone();
    } else if (inscmd.getCmdName()=="BibTeX") {
     inset = new InsetBibtex(inscmd.getContents(), inscmd.getOptions(), this);
    } else if (inscmd.getCmdName()=="index") {
     inset = new InsetIndex(inscmd.getContents());
    } else if (inscmd.getCmdName()=="include") {
     inset = new InsetInclude(inscmd.getContents(), this);
    } else if (inscmd.getCmdName()=="label") {
     inset = new InsetLabel(inscmd.getCommand());
    } else if (inscmd.getCmdName()=="url"
        || inscmd.getCmdName()=="htmlurl") {
     inset = new InsetUrl(inscmd.getCommand());
    } else if (inscmd.getCmdName() == "ref"
        || inscmd.getCmdName() == "pageref") {
     if (!inscmd.getOptions().empty() || !inscmd.getContents().empty()) {
      inset = new InsetRef(inscmd, this);
     }
     /* This condition comes from a temporary solution
   to the latexdel ref inset that was transformed to an empty ref
   inset plus the body surronded by latexdel insets */
     else {
      LString cont,opt,tmptmptok,cmdname;
      lex.next();
      while(lex.IsOK() && lex.GetString() != "\\end_inset" ) {
       lex.next();
      }
      lex.next();
      while(lex.IsOK()) {
       tmptmptok=lex.GetString();
       if(tmptmptok[0] == '\\') {
        if( tmptmptok == "\\backslash")
         opt += '\\';
        else
         break;
       }
       else
        opt += tmptmptok;
       opt += ' ';
       lex.next();
      }
      while(lex.IsOK() && lex.GetString() != "\\end_inset" ) {
       lex.next();
      }
      lex.next();
      while(lex.IsOK()) {
       tmptmptok=lex.GetString();
       if(tmptmptok[0] == '\\') {
        if( tmptmptok == "\\backslash")
         cont += '\\';
        else
         break;
       }
       else
        cont += tmptmptok;
       cont += ' ';
       lex.next();
      }
      while(lex.IsOK() && lex.GetString() != "\\end_inset" ) {
       lex.next();
      }

      cont.strip();
      opt.strip();
      cmdname =  "\\" + inscmd.getCmdName();
      cmdname += "["  + cont  + "]";
      cmdname += "{"  + opt + "}";
      inset = new InsetRef(cmdname,this);
     }
    } else if (inscmd.getCmdName()=="tableofcontents") {
     inset = new InsetTOC(this);
    } else if (inscmd.getCmdName()=="listoffigures") {
     inset = new InsetLOF(this);
    } else if (inscmd.getCmdName()=="listofalgorithms") {
     inset = new InsetLOA(this);
    } else if (inscmd.getCmdName()=="listoftables") {
     inset = new InsetLOT(this);
    } else if (inscmd.getCmdName()=="printindex") {
     inset = new InsetPrintIndex(this);
    } else if (inscmd.getCmdName()=="lyxparent") {
     inset = new InsetParent(inscmd.getContents(),this);
    } else
     // The following three are only for compatibility
     if (inscmd.getCmdName()=="-") {
      inset = new InsetSpecialChar(InsetSpecialChar::HYPHENATION);
     } else if (inscmd.getCmdName()=="@.") {
      inset = new InsetSpecialChar(InsetSpecialChar::END_OF_SENTENCE);
     } else if (inscmd.getCmdName()=="ldots") {
      inset = new InsetSpecialChar(InsetSpecialChar::LDOTS);
     } else
      inset = inscmd.Clone();

    if (inset) {
     par->InsertChar(pos, LYX_META_INSET);
     par->InsertInset(pos, inset);
     par->SetFont(pos, font);
     pos++;
    }
   }
  } else if (token == "\\InsetQuotes") {
   inset = new InsetQuotes;
   inset->Read(lex);
   par->InsertChar(pos, LYX_META_INSET);
   par->InsertInset(pos, inset);
   par->SetFont(pos, font);
   pos++;
  } else if (token == "\\InsetLatex") {
   inset = new InsetLatex;
   inset->Read(lex);
   par->InsertChar(pos, LYX_META_INSET);
   par->InsertInset(pos, inset);
   par->SetFont(pos, font);
   pos++;
  } else if (token == "\\InsetLatexDel") {
   lex.printError(_("Warning: Ignoring Old Inset"));
  } else if (token == "\\InsetFormula") {
   inset = new InsetFormula;
   inset->Read(lex);
   par->InsertChar(pos, LYX_META_INSET);
   par->InsertInset(pos, inset);
   par->SetFont(pos, font);
   pos++;
  } else if (token == "\\SpecialChar") {
   inset = new InsetSpecialChar;
   inset->Read(lex);
   par->InsertChar(pos, LYX_META_INSET);
   par->InsertInset(pos, inset);
   par->SetFont(pos, font);
   pos++;
  } else if (token == "\\Figure") {
   inset = new InsetFig(100,100, this);
   inset->Read(lex);
   par->InsertChar(pos, LYX_META_INSET);
   par->InsertInset(pos, inset);
   par->SetFont(pos, font);
   pos++;
  } else if (token == "\\newline") {
   par->InsertChar(pos, LYX_META_NEWLINE);
   par->SetFont(pos, font);
   pos++;
  } else if (token == "\\LyXTable") {
   par->table = new LyXTable(lex);
  } else if (token == "\\hfill") {
   par->InsertChar(pos, LYX_META_HFILL);
   par->SetFont(pos, font);
   pos++;
  } else if (token == "\\protected_separator") {
   par->InsertChar(pos, LYX_META_PROTECTED_SEPARATOR);
   par->SetFont(pos, font);
   pos++;
  } else if (token == "\\bibitem") {  // ale970302
          if (!par->bibkey)
    par->bibkey = new InsetBibKey;
          par->bibkey->Read(lex);
  }else if (token == "\\backslash") {
   par->InsertChar(pos, '\\');
   par->SetFont(pos, font);
   pos++;
  }else if (token == "\\the_end") {
   the_end_read = true;
  } else {
   // This should be insurance for the future: (Asger)
   lex.printError("Unknown token `$$Token'. "
           "Inserting as text.");
   int n = token.length();
   for (int i=0; i < n; i++) {
    par->InsertChar(pos, token[i]);
    par->SetFont(pos, font);
    pos++;
   }
  }
}

if (!return_par)
  return_par = par;

paragraph = return_par;

return the_end_read;
}

bool Buffer::readFile(LyXLex &lex, LyXParagraph *par)
{
LString token;

if (lex.IsOK()) {
  lex.next();
  token = lex.GetString();
  if (token == "\\lyxformat") { // the first token _must_ be...
   lex.next();
   format = lex.GetFloat();
   if (format > 1) {
    if (LYX_FORMAT - format > 0.05) {
     printf(_("Warning: need lyxformat %.2f but found %.2f\n"),
            LYX_FORMAT, format);
    }
    if (format - LYX_FORMAT > 0.05) {
     printf(_("ERROR: need lyxformat %.2f but found %.2f\n"),
            LYX_FORMAT, format);
    }
    bool the_end = readLyXformat2(lex, par);
    // Formats >= 2.13 support "\the_end" marker
    if (format < 2.13)
     the_end = true;
                                // Formats >= 2.14 changed papersize stuff
                                if (format < 2.14) {
                                        setOldPaperStuff();
                                } else {
                                        setPaperStuff();
                                }
    if (!the_end)
     WriteAlert(_("Warning!"),
         _("Reading of document is not complete"),
         _("Maybe the document is truncated"));
    // We simulate a safe reading anyways to allow
    // users to take the chance... (Asger)
    return true;
   } // format < 1
   else {
    WriteAlert(_("ERROR!"),
        _("Old LyX file format found. "
          "Use LyX 0.10.x to read this!"));
    return false;
   }

  } else { // "\\lyxformat" not found
   WriteAlert(_("ERROR!"), _("Not a LyX file!"));
  }
} else
  WriteAlert(_("ERROR!"), _("Unable to read file!"));
return false;
}


// Returns false if unsuccesful
bool Buffer::writeFile(LString const & filename, bool flag)
{
// if flag is false writeFile will not create any GUI
// warnings, only stderr.
// Needed for autosave in background or panic save (Matthias 120496)

if (read_only && (filename == this->filename)) {
  // Here we should come with a question if we should
  // perform the write anyway.
  if (flag)
   lyxerr.print(_("Error! Document is read-only: ") + filename);
  else
   WriteAlert(_("Error! Document is read-only: "), filename);
  return false;
}

FileInfo finfo(filename);
if (finfo.exist() && !finfo.writable()) {
  // Here we should come with a question if we should
  // try to do the save anyway. (i.e. do a chmod first)
  if (flag)
   lyxerr.print(_("Error! Cannot write file: ") + filename);
  else
   WriteFSAlert(_("Error! Cannot write file: "), filename);
  return false;
}

FilePtr file(filename, FilePtr::truncate);
if (!file()) {
  if (flag)
   lyxerr.print(_("Error! Cannot write file: ") + filename);
  else
   WriteFSAlert(_("Error! Cannot write file: "), filename);
  return false;
}
// The top of the file should not be written by params.
// collect some very important information
LString userName(getUserName()) ;

// write out a comment in the top of the file
fprintf(file,
  "#This file was created by <%s> %s",
  userName.c_str(),(char*)date());
fprintf(file,
  "#LyX 1.0 (C) 1995-1999 Matthias Ettrich"
  " and the LyX Team\n");

// at the very beginning the used lyx format
fprintf(file, "\\lyxformat %.2f\n", LYX_FORMAT);

// now write out the buffer parameters.
params.writeFile(file);

char footnoteflag = 0;
char depth = 0;

// this will write out all the paragraphs
// using recursive descent.
paragraph->writeFile(file, params, footnoteflag, depth);

// Write marker that shows file is complete
fprintf(file, "\n\\the_end\n");
if (file.close()) {
  if (flag)
   lyxerr.print(_("Error! Could not close file properly: ")
         + filename);
  else
   WriteFSAlert(_("Error! Could not close file properly: "),
         filename);
  return false;
}
return true;
}

void Buffer::writeFileAscii(LString const & filename, int linelen)
{
FilePtr file(filename, FilePtr::write);
LyXFont
  font1, font2;
Inset
  *inset;
LyXParagraph
  *par = paragraph;
char
  c,
  footnoteflag = 0,
  depth = 0;

LString
  fname1,
  tmp;

int
  i,j,h,
  ltype=0,
  ltype_depth=0,
  noparbreak=0,
  islatex=0,
  *clen=NULL,
  actcell=0,
  actpos=0,
  cell=0,
         cells=0,
         currlinelen=0;
long
  fpos=0;
bool
  ref_printed = false;


if (!file()) {
  WriteFSAlert(_("Error: Cannot write file:"), filename);
  return;
}
fname1=TmpFileName();
while (par) {
  noparbreak = 0;
  islatex = 0;
  if (par->footnoteflag != LyXParagraph::NO_FOOTNOTE ||
      !par->previous ||
      par->previous->footnoteflag == LyXParagraph::NO_FOOTNOTE){

   /* begins a footnote environment ? */
   if (footnoteflag != par->footnoteflag) {
    footnoteflag = par->footnoteflag;
    if (footnoteflag) {
     j=strlen(string_footnotekinds[par->footnotekind])+4;
     if (currlinelen+j > linelen)
      fprintf(file,"\n");
     fprintf(file, "([%s] ",
      string_footnotekinds[par->footnotekind]);
     currlinelen += j;
    }
   }

   /* begins or ends a deeper area ?*/
   if (depth != par->depth) {
    if (par->depth > depth) {
     while (par->depth > depth) {
      depth++;
     }
    }
    else {
     while (par->depth < depth) {
      depth--;
     }
    }
   }

   /* First write the layout */
   tmp = lyxstyle.NameOfLayout(params.textclass,par->layout);
   if (tmp == "Itemize") {
    ltype = 1;
    ltype_depth = depth+1;
   } else if (tmp =="Enumerate") {
    ltype = 2;
    ltype_depth = depth+1;
   } else if (strstr(tmp.c_str(),"ection")) {
    ltype = 3;
    ltype_depth = depth+1;
   } else if (strstr(tmp.c_str(),"aragraph")) {
    ltype = 4;
    ltype_depth = depth+1;
   } else if (tmp == "Description") {
    ltype = 5;
    ltype_depth = depth+1;
   } else if (tmp == "Abstract") {
    ltype = 6;
    ltype_depth = 0;
   } else if (tmp == "Bibliography") {
    ltype = 7;
    ltype_depth = 0;
   } else {
    ltype = 0;
    ltype_depth = 0;
   }

   /* maybe some vertical spaces */

   /* the labelwidthstring used in lists */

   /* some lines? */

   /* some pagebreaks? */

   /* noindent ? */

   /* what about the alignment */
  }
  else {
   /* dummy layout, that means a footnote ended */
   footnoteflag = LyXParagraph::NO_FOOTNOTE;
   fprintf(file, ") ");
   noparbreak = 1;
  }

  /* It might be a table */
  if (par->table){
   if (!lyxrc->ascii_roff_command.empty() &&
                            lyxrc->ascii_roff_command != "none") {
    RoffAsciiTable(file,par);
    par = par->next;
    continue;
   }
   cell = 1;
                        actcell = 0;
   cells = par->table->columns;
   clen = new int [cells];
   memset(clen,0,sizeof(int)*cells);
   for (i = 0, j = 0, h=1; i < par->last; i++, h++) {
    c = par->GetChar(i);
    if (c == LYX_META_INSET) {
     if ((inset = par->GetInset(i))) {
      FilePtr fp(fname1,
          FilePtr::write);
      if (!fp()) {
       WriteFSAlert(_("Error: Cannot open temporary file:"), fname1);
       return;
      }
      inset->Latex(fp,-1);
      h += ftell(fp) - 1;
      remove(fname1.c_str());
     }
    } else if (c == LYX_META_NEWLINE) {
     if (clen[j] < h)
      clen[j] = h;
     h = 0;
     j = (++j) % par->table->NumberOfCellsInRow(actcell);
                                        actcell++;
    }
   }
   if (clen[j] < h)
    clen[j] = h;
  }

  font1 = LyXFont(LyXFont::ALL_INHERIT);
                actcell=0;
  for (i = 0,actpos=1; i < par->last; i++, actpos++) {
   if (!i && !footnoteflag && !noparbreak){
    fprintf(file, "\n\n");
    for(j=0; j<depth; j++)
     fprintf(file, " ");
    currlinelen = depth*2;
    switch(ltype) {
    case 0: /* Standart */
    case 4: /* (Sub)Paragraph */
                                case 5: /* Description */
     break;
    case 6: /* Abstract */
     fprintf(file, "Abstract\n\n");
     break;
    case 7: /* Bibliography */
     if (!ref_printed) {
      fprintf(file, "References\n\n");
      ref_printed = true;
     }
     break;
    default:
     fprintf(file,"%s ",par->labelstring.c_str());
     break;
    }
    if (ltype_depth > depth) {
     for(j=ltype_depth-1; j>depth; j--)
      fprintf(file, " ");
     currlinelen += (ltype_depth-depth)*2;
    }
    if (par->table) {
     for(j=0;j<cells;j++) {
      fputc('+',file);
      for(h=0; h<(clen[j]+1); h++)
       fputc('-',file);
     }
     fprintf(file,"+\n");
     for(j=0; j<depth; j++)
      fprintf(file, " ");
     currlinelen = depth*2;
     if (ltype_depth > depth) {
      for(j=ltype_depth; j>depth; j--)
       fprintf(file, " ");
      currlinelen += (ltype_depth-depth)*2;
     }
     fprintf(file,"| ");
    }
   }
   font2 = par->GetFontSettings(i);
   if (font1.latex() != font2.latex()) {
    if (font2.latex() == LyXFont::OFF)
     islatex = 0;
    else
     islatex = 1;
   }
   else {
    islatex = 0;
   }
   c = par->GetChar(i);
   if (islatex)
    continue;
   switch (c) {
   case LYX_META_INSET:
    if ((inset = par->GetInset(i))) {
     fpos = ftell(file);
     inset->Latex(file,-1);
     currlinelen += (ftell(file) - fpos);
     actpos += (ftell(file) - fpos) - 1;
    }
    break;
   case LYX_META_NEWLINE:
    if (par->table) {
     if (par->table->NumberOfCellsInRow(actcell) <= cell) {
      for(j=actpos;j<clen[cell-1];j++)
       fputc(' ',file);
      fprintf(file," |\n");
      for(j=0; j<depth; j++)
       fprintf(file, " ");
      currlinelen = depth*2;
      if (ltype_depth > depth) {
       for(j=ltype_depth; j>depth; j--)
        fprintf(file, " ");
       currlinelen += (ltype_depth-depth)*2;
      }
      for(j=0;j<cells;j++) {
       fputc('+',file);
       for(h=0; h<(clen[j]+1); h++)
        fputc('-',file);
      }
      fprintf(file,"+\n");
      for(j=0; j<depth; j++)
       fprintf(file, " ");
      currlinelen = depth*2;
      if (ltype_depth > depth) {
       for(j=ltype_depth; j>depth; j--)
        fprintf(file, " ");
       currlinelen += (ltype_depth-depth)*2;
      }
      fprintf(file,"| ");
      cell = 1;
     } else {
      for(j=actpos; j<clen[cell-1]; j++)
       fputc(' ',file);
      fprintf(file, " | ");
      cell++;
     }
                                        actcell++;
     currlinelen = actpos = 0;
    } else {
     fprintf(file, "\n");
     for(j=0; j<depth; j++)
      fprintf(file, " ");
     currlinelen = depth*2;
     if (ltype_depth > depth) {
      for(j=ltype_depth; j>depth; j--)
       fprintf(file, " ");
      currlinelen += (ltype_depth-depth)*2;
     }
    }
    break;
   case LYX_META_HFILL:
    fprintf(file, "\t");
    break;
   case LYX_META_PROTECTED_SEPARATOR:
    fprintf(file, " ");
    break;
   case '\\':
    fprintf(file, "\\");
    break;
   default:
    if (currlinelen > (linelen-10) \
                                    && c==' ' && (i+2 < par->last)) {
     fprintf(file, "\n");
     for(j=0; j<depth; j++)
      fprintf(file, " ");
     currlinelen = depth*2;
     if (ltype_depth > depth) {
      for(j=ltype_depth; j>depth; j--)
       fprintf(file, " ");
      currlinelen += (ltype_depth-depth)*2;
     }
    } else if (c != '\0')
     fprintf(file, "%c", c);
    else if (c == '\0')
     lyxerr.debug("writeAsciiFile: NULL char in structure.");
    currlinelen++;
    break;
   }
  }
  if (par->table) {
   for(j=actpos;j<clen[cell-1];j++)
    fputc(' ',file);
   fprintf(file," |\n");
   for(j=0; j<depth; j++)
    fprintf(file, " ");
   currlinelen = depth*2;
   if (ltype_depth > depth) {
    for(j=ltype_depth; j>depth; j--)
     fprintf(file, " ");
    currlinelen += (ltype_depth-depth)*2;
   }
   for(j=0;j<cells;j++) {
    fputc('+',file);
    for(h=0; h<(clen[j]+1); h++)
     fputc('-',file);
   }
   fprintf(file,"+\n");
   delete [] clen;
  }
  par = par->next;
}

fprintf(file, "\n");
}

void Buffer::makeLaTeXFile(LString const & filename,
      LString const & original_path,
      bool nice, bool only_body)
{
lyxerr.debug("makeLaTeXFile...", Error::LATEX);
params.textclass = GetCurrentTextClass();
niceFile = nice; // this will be used by Insetincludes.
if (nice)
  tex_code_break_column = lyxrc->ascii_linelen;
else
  tex_code_break_column = 0;

        LyXTextClass *tclass = lyxstyle.TextClass(params.textclass);

FilePtr file(filename, FilePtr::write);
if (!file()) {
  WriteFSAlert(_("Error: Cannot write file:"),filename);
  return;
}

// validate the buffer.
lyxerr.debug(" Validating buffer...", Error::LATEX);
LaTeXFeatures features(tclass->number_of_defined_layouts);
validate(features);
lyxerr.debug(" Buffer validation done.", Error::LATEX);

texrow.reset();
// The starting paragraph of the coming rows is the
// first paragraph of the document. (Asger)
texrow.start(paragraph, 0);

LString userName(getUserName());
LString LFile;

if (!only_body) {
  LFile += "%% This LaTeX-file was created by <";
  LFile += userName + "> " + (char*)date();
  LFile += "%% LyX 1.0 (C) 1995-1999 by Matthias Ettrich and the LyX Team\n";
  LFile += "\n%% Do not edit this file unless you know what you are doing.\n";
  texrow.newline();
  texrow.newline();
  texrow.newline();
  texrow.newline();
}
lyxerr.debug("lyx header finished");
// There are a few differences between nice LaTeX and usual files:
// usual is \batchmode, uses \listfiles and has a
// special input@path to allow the including of figures
// with either \input or \includegraphics (what figinsets do).
// batchmode is not set if there is a tex_code_break_column.
// In this case somebody is interested in the generated LaTeX,
// so this is OK. input@path is set when the actual parameter
// original_path is set. This is done for usual tex-file, but not
// for nice-latex-file. (Matthias 250696)
if (!only_body) {
  if (!nice){
   // code for usual, NOT nice-latex-file
   LFile += "\\batchmode\n"; // changed
   // from \nonstopmode
   texrow.newline();
   LFile += "\\listfiles\n";
   texrow.newline();
  }
  if (!original_path.empty()) {
   LFile += "\\makeatletter\n";
   texrow.newline();
   LFile += "\\def\\input@path{{" + original_path
     + "/}}\n";
   texrow.newline();
   LFile += "\\makeatother\n";
   texrow.newline();
  }

  LFile += "\\documentclass";

  LString options; // the document class options.

  if (tclass->opt_fontsize.tokenPos('|',params.fontsize) >= 0) {
   // only write if existing in list (and not default)
   options += params.fontsize;
   options += "pt,";
  }


  if (!params.use_geometry &&
      (params.paperpackage == PACKAGE_NONE)) {
   switch (params.papersize) {
   case PAPER_A4PAPER:
    options += "a4paper,";
    break;
   case PAPER_USLETTER:
    options += "letterpaper,";
    break;
   case PAPER_A5PAPER:
    options += "a5paper,";
    break;
   case PAPER_B5PAPER:
    options += "b5paper,";
    break;
   case PAPER_EXECUTIVEPAPER:
    options += "executivepaper,";
    break;
   case PAPER_LEGALPAPER:
    options += "legalpaper,";
    break;
   }
  }

  // if needed
  if (params.sides != tclass->sides) {
   if (params.sides == 2)
    options += "twoside,";
   else
    options += "oneside,";
  }

  // if needed
  if (params.columns != tclass->columns) {
   if (params.columns == 2)
    options += "twocolumn,";
   else
    options += "onecolumn,";
  }

  if (!params.use_geometry && params.orientation == ORIENTATION_LANDSCAPE)
   options += "landscape,";

  // language should be a parameter to \documentclass
  if (params.language != "default") {
   options += params.language + ',';
  }

  // the user-defined options
  if (!params.options.empty()) {
   options += params.options + ',';
  }

  if (!options.empty()){
   options.strip(',');
   LFile += '[';
   LFile += options;
   LFile += ']';
  }

  LFile += '{';
  LFile += lyxstyle.LatexnameOfClass(params.textclass);
  LFile += "}\n";
  texrow.newline();
  // end of \documentclass defs

  // this one is not per buffer
  if (lyxrc->fontenc != "default") {
   LFile += "\\usepackage[" + lyxrc->fontenc
     + "]{fontenc}\n";
   texrow.newline();
  }
  if (params.inputenc != "default") {
   LFile += "\\usepackage[" + params.inputenc
     + "]{inputenc}\n";
   texrow.newline();
  }
  if (params.fonts != "default") {
   LFile += "\\usepackage{" + params.fonts + "}\n";
   texrow.newline();
  }

  /* at the very beginning the text parameters */
  if (params.paperpackage != PACKAGE_NONE) {
   switch (params.paperpackage) {
   case PACKAGE_A4:
    LFile += "\\usepackage{a4}\n";
    texrow.newline();
    break;
   case PACKAGE_A4WIDE:
    LFile += "\\usepackage{a4wide}\n";
    texrow.newline();
    break;
   case PACKAGE_WIDEMARGINSA4:
    LFile += "\\usepackage[widemargins]{a4}\n";
    texrow.newline();
    break;
   }
  }
  if (params.use_geometry) {
   LFile += "\\usepackage{geometry}\n";
   texrow.newline();
   LFile += "\\geometry{verbose";
   if (params.orientation == ORIENTATION_LANDSCAPE)
    LFile += ",landscape";
   switch (params.papersize2) {
   case VM_PAPER_CUSTOM:
    if (!params.paperwidth.empty())
     LFile += ",paperwidth="
       + params.paperwidth;
    if (!params.paperheight.empty())
     LFile += ",paperheight="
       + params.paperheight;
    break;
   case VM_PAPER_USLETTER:
    LFile += ",letterpaper";
    break;
   case VM_PAPER_USLEGAL:
    LFile += ",legalpaper";
    break;
   case VM_PAPER_USEXECUTIVE:
    LFile += ",executivepaper";
    break;
   case VM_PAPER_A3:
    LFile += ",a3paper";
    break;
   case VM_PAPER_A4:
    LFile += ",a4paper";
    break;
   case VM_PAPER_A5:
    LFile += ",a5paper";
    break;
   case VM_PAPER_B3:
    LFile += ",b3paper";
    break;
   case VM_PAPER_B4:
    LFile += ",b4paper";
    break;
   case VM_PAPER_B5:
    LFile += ",b5paper";
    break;
   }
   if (!params.topmargin.empty())
    LFile += ",tmargin=" + params.topmargin;
   if (!params.bottommargin.empty())
    LFile += ",bmargin=" + params.bottommargin;
   if (!params.leftmargin.empty())
    LFile += ",lmargin=" + params.leftmargin;
   if (!params.rightmargin.empty())
    LFile += ",rmargin=" + params.rightmargin;
   if (!params.headheight.empty())
    LFile += ",headheight=" + params.headheight;
   if (!params.headsep.empty())
    LFile += ",headsep=" + params.headsep;
   if (!params.footskip.empty())
    LFile += ",footskip=" + params.footskip;
   LFile += "}\n";
   texrow.newline();
  }
  if (params.use_amsmath
      && !lyxstyle.LatexnameOfClass(params.textclass).prefixIs("ams")) {
   LFile += "\\usepackage{amsmath}\n";
  }

  if (tclass->opt_pagestyle.tokenPos('|',params.pagestyle) >= 0) {
   if (params.pagestyle == "fancy") {
    LFile += "\\usepackage{fancyhdr}\n";
    texrow.newline();
   }
   LFile += "\\pagestyle{" + params.pagestyle + "}\n";
   texrow.newline();
  }

  // We try to load babel late, in case it interferes
  // with other packages.
  if (params.language != "default") {
   LFile += "\\usepackage{babel}\n";
   texrow.newline();
  }

  if (params.secnumdepth != tclass->secnumdepth) {
   LFile += "\\setcounter{secnumdepth}{";
   LFile += params.secnumdepth;
   LFile += "}\n";
   texrow.newline();
  }
  if (params.tocdepth != tclass->tocdepth) {
   LFile += "\\setcounter{tocdepth}{";
   LFile += params.tocdepth;
   LFile += "}\n";
   texrow.newline();
  }

  if (params.paragraph_separation) {
   switch (params.defskip.kind()) {
   case VSpace::SMALLSKIP:
    LFile += "\\setlength\\parskip{\\smallskipamount}\n";
    break;
   case VSpace::MEDSKIP:
    LFile += "\\setlength\\parskip{\\medskipamount}\n";
    break;
   case VSpace::BIGSKIP:
    LFile += "\\setlength\\parskip{\\bigskipamount}\n";
    break;
   case VSpace::LENGTH:
    LFile += "\\setlength\\parskip{"
      + params.defskip.length().asLatexString()
      + "}\n";
    break;
   default: // should never happen // Then delete it.
    LFile += "\\setlength\\parskip{\\medskipamount}\n";
    break;
   }
   texrow.newline();

   LFile += "\\setlength\\parindent{0pt}\n";
   texrow.newline();
  }

  // Write out what we've generated so far...and reset LFile
  fwrite(LFile.c_str(), sizeof(char), LFile.length(), file);
  LFile.clean();

  // Now insert the LyX specific LaTeX commands...
  LString preamble, tmppreamble;

  // The optional packages;
  preamble = features.getPackages(params);

  // this might be useful...
  preamble += "\n\\makeatletter\n\n";

  // Some macros LyX will need
  tmppreamble = features.getMacros(params);

  if (!tmppreamble.empty()) {
   preamble += "\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% "
    "LyX specific LaTeX commands.\n"
    + tmppreamble + '\n';
  }

  // the text class specific preamble
  tmppreamble = features.getTClassPreamble(params);
  if (!tmppreamble.empty()) {
   preamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% "
    "Textclass specific LaTeX commands.\n"
    + tmppreamble + '\n';
  }

  /* the user-defined preamble */
  if (!params.preamble.empty()) {
   preamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% "
    "User specified LaTeX commands.\n"
    + params.preamble + '\n';
  }

  preamble += "\\makeatother\n\n";

  // Itemize bullet settings need to be last in case the user
  // defines their own bullets that use a package included
  // in the user-defined preamble -- ARRae
  for (int i = 0; i < 4; ++i) {
   if (params.user_defined_bullets[i] != ITEMIZE_DEFAULTS[i]) {
    preamble += "\\renewcommand\\labelitemi";
    switch (i) {
     // `i' is one less than the item to modify
    case 0:
     break;
    case 1:
     preamble += 'i';
     break;
    case 2:
     preamble += "ii";
     break;
    case 3:
     preamble += 'v';
     break;
    }
    preamble += "[0]{" + params.user_defined_bullets[i].getText() + "}\n";
   }
  }

  for (int j = preamble.countChar('\n'); j-- ;) {
   texrow.newline();
  }

  // A bit faster than printing a char at a time I think.
  fwrite(preamble.c_str(), sizeof(char),
         preamble.length(), file);

  // make the body.
  LFile += "\\begin{document}\n\n";
  texrow.newline();
  texrow.newline();
} // only_body
lyxerr.debug("preamble finished, now the body.");

bool was_title = false;
bool already_title = false;
LString ftnote;
TexRow ft_texrow;
int ftcount = 0;
int loop_count = 0;

LyXParagraph *par = paragraph;

// if only_body
while (par) {
  ++loop_count;
  if (par->IsDummy())
   lyxerr.debug("Error in MakeLateXFile.", Error::LATEX);
  LyXLayout * layout = lyxstyle.Style(params.textclass,
          par->layout);

         if (layout->intitle) {
   if (already_title) {
    lyxerr.print("Error in MakeLatexFile: You"
          " should not mix title layouts"
          " with normal ones.");
   } else
    was_title = true;
         } else if (was_title && !already_title) {
   LFile += "\\maketitle\n";
   texrow.newline();
   already_title = true;
   was_title = false;
  }
  // We are at depth 0 so we can just use
  // ordinary \footnote{} generation
  // flag this with ftcount
  ftcount = -1;
  if (layout->isEnvironment()
                    || par->pextra_type != PEXTRA_NONE) {
   par = par->TeXEnvironment(LFile, texrow,
        ftnote, ft_texrow, ftcount);
  } else {
   par = par->TeXOnePar(LFile, texrow,
          ftnote, ft_texrow, ftcount);
  }

  // Write out what we've generated...and reset LFile
  if (ftcount >= 1) {
   if (ftcount > 1) {
    LFile += "\\addtocounter{footnote}{-";
    LFile += ftcount - 1;
    LFile += '}';
   }
   LFile += ftnote;
   texrow += ft_texrow;
   ftnote.clean();
   ft_texrow.reset();
   ftcount = 0;
  }
  if (loop_count == 2) {
   // fwrite()ing every second time through the loop
   // gains a few extra % of speed; going higher than
   // 2 will slow things down again.  I'll look at
   // LFile.length() in a future revision.  ARRae
   fwrite(LFile.c_str(), sizeof(char),
          LFile.length(), file);
   LFile.clean();
   loop_count = 0;
  }
}

if (!only_body) {
  LFile += "\\end{document}\n";
  texrow.newline();

  lyxerr.debug("makeLaTeXFile...done", Error::LATEX);
} else {
  lyxerr.debug("LaTeXFile for inclusion made.", Error::LATEX);
}

// Just to be sure. (Asger)
texrow.newline();

// Write out what we've generated...and reset LFile
fwrite(LFile.c_str(), sizeof(char), LFile.length(), file);
LFile.clean();

// tex_code_break_column's value is used to decide
// if we are in batchmode or not (within mathed_write()
// in math_write.C) so we must set it to a non-zero
// value when we leave otherwise we save incorrect .lyx files.
tex_code_break_column = lyxrc->ascii_linelen;

if (file.close()) {
  WriteFSAlert(_("Error! Could not close file properly:"), filename);
}
lyxerr.debug("Finished making latex file.");
}

bool Buffer::isLatex()
{
return lyxstyle.TextClass(params.textclass)->output_type == LATEX;
}

bool Buffer::isLinuxDoc()
{
return lyxstyle.TextClass(params.textclass)->output_type == LINUXDOC;
}

void Buffer::sgmlOpenTag(FILE * file,int depth,LString & latexname)
{
static char *space[] = {" "," "," "," "," "," "," ",
    " "," "," "," "};

fprintf(file,"\n%s<%s>",space[depth],latexname.c_str());
}

void Buffer::sgmlCloseTag(FILE * file,int depth,LString & latexname)
{
static char *space[] = {" "," "," "," "," "," "," ",
    " "," "," "," "};

fprintf(file,"\n%s",space[depth],latexname.c_str());
}

void Buffer::makeLinuxDocFile(LString const & filename, int column)
{
LyXParagraph *par = paragraph;

LString top_element=lyxstyle.LatexnameOfClass(params.textclass);
LString environment_stack[10];
        LString item_name;

int depth=0;              /* paragraph depth */

FilePtr file(filename, FilePtr::write);
tex_code_break_column = column;

if (!file()) {
  WriteAlert(_("LYX_ERROR:"), _("Cannot write file"), filename);
  return;
}

//ResetTexRow();
texrow.reset();

if (params.preamble.empty()) {
  fprintf(file, "\n\n");
}
else {
  fprintf(file, "\n\n",
   params.preamble.c_str() );
}

        LString userName(getUserName());
fprintf(file, "\n", userName.c_str(), (char *)date());

if(params.options.empty())
  sgmlOpenTag(file,0,top_element);
else {
  LString top = top_element;
  top += " ";
  top += params.options;
  sgmlOpenTag(file,0,top);
}

while (par) {
  if (par->IsDummy()) {
   lyxerr.debug("Error in MakeLinuxDocFile.");
   par = par->next;
                } else {
   int desc_on=0;            /* description mode*/

   LyXLayout *style=lyxstyle.Style(GetCurrentTextClass(), par->layout);

   par->AutoDeleteInsets();

   /* treat <toc> as a special case for compatibility with old code */
   if (par->GetChar(0) == LYX_META_INSET) {
           Inset *inset = par->GetInset(0);
    char  lyx_code = inset->LyxCode();
    if (lyx_code ==Inset::TOC_CODE){
                                        LString temp= "toc";
                                        sgmlOpenTag(file, depth, temp);

     par = par->next;
     linuxDocHandleFootnote(file, par);
     continue;
    }
   }

   /* environment tag closing */
   for( ;depth > par->depth; depth--) {
                                sgmlCloseTag(file,depth,environment_stack[depth]);
    environment_stack[depth]="";
   }

   /* write opening SGML tags */
   switch(style->latextype) {
   case LATEX_PARAGRAPH:
           if(depth == par->depth && environment_stack[depth]!="") {
                                        sgmlCloseTag(file,depth,environment_stack[depth]);
            environment_stack[depth] = "";
     if(depth)
             depth--;
     else
             fprintf(file,"

");
    }
                                sgmlOpenTag(file,depth,style->latexname);
    break;

   case LATEX_COMMAND:
          if (depth!=0)
           LinuxDocError(par, 0, _("Error : Wrong depth for LatexType Command.\n"));

                               if (environment_stack[depth]!=""){
           sgmlCloseTag(file,depth,environment_stack[depth]);
                                       fprintf(file, "

");
                               }

          environment_stack[depth]="";
                               sgmlOpenTag(file,depth, style->latexname);
          break;

   case LATEX_ENVIRONMENT:
   case LATEX_ITEM_ENVIRONMENT:
          if(depth == par->depth && environment_stack[depth]!=style->latexname &&
           environment_stack[depth]!= "") {

                                       sgmlCloseTag(file,depth,environment_stack[depth]);
           environment_stack[depth] = "";
          }
          if (depth < par->depth) {
           depth = par->depth;
           environment_stack[depth] = "";
          }
          if (environment_stack[depth] != style->latexname) {
                                       if(depth==0) {
                                               LString temp="p";
                                               sgmlOpenTag(file,depth,temp);
                                       }
           environment_stack[depth]= style->latexname;
                                       sgmlOpenTag(file,depth,environment_stack[depth]);
          }
          if(style->latextype == LATEX_ENVIRONMENT) break;

          desc_on =(style->labeltype == LABEL_MANUAL);

                               if(desc_on)
                                       item_name="tag";
                               else
           item_name="item";

                               sgmlOpenTag(file,depth+1,item_name);
          break;
   default:
           sgmlOpenTag(file,depth,style->latexname);
    break;
   }

   SimpleLinuxDocOnePar(file, par, desc_on);

   /* write closing SGML tags */
   switch(style->latextype) {
   case LATEX_COMMAND:
   case LATEX_ENVIRONMENT:
   case LATEX_ITEM_ENVIRONMENT:
           break;
   default:
    sgmlCloseTag(file,depth,style->latexname);
    break;
   }

   par = par->next;

   linuxDocHandleFootnote(file,par);
  }
}


/* Close open tags */
for(;depth>0;depth--)
         sgmlCloseTag(file,depth,environment_stack[depth]);

if(environment_stack[depth] != "")
         sgmlCloseTag(file,depth,environment_stack[depth]);

fprintf(file, "\n\n");
sgmlCloseTag(file,0,top_element);

if (file.close()) {
  WriteFSAlert(_("Error! Could not close file properly:"),
        filename);
}
}

void Buffer::linuxDocHandleFootnote(FILE *file,LyXParagraph* &par)
{
while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
  fprintf(file," ");
  SimpleLinuxDocOnePar(file, par, 0);
  fprintf(file,"\n");
  par = par->next;
}
}

/* push a tag in a style stack */
void Buffer::push_tag(FILE *file, char const *tag,
        int& pos, char stack[5][3])
{
int j;

/* pop all previous tags */
for (j=pos; j>=0; j--)
  fprintf(file, "", stack[j]);

/* add new tag */
sprintf(stack[++pos], "%s", tag);

/* push all tags */
for (j=0; j<=pos; j++)
  fprintf(file, "<%s>", stack[j]);
}

// pop a tag from a style stack
void Buffer::pop_tag(FILE *file, char const * tag,
       int& pos, char stack[5][3])
{
int j;

// pop all tags till specified one
for (j=pos; (j>=0) && (strcmp(stack[j], tag)); j--)
  fprintf(file, "", stack[j]);

// closes the tag
fprintf(file, "", tag);

// push all tags, but the specified one
for (j=j+1; j<=pos; j++) {
  fprintf(file, "<%s>", stack[j]);
  strcpy(stack[j-1], stack[j]);
}
pos --;
}

/* handle internal paragraph parsing -- layout already processed */

// checks, if newcol chars should be put into this line
// writes newline, if necessary.
static
void linux_doc_line_break(FILE *file, unsigned int &colcount, const unsigned int newcol)
{
colcount += newcol;
if (colcount > lyxrc->ascii_linelen) {
  fprintf(file, "\n");
  colcount = newcol; // assume write after this call
}
}

void Buffer::SimpleLinuxDocOnePar(FILE *file, LyXParagraph *par, int desc_on)
{
LyXFont font1,font2;
char c;
Inset *inset;
int main_body, j;
LyXLayout * style = lyxstyle.Style(params.textclass, par->GetLayout());

bool is_tt = false;               // typewriter font flag
bool is_bf = false;               // bold font flag
bool is_em = false;               // emphasis (italic) font flag

int stack_num = -1;          // style stack position
char stack[5][3];          // style stack
        unsigned int char_line_count = 5;     // Heuristic choice ;-)

if (style->labeltype != LABEL_MANUAL)
  main_body = 0;
else
  main_body = par->BeginningOfMainBody();

/* gets paragraph main font */
if (main_body > 0)
  font1 = style->labelfont;
else
  font1 = style->font;


/* parsing main loop */
for (int i = 0; i < par->last; i++) {

  /* handle quote tag */
  if (i == main_body && !par->IsDummy()) {
   if (main_body > 0)
    font1 = style->font;
  }

  font2 = par->getFont(i);

  /* handle <tt> tag */
  if (font1.family() != font2.family()) {
          if (font2.family() == LyXFont::TYPEWRITER_FAMILY) {
           push_tag(file, "tt", stack_num, stack);
    is_tt = true;
   } else if (is_tt) {
           pop_tag(file, "tt", stack_num, stack);
    is_tt = false;
   }
  }

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

--> maximum size reached

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

quality88%

¤ Dauer der Verarbeitung: 0.31 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

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.