]> git.lyx.org Git - lyx.git/blobdiff - src/paragraph.C
remove lowercase, better layout handling and some variable renameing
[lyx.git] / src / paragraph.C
index d3f6f779fc2bdb0ef4980cc9fb83ec774ea505e2..bcc3eb9864240f454ecbe1ed5da11cf3df279b7f 100644 (file)
@@ -4,41 +4,47 @@
  *           LyX, The Document Processor
  *      
  *           Copyright 1995 Matthias Ettrich
- *           Copyright 1995-2000 The LyX Team. 
+ *           Copyright 1995-2001 The LyX Team. 
  *
  * ====================================================== */
 
 #include <config.h>
 
 #ifdef __GNUG__
-#pragma implementation "lyxparagraph.h"
+#pragma implementation
 #endif
 
-#include <algorithm>
-#include <fstream>
-#include <csignal>
-
-#include "lyxparagraph.h"
-#include "support/textutils.h"
+#include "paragraph.h"
+#include "paragraph_pimpl.h"
 #include "lyxrc.h"
 #include "layout.h"
+#include "language.h"
 #include "tex-strings.h"
 #include "buffer.h"
 #include "bufferparams.h"
-#include "support/FileInfo.h"
-#include "support/LAssert.h"
 #include "debug.h"
 #include "LaTeXFeatures.h"
+#include "texrow.h"
+#include "BufferView.h"
+#include "encoding.h"
+#include "ParameterStruct.h"
+#include "gettext.h"
+#include "lyxtextclasslist.h"
+
 #include "insets/insetinclude.h"
 #include "insets/insetbib.h"
 #include "insets/insettext.h"
+
 #include "support/filetools.h"
-#include "lyx_gui_misc.h"
-#include "texrow.h"
+#include "support/lstrings.h"
 #include "support/lyxmanip.h"
-#include "BufferView.h"
-#include "encoding.h"
-#include "ParameterStruct.h"
+#include "support/FileInfo.h"
+#include "support/LAssert.h"
+#include "support/textutils.h"
+
+#include <algorithm>
+#include <fstream>
+#include <csignal>
 
 using std::ostream;
 using std::endl;
@@ -48,8 +54,10 @@ using std::lower_bound;
 using std::upper_bound;
 using std::reverse;
 
+using lyx::pos_type;
+
 int tex_code_break_column = 72;  // needs non-zero initialization. set later.
-// this is a bad idea, but how can LyXParagraph find its buffer to get
+// this is a bad idea, but how can Paragraph find its buffer to get
 // parameters? (JMarc)
 
 extern string bibitemWidest(Buffer const *);
@@ -67,43 +75,30 @@ Inset * minibuffer_inset;
 
 extern BufferView * current_view;
 
-// Initialization of the counter for the paragraph id's,
-// declared in lyxparagraph.h
-unsigned int LyXParagraph::paragraph_id = 0;
-
-// Initialize static member.
-ShareContainer<LyXFont> LyXParagraph::FontTable::container;
 
-
-LyXParagraph::LyXParagraph()
+Paragraph::Paragraph()
+       : pimpl_(new Paragraph::Pimpl(this))
 {
-       text.reserve(500); // is this number too big?
-       for (int i = 0; i < 10; ++i) setCounter(i , 0);
-       enumdepth = 0;
-       itemdepth = 0;
+       for (int i = 0; i < 10; ++i)
+               setCounter(i, 0);
        next_ = 0;
        previous_ = 0;
-#ifndef NEW_INSETS
-       footnoteflag = LyXParagraph::NO_FOOTNOTE;
-       footnotekind = LyXParagraph::FOOTNOTE; // should not be needed
-#endif
-
-       inset_owner = 0;
-       id_ = paragraph_id++;
-        bibkey = 0; // ale970302
-       Clear();
+       enumdepth = 0;
+       itemdepth = 0;
+       bibkey = 0; // ale970302
+       clear();
 }
 
 
-// This konstruktor inserts the new paragraph in a list.
-LyXParagraph::LyXParagraph(LyXParagraph * par)
+// This constructor inserts the new paragraph in a list.
+Paragraph::Paragraph(Paragraph * par)
+       : pimpl_(new Paragraph::Pimpl(this))
 {
-       text.reserve(500);
-       par->fitToSize();
-       
-       for (int i = 0; i < 10; ++i) setCounter(i, 0);
+       for (int i = 0; i < 10; ++i)
+               setCounter(i, 0);
        enumdepth = 0;
        itemdepth = 0;
+
        // double linked list begin
        next_ = par->next_;
        if (next_)
@@ -111,172 +106,179 @@ LyXParagraph::LyXParagraph(LyXParagraph * par)
        previous_ = par;
        previous_->next_ = this;
        // end
-#ifndef NEW_INSETS
-       footnoteflag = LyXParagraph::NO_FOOTNOTE;
-       footnotekind = LyXParagraph::FOOTNOTE;
-#endif
-       inset_owner = 0;
-       id_ = paragraph_id++;
 
-        bibkey = 0; // ale970302        
-    
-       Clear();
+       bibkey = 0; // ale970302        
+
+       clear();
 }
 
 
-void LyXParagraph::writeFile(Buffer const * buf, ostream & os,
-                            BufferParams const & bparams,
-                            char footflag, char dth) const
+Paragraph::Paragraph(Paragraph const & lp, bool same_ids)
+       : pimpl_(new Paragraph::Pimpl(*lp.pimpl_, this, same_ids))
 {
-#ifndef NEW_INSETS
-       if (footnoteflag != LyXParagraph::NO_FOOTNOTE ||
-           !previous_
-           || previous_->footnoteflag == LyXParagraph::NO_FOOTNOTE) {
-               // The beginning or the end of a footnote environment?
-               if (footflag != footnoteflag) {
-                       footflag = footnoteflag;
-                       if (footflag) {
-                               os << "\n\\begin_float "
-                                  << string_footnotekinds[footnotekind]
-                                  << " ";
-                       } else {
-                               os << "\n\\end_float ";
-                       }
-               }
-#endif
-               // The beginning or end of a deeper (i.e. nested) area?
-               if (dth != params.depth()) {
-                       if (params.depth() > dth) {
-                               while (params.depth() > dth) {
-                                       os << "\n\\begin_deeper ";
-                                       ++dth;
-                               }
-                       } else {
-                               while (params.depth() < dth) {
-                                       os << "\n\\end_deeper ";
-                                       --dth;
-                               }
-                       }
-               }
+       for (int i = 0; i < 10; ++i)
+               setCounter(i, 0);
+       enumdepth = 0;
+       itemdepth = 0;
+       next_     = 0;
+       previous_ = 0;
 
-               // First write the layout
-               os << "\n\\layout "
-                  << textclasslist.NameOfLayout(bparams.textclass, layout)
-                  << "\n";
-
-               // Maybe some vertical spaces.
-               if (params.spaceTop().kind() != VSpace::NONE)
-                       os << "\\added_space_top "
-                          << params.spaceTop().asLyXCommand() << " ";
-               if (params.spaceBottom().kind() != VSpace::NONE)
-                       os << "\\added_space_bottom "
-                          << params.spaceBottom().asLyXCommand() << " ";
-
-               // Maybe the paragraph has special spacing
-               params.spacing().writeFile(os, true);
-               
-               // The labelwidth string used in lists.
-               if (!params.labelWidthString().empty())
-                       os << "\\labelwidthstring "
-                          << params.labelWidthString() << '\n';
-
-               // Lines above or below?
-               if (params.lineTop())
-                       os << "\\line_top ";
-               if (params.lineBottom())
-                       os << "\\line_bottom ";
-
-               // Pagebreaks above or below?
-               if (params.pagebreakTop())
-                       os << "\\pagebreak_top ";
-               if (params.pagebreakBottom())
-                       os << "\\pagebreak_bottom ";
-                       
-               // Start of appendix?
-               if (params.startOfAppendix())
-                       os << "\\start_of_appendix ";
+       // this is because of the dummy layout of the paragraphs that
+       // follow footnotes
+       layout_ = lp.layout();
 
-               // Noindent?
-               if (params.noindent())
-                       os << "\\noindent ";
-                       
-               // Alignment?
-               if (params.align() != LYX_ALIGN_LAYOUT) {
-                       int h = 0;
-                       switch (params.align()) {
-                       case LYX_ALIGN_LEFT: h = 1; break;
-                       case LYX_ALIGN_RIGHT: h = 2; break;
-                       case LYX_ALIGN_CENTER: h = 3; break;
-                       default: h = 0; break;
-                       }
-                       os << "\\align " << string_align[h] << " ";
-               }
-#ifndef NO_PEXTRA
-                if (params.pextraType() != PEXTRA_NONE) {
-                        os << "\\pextra_type " << params.pextraType();
-                        if (params.pextraType() == PEXTRA_MINIPAGE) {
-                               os << " \\pextra_alignment "
-                                  << params.pextraAlignment();
-                               if (params.pextraHfill())
-                                       os << " \\pextra_hfill "
-                                          << params.pextraHfill();
-                               if (params.pextraStartMinipage())
-                                       os << " \\pextra_start_minipage "
-                                          << params.pextraStartMinipage();
-                        }
-                        if (!params.pextraWidth().empty()) {
-                               os << " \\pextra_width "
-                                  << VSpace(params.pextraWidth()).asLyXCommand();
-                        } else if (!params.pextraWidthp().empty()) {
-                               os << " \\pextra_widthp "
-                                  << params.pextraWidthp();
-                        }
-                       os << '\n';
-                }
-#endif
-#ifndef NEW_INSETS
+       // ale970302
+       if (lp.bibkey) {
+               bibkey = static_cast<InsetBibKey *>
+                       (lp.bibkey->clone(*current_view->buffer()));
        } else {
-               // Dummy layout. This means that a footnote ended.
-               os << "\n\\end_float ";
-               footflag = LyXParagraph::NO_FOOTNOTE;
+               bibkey = 0;
        }
-#endif
+       
+       // copy everything behind the break-position to the new paragraph
+       insetlist = lp.insetlist;
+       for (InsetList::iterator it = insetlist.begin();
+            it != insetlist.end(); ++it)
+       {
+               it->inset = it->inset->clone(*current_view->buffer(), same_ids);
+               // tell the new inset who is the boss now
+               it->inset->parOwner(this);
+       }
+}
+
+
+// the destructor removes the new paragraph from the list
+Paragraph::~Paragraph()
+{
+       if (previous_)
+               previous_->next_ = next_;
+       if (next_)
+               next_->previous_ = previous_;
+
+       for (InsetList::iterator it = insetlist.begin();
+            it != insetlist.end(); ++it) {
+               delete it->inset;
+       }
+
+       // ale970302
+       delete bibkey;
+
+       delete pimpl_;
+       //
+       //lyxerr << "Paragraph::paragraph_id = "
+       //       << Paragraph::paragraph_id << endl;
+}
 
+
+void Paragraph::writeFile(Buffer const * buf, ostream & os,
+                          BufferParams const & bparams,
+                          depth_type dth) const
+{
+       // The beginning or end of a deeper (i.e. nested) area?
+       if (dth != params().depth()) {
+               if (params().depth() > dth) {
+                       while (params().depth() > dth) {
+                               os << "\n\\begin_deeper ";
+                               ++dth;
+                       }
+               } else {
+                       while (params().depth() < dth) {
+                               os << "\n\\end_deeper ";
+                               --dth;
+                       }
+               }
+       }
+       
+       // First write the layout
+       os << "\n\\layout " << layout() << "\n";
+       
+       // Maybe some vertical spaces.
+       if (params().spaceTop().kind() != VSpace::NONE)
+               os << "\\added_space_top "
+                  << params().spaceTop().asLyXCommand() << " ";
+       if (params().spaceBottom().kind() != VSpace::NONE)
+               os << "\\added_space_bottom "
+                  << params().spaceBottom().asLyXCommand() << " ";
+       
+       // Maybe the paragraph has special spacing
+       params().spacing().writeFile(os, true);
+       
+       // The labelwidth string used in lists.
+       if (!params().labelWidthString().empty())
+               os << "\\labelwidthstring "
+                  << params().labelWidthString() << '\n';
+       
+       // Lines above or below?
+       if (params().lineTop())
+               os << "\\line_top ";
+       if (params().lineBottom())
+               os << "\\line_bottom ";
+       
+       // Pagebreaks above or below?
+       if (params().pagebreakTop())
+               os << "\\pagebreak_top ";
+       if (params().pagebreakBottom())
+               os << "\\pagebreak_bottom ";
+       
+       // Start of appendix?
+       if (params().startOfAppendix())
+               os << "\\start_of_appendix ";
+       
+       // Noindent?
+       if (params().noindent())
+               os << "\\noindent ";
+       
+       // Alignment?
+       if (params().align() != LYX_ALIGN_LAYOUT) {
+               int h = 0;
+               switch (params().align()) {
+               case LYX_ALIGN_LEFT: h = 1; break;
+               case LYX_ALIGN_RIGHT: h = 2; break;
+               case LYX_ALIGN_CENTER: h = 3; break;
+               default: h = 0; break;
+               }
+               os << "\\align " << string_align[h] << " ";
+       }
+       
        // bibitem  ale970302
        if (bibkey)
-               bibkey->Write(buf, os);
-
+               bibkey->write(buf, os);
+       
        LyXFont font1(LyXFont::ALL_INHERIT, bparams.language);
-
+       
        int column = 0;
-       for (size_type i = 0; i < size(); ++i) {
+       for (pos_type i = 0; i < size(); ++i) {
                if (!i) {
                        os << "\n";
                        column = 0;
                }
                
                // Write font changes
-               LyXFont font2 = GetFontSettings(bparams, i);
+               LyXFont font2 = getFontSettings(bparams, i);
                if (font2 != font1) {
+#ifndef INHERIT_LANGUAGE
                        font2.lyxWriteChanges(font1, os);
+#else
+                       font2.lyxWriteChanges(font1, bparams.language, os);
+#endif
                        column = 0;
                        font1 = font2;
                }
-
-               value_type const c = GetChar(i);
+               
+               value_type const c = getChar(i);
                switch (c) {
                case META_INSET:
                {
-                       Inset const * inset = GetInset(i);
+                       Inset const * inset = getInset(i);
                        if (inset)
-                               if (inset->DirectWrite()) {
+                               if (inset->directWrite()) {
                                        // international char, let it write
                                        // code directly so it's shorter in
                                        // the file
-                                       inset->Write(buf, os);
+                                       inset->write(buf, os);
                                } else {
                                        os << "\n\\begin_inset ";
-                                       inset->Write(buf, os);
+                                       inset->write(buf, os);
                                        os << "\n\\end_inset \n\n";
                                        column = 0;
                                }
@@ -295,7 +297,7 @@ void LyXParagraph::writeFile(Buffer const * buf, ostream & os,
                        column = 0;
                        break;
                case '.':
-                       if (i + 1 < size() && GetChar(i + 1) == ' ') {
+                       if (i + 1 < size() && getChar(i + 1) == ' ') {
                                os << ".\n";
                                column = 0;
                        } else
@@ -312,7 +314,7 @@ void LyXParagraph::writeFile(Buffer const * buf, ostream & os,
                        if (c != '\0')
                                os << c;
                        else
-                               lyxerr << "ERROR (LyXParagraph::writeFile):"
+                               lyxerr << "ERROR (Paragraph::writeFile):"
                                        " NULL char in structure." << endl;
                        ++column;
                        break;
@@ -321,106 +323,93 @@ void LyXParagraph::writeFile(Buffer const * buf, ostream & os,
        
        // now write the next paragraph
        if (next_)
-               next_->writeFile(buf, os, bparams, footflag, dth);
+               next_->writeFile(buf, os, bparams, dth);
 }
 
 
-void LyXParagraph::validate(LaTeXFeatures & features) const
+void Paragraph::validate(LaTeXFeatures & features) const
 {
        BufferParams const & bparams = features.bufferParams();
 
-#ifndef NEW_INSETS
-       // this will be useful later
-       LyXLayout const & layout =
-               textclasslist.Style(bparams.textclass, 
-                                   GetLayout());
-#endif
-       
        // check the params.
-       if (params.lineTop() || params.lineBottom())
-               features.lyxline = true;
-       if (!params.spacing().isDefault())
-               features.setspace = true;
+       if (params().lineTop() || params().lineBottom())
+               features.require("lyxline");
+       if (!params().spacing().isDefault())
+               features.require("setspace");
        
        // then the layouts
-       features.layout[GetLayout()] = true;
+       features.useLayout(layout());
 
        // then the fonts
        Language const * doc_language = bparams.language;
        
-       for (FontList::const_iterator cit = fontlist.begin();
-            cit != fontlist.end(); ++cit) {
-               if ((*cit).font().noun() == LyXFont::ON) {
+       for (Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
+            cit != pimpl_->fontlist.end(); ++cit) {
+               if (cit->font().noun() == LyXFont::ON) {
                        lyxerr[Debug::LATEX] << "font.noun: "
-                                            << (*cit).font().noun()
+                                            << cit->font().noun()
                                             << endl;
-                       features.noun = true;
+                       features.require("noun");
                        lyxerr[Debug::LATEX] << "Noun enabled. Font: "
-                                            << (*cit).font().stateText(0)
+                                            << cit->font().stateText(0)
                                             << endl;
                }
-               switch ((*cit).font().color()) {
+               switch (cit->font().color()) {
                case LColor::none:
                case LColor::inherit:
                case LColor::ignore:
+                       // probably we should put here all interface colors used for
+                       // font displaying! For now I just add this ones I know of (Jug)
+               case LColor::latex:
+               case LColor::note:
                        break;
                default:
-                       features.color = true;
+                       features.require("color");
                        lyxerr[Debug::LATEX] << "Color enabled. Font: "
-                                            << (*cit).font().stateText(0)
+                                            << cit->font().stateText(0)
                                             << endl;
                }
 
-               Language const * language = (*cit).font().language();
-               if (language->babel() != doc_language->babel()) {
-                       features.UsedLanguages.insert(language);
+               Language const * language = cit->font().language();
+               if (language->babel() != doc_language->babel() &&
+                   language != ignore_language &&
+#ifdef INHERIT_LANGUAGE
+                   language != inherit_language &&
+#endif
+                   language != latex_language)
+               {
+                       features.useLanguage(language);
                        lyxerr[Debug::LATEX] << "Found language "
                                             << language->babel() << endl;
                }
        }
 
        // then the insets
+       LyXLayout const & lout = textclasslist[bparams.textclass][layout()];
+
        for (InsetList::const_iterator cit = insetlist.begin();
             cit != insetlist.end(); ++cit) {
-               if ((*cit).inset)
-                       (*cit).inset->Validate(features);
+               if (cit->inset) {
+                       cit->inset->validate(features);
+                       if (lout.needprotect &&
+                           cit->inset->lyxCode() == Inset::FOOT_CODE)
+                               features.require("NeedLyXFootnoteCode");
+               }
        }
-
-#ifndef NO_PEXTRA
-        if (params.pextraType() == PEXTRA_INDENT)
-                features.LyXParagraphIndent = true;
-        if (params.pextraType() == PEXTRA_FLOATFLT)
-                features.floatflt = true;
-#endif
-#ifndef NEW_INSETS
-        if (layout.needprotect 
-           && next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE)
-               features.NeedLyXFootnoteCode = true;
-#endif
-#ifndef NO_PEXTRA
-        if (bparams.paragraph_separation == BufferParams::PARSEP_INDENT
-            && params.pextraType() == LyXParagraph::PEXTRA_MINIPAGE)
-               features.NeedLyXMinipageIndent = true;
-#endif
-#ifndef NEW_INSETS
-       if (footnoteflag != NO_FOOTNOTE && footnotekind == ALGORITHM)
-               features.algorithm = true;
-#endif
 }
 
 
 // First few functions needed for cut and paste and paragraph breaking.
-void LyXParagraph::CopyIntoMinibuffer(Buffer const & buffer,
-                                     LyXParagraph::size_type pos) const
+void Paragraph::copyIntoMinibuffer(Buffer const & buffer, pos_type pos) const
 {
        BufferParams bparams = buffer.params;
 
-       minibuffer_char = GetChar(pos);
-       minibuffer_font = GetFontSettings(bparams, pos);
+       minibuffer_char = getChar(pos);
+       minibuffer_font = getFontSettings(bparams, pos);
        minibuffer_inset = 0;
-       if (minibuffer_char == LyXParagraph::META_INSET) {
-               if (GetInset(pos)) {
-                       minibuffer_inset = GetInset(pos)->Clone(buffer);
+       if (minibuffer_char == Paragraph::META_INSET) {
+               if (getInset(pos)) {
+                       minibuffer_inset = getInset(pos)->clone(buffer);
                } else {
                        minibuffer_inset = 0;
                        minibuffer_char = ' ';
@@ -430,15 +419,14 @@ void LyXParagraph::CopyIntoMinibuffer(Buffer const & buffer,
 }
 
 
-void LyXParagraph::CutIntoMinibuffer(BufferParams const & bparams,
-                                    LyXParagraph::size_type pos)
+void Paragraph::cutIntoMinibuffer(BufferParams const & bparams, pos_type pos)
 {
-       minibuffer_char = GetChar(pos);
-       minibuffer_font = GetFontSettings(bparams, pos);
+       minibuffer_char = getChar(pos);
+       minibuffer_font = getFontSettings(bparams, pos);
        minibuffer_inset = 0;
-       if (minibuffer_char == LyXParagraph::META_INSET) {
-               if (GetInset(pos)) {
-                       minibuffer_inset = GetInset(pos);
+       if (minibuffer_char == Paragraph::META_INSET) {
+               if (getInset(pos)) {
+                       minibuffer_inset = getInset(pos);
                        // This is a little hack since I want exactly
                        // the inset, not just a clone. Otherwise
                        // the inset would be deleted when calling Erase(pos)
@@ -447,9 +435,11 @@ void LyXParagraph::CutIntoMinibuffer(BufferParams const & bparams,
                        InsetList::iterator it =
                                lower_bound(insetlist.begin(),
                                            insetlist.end(),
-                                           search_elem, matchIT());
-                       if (it != insetlist.end() && (*it).pos == pos)
-                               (*it).inset = 0;
+                                           search_elem, Pimpl::matchIT());
+                       if (it != insetlist.end() && it->pos == pos)
+                               it->inset = 0;
+                       // the inset is not in a paragraph anymore
+                       minibuffer_inset->parOwner(0);
                } else {
                        minibuffer_inset = 0;
                        minibuffer_char = ' ';
@@ -462,15 +452,20 @@ void LyXParagraph::CutIntoMinibuffer(BufferParams const & bparams,
 }
 
 
-bool LyXParagraph::InsertFromMinibuffer(LyXParagraph::size_type pos)
+bool Paragraph::insertFromMinibuffer(pos_type pos)
 {
-       if ((minibuffer_char == LyXParagraph::META_INSET) &&
-           !InsertInsetAllowed(minibuffer_inset))
-               return false;
-       if (minibuffer_char == LyXParagraph::META_INSET)
-               InsertInset(pos, minibuffer_inset, minibuffer_font);
-       else
-               InsertChar(pos, minibuffer_char, minibuffer_font);
+       if (minibuffer_char == Paragraph::META_INSET) {
+               if (!insetAllowed(minibuffer_inset->lyxCode())) {
+                       return false;
+               }
+               insertInset(pos, minibuffer_inset, minibuffer_font);
+       } else {
+               LyXFont f = minibuffer_font;
+               if (!checkInsertChar(f)) {
+                       return false;
+               }
+               insertChar(pos, minibuffer_char, f);
+       }
        return true;
 }
 
@@ -478,254 +473,80 @@ bool LyXParagraph::InsertFromMinibuffer(LyXParagraph::size_type pos)
 
 
 
-void LyXParagraph::Clear()
+void Paragraph::clear()
 {
-       params.clear();
-       
-       layout = 0;
+       params().clear();
+
+       layout_.erase();
+
        bibkey = 0;
 }
 
 
-// the destructor removes the new paragraph from the list
-LyXParagraph::~LyXParagraph()
+void Paragraph::erase(pos_type pos)
 {
-       if (previous_)
-               previous_->next_ = next_;
-       if (next_)
-               next_->previous_ = previous_;
-
-       for (InsetList::iterator it = insetlist.begin();
-            it != insetlist.end(); ++it) {
-               delete (*it).inset;
-       }
-
-        // ale970302
-       delete bibkey;
-       //
-       //lyxerr << "LyXParagraph::paragraph_id = "
-       //       << LyXParagraph::paragraph_id << endl;
+       pimpl_->erase(pos);
 }
 
 
-void LyXParagraph::Erase(LyXParagraph::size_type pos)
+bool Paragraph::checkInsertChar(LyXFont & font)
 {
-#ifndef NEW_INSETS
-       // > because last is the next unused position, and you can 
-       // use it if you want
-       if (pos > size()) {
-               if (next_ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) 
-                       NextAfterFootnote()->Erase(pos - text.size() - 1);
-               else 
-                       lyxerr.debug() << "ERROR (LyXParagraph::Erase): "
-                               "position does not exist." << endl;
-               return;
-       }
-#else
-       Assert(pos < size());
-#endif
-#ifndef NEW_INSETS
-       if (pos < size()) { // last is free for insertation, but should be empty
-#endif
-               // if it is an inset, delete the inset entry 
-               if (text[pos] == LyXParagraph::META_INSET) {
-                       // find the entry
-                       InsetTable search_inset(pos, 0);
-                       InsetList::iterator it =
-                               lower_bound(insetlist.begin(),
-                                           insetlist.end(),
-                                           search_inset, matchIT());
-                       if (it != insetlist.end() && (*it).pos == pos) {
-                               delete (*it).inset;
-                               insetlist.erase(it);
-                       }
-               }
-
-               text.erase(text.begin() + pos);
-
-               // Erase entries in the tables.
-               FontTable search_font(pos, LyXFont());
-               
-               FontList::iterator it =
-                       lower_bound(fontlist.begin(),
-                                   fontlist.end(),
-                                   search_font, matchFT());
-               if (it != fontlist.end() && (*it).pos() == pos &&
-                   (pos == 0 || 
-                    (it != fontlist.begin() && (*(it - 1)).pos() == pos - 1))) {
-                       // If it is a multi-character font
-                       // entry, we just make it smaller
-                       // (see update below), otherwise we
-                       // should delete it.
-                       unsigned int const i = it - fontlist.begin();
-                       fontlist.erase(fontlist.begin() + i);
-                       it = fontlist.begin() + i;
-                       if (i > 0 && i < fontlist.size() &&
-                           fontlist[i - 1].font() == fontlist[i].font()) {
-                               fontlist.erase(fontlist.begin() + i - 1);
-                               it = fontlist.begin() + i - 1;
-                       }
-               }
-
-               // Update all other entries.
-               FontList::iterator fend = fontlist.end();
-               for (; it != fend; ++it)
-                       (*it).pos((*it).pos() - 1);
-
-               // Update the inset table.
-               InsetTable search_inset(pos, 0);
-               InsetList::iterator lend = insetlist.end();
-               for (InsetList::iterator it =
-                            upper_bound(insetlist.begin(),
-                                        lend,
-                                        search_inset, matchIT());
-                    it != lend; ++it)
-                       --(*it).pos;
-#ifndef NEW_INSETS
-       } else {
-               lyxerr << "ERROR (LyXParagraph::Erase): "
-                       "can't erase non-existant char." << endl;
-       }
-#endif
+       if (pimpl_->inset_owner)
+               return pimpl_->inset_owner->checkInsertChar(font);
+       return true;
 }
 
 
-void LyXParagraph::InsertChar(LyXParagraph::size_type pos,
-                             LyXParagraph::value_type c)
+void Paragraph::insertChar(pos_type pos, Paragraph::value_type c)
 {
        LyXFont const f(LyXFont::ALL_INHERIT);
-       InsertChar(pos, c, f);
+       insertChar(pos, c, f);
 }
 
 
-void LyXParagraph::InsertChar(LyXParagraph::size_type pos,
-                             LyXParagraph::value_type c,
-                             LyXFont const & font)
+void Paragraph::insertChar(pos_type pos, Paragraph::value_type c,
+                           LyXFont const & font)
 {
-#ifndef NEW_INSETS
-       // > because last is the next unused position, and you can 
-       // use it if you want
-       if (pos > size()) {
-               if (next_
-                   && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) 
-                       NextAfterFootnote()->InsertChar(pos - text.size() - 1,
-                                                       c);
-               else 
-                       lyxerr.debug() << "ERROR (LyXParagraph::InsertChar): "
-                               "position does not exist." << endl;
-               return;
-       }
-#else
-       Assert(pos <= size());
-#endif
-       text.insert(text.begin() + pos, c);
-
-       // Update the font table.
-       FontTable search_font(pos, LyXFont());
-       for (FontList::iterator it = lower_bound(fontlist.begin(),
-                                                fontlist.end(),
-                                                search_font, matchFT());
-            it != fontlist.end(); ++it)
-               (*it).pos((*it).pos() + 1);
-   
-       // Update the inset table.
-       InsetTable search_inset(pos, 0);
-       for (InsetList::iterator it = lower_bound(insetlist.begin(),
-                                                 insetlist.end(),
-                                                 search_inset, matchIT());
-            it != insetlist.end(); ++it)
-               ++(*it).pos;
-
-       SetFont(pos, font);
+       pimpl_->insertChar(pos, c, font);
 }
 
 
-void LyXParagraph::InsertInset(LyXParagraph::size_type pos,
-                              Inset * inset)
+void Paragraph::insertInset(pos_type pos, Inset * inset)
 {
        LyXFont const f(LyXFont::ALL_INHERIT);
-       InsertInset(pos, inset, f);
+       insertInset(pos, inset, f);
 }
 
 
-void LyXParagraph::InsertInset(LyXParagraph::size_type pos,
-                              Inset * inset, LyXFont const & font)
+void Paragraph::insertInset(pos_type pos, Inset * inset, LyXFont const & font)
 {
-       Assert(inset);
-       
-#ifndef NEW_INSETS
-       // > because last is the next unused position, and you can 
-       // use it if you want
-       if (pos > size()) {
-               if (next_
-                   && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) 
-                       NextAfterFootnote()
-                               ->InsertInset(pos - text.size() - 1,
-                                             inset, font);
-               else
-                       lyxerr << "ERROR (LyXParagraph::InsertInset): " 
-                               "position does not exist: " << pos << endl;
-               return;
-       }
-#else
-       Assert(pos <= size());
-#endif
-       
-       InsertChar(pos, META_INSET, font);
-       Assert(text[pos] == META_INSET);
-       
-       // Add a new entry in the inset table.
-       InsetTable search_inset(pos, 0);
-       InsetList::iterator it = lower_bound(insetlist.begin(),
-                                            insetlist.end(),
-                                            search_inset, matchIT());
-       if (it != insetlist.end() && (*it).pos == pos)
-               lyxerr << "ERROR (LyXParagraph::InsertInset): "
-                       "there is an inset in position: " << pos << endl;
-       else
-               insetlist.insert(it, InsetTable(pos, inset));
-       if (inset_owner)
-               inset->setOwner(inset_owner);
+       pimpl_->insertInset(pos, inset, font);
 }
 
 
-bool LyXParagraph::InsertInsetAllowed(Inset * inset)
+bool Paragraph::insetAllowed(Inset::Code code)
 {
-       //lyxerr << "LyXParagraph::InsertInsetAllowed" << endl;
+       //lyxerr << "Paragraph::InsertInsetAllowed" << endl;
        
-       if (inset_owner)
-               return inset_owner->InsertInsetAllowed(inset);
+       if (pimpl_->inset_owner)
+               return pimpl_->inset_owner->insetAllowed(code);
        return true;
 }
 
 
-Inset * LyXParagraph::GetInset(LyXParagraph::size_type pos)
+Inset * Paragraph::getInset(pos_type pos)
 {
-#ifndef NEW_INSETS
-       if (pos >= size()) {
-               if (next_
-                   && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) 
-                       return NextAfterFootnote()
-                               ->GetInset(pos - text.size() - 1);
-               else
-                       lyxerr << "ERROR (LyXParagraph::GetInset): "
-                               "position does not exist: "
-                              << pos << endl;
-               
-               return 0;
-       }
-#else
-       Assert(pos < size());
-#endif
+       lyx::Assert(pos < size());
+
        // Find the inset.
        InsetTable search_inset(pos, 0);
        InsetList::iterator it = lower_bound(insetlist.begin(),
                                             insetlist.end(),
-                                            search_inset, matchIT());
-       if (it != insetlist.end() && (*it).pos == pos)
-               return (*it).inset;
+                                            search_inset, Pimpl::matchIT());
+       if (it != insetlist.end() && it->pos == pos)
+               return it->inset;
 
-       lyxerr << "ERROR (LyXParagraph::GetInset): "
+       lyxerr << "ERROR (Paragraph::getInset): "
                "Inset does not exist: " << pos << endl;
        //::raise(SIGSTOP);
        
@@ -738,33 +559,19 @@ Inset * LyXParagraph::GetInset(LyXParagraph::size_type pos)
 }
 
 
-Inset const * LyXParagraph::GetInset(LyXParagraph::size_type pos) const
+Inset const * Paragraph::getInset(pos_type pos) const
 {
-#ifndef NEW_INSETS
-       if (pos >= size()) {
-               if (next_
-                   && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) 
-                       return NextAfterFootnote()
-                               ->GetInset(pos - text.size() - 1);
-               else
-                       lyxerr << "ERROR (LyXParagraph::GetInset): "
-                               "position does not exist: "
-                              << pos << endl;
+       lyx::Assert(pos < size());
 
-               return 0;
-       }
-#else
-       Assert(pos < size());
-#endif
        // Find the inset.
        InsetTable search_inset(pos, 0);
        InsetList::const_iterator cit = lower_bound(insetlist.begin(),
                                                    insetlist.end(),
-                                                   search_inset, matchIT());
-       if (cit != insetlist.end() && (*cit).pos == pos)
-               return (*cit).inset;
+                                                   search_inset, Pimpl::matchIT());
+       if (cit != insetlist.end() && cit->pos == pos)
+               return cit->inset;
 
-       lyxerr << "ERROR (LyXParagraph::GetInset): "
+       lyxerr << "ERROR (Paragraph::GetInset): "
                "Inset does not exist: " << pos << endl;
        //::raise(SIGSTOP);
        //text[pos] = ' '; // WHY!!! does this set the pos to ' '????
@@ -777,75 +584,37 @@ Inset const * LyXParagraph::GetInset(LyXParagraph::size_type pos) const
 
 
 // Gets uninstantiated font setting at position.
-// Optimized after profiling. (Asger)
-#ifndef NEW_INSETS
-LyXFont const LyXParagraph::GetFontSettings(BufferParams const & bparams,
-                                     LyXParagraph::size_type pos) const
-{
-       if (pos < size()) {
-               FontTable search_font(pos, LyXFont());
-               FontList::const_iterator cit = lower_bound(fontlist.begin(),
-                                                   fontlist.end(),
-                                                   search_font, matchFT());
-               if (cit != fontlist.end())
-                       return (*cit).font();
-       }
-       // > because last is the next unused position, and you can 
-       // use it if you want
-       else if (pos > size()) {
-               if (next_
-                   && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) 
-                       return NextAfterFootnote()
-                               ->GetFontSettings(bparams,
-                                                 pos - text.size() - 1);
-               else
-                       // Why is it an error to ask for the font of a
-                       // position that does not exist? Would it be
-                       // enough for this to be enabled on debug?
-                       // We want strict error checking, but it's ok to only
-                       // have it when debugging. (Asger)
-                       lyxerr << "ERROR (LyXParagraph::GetFontSettings): "
-                               "position does not exist. "
-                              << pos << " (" << static_cast<int>(pos)
-                              << ")" << endl;
-       } else if (pos > 0) {
-               return GetFontSettings(bparams, pos - 1);
-       }
-
-       return LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams));
-}
-#else
-LyXFont const LyXParagraph::GetFontSettings(BufferParams const & bparams,
-                                           LyXParagraph::size_type pos) const
+LyXFont const Paragraph::getFontSettings(BufferParams const & bparams,
+                                         pos_type pos) const
 {
-       Assert(pos <= size());
-       FontTable search_font(pos, LyXFont());
-       FontList::const_iterator cit = lower_bound(fontlist.begin(),
-                                                  fontlist.end(),
-                                                  search_font, matchFT());
-       if (cit != fontlist.end())
-               return (*cit).font();
-       
-       if (pos == size() && size())
-               return GetFontSettings(bparams, pos - 1);
+       lyx::Assert(pos <= size());
        
-       return LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams));
-}
+       Pimpl::FontTable search_font(pos, LyXFont());
+       Pimpl::FontList::const_iterator cit = lower_bound(pimpl_->fontlist.begin(),
+                                                  pimpl_->fontlist.end(),
+                                                  search_font, Pimpl::matchFT());
+       LyXFont retfont;
+       if (cit != pimpl_->fontlist.end()) {
+               retfont = cit->font();
+       } else if (pos == size() && size()) {
+               retfont = getFontSettings(bparams, pos - 1);
+       } else
+               retfont = LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams));
+#ifdef INHERIT_LANGUAGE
+       if (retfont.language() == inherit_language)
+               retfont.setLanguage(bparams.language);
 #endif
 
+       return retfont;
+}
+
 
 // Gets uninstantiated font setting at position 0
-LyXFont const LyXParagraph::GetFirstFontSettings() const
+LyXFont const Paragraph::getFirstFontSettings() const
 {
-       if (size() > 0) {
-               if (!fontlist.empty())
-                       return fontlist[0].font();
-       }
+       if (size() > 0 && !pimpl_->fontlist.empty())
+               return pimpl_->fontlist[0].font();
        
-#ifndef NEW_INSETS
-       else if (next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE) 
-               return NextAfterFootnote()->GetFirstFontSettings();
-#endif
        return LyXFont(LyXFont::ALL_INHERIT);
 }
 
@@ -857,77 +626,85 @@ LyXFont const LyXParagraph::GetFirstFontSettings() const
 // the true picture of the buffer. (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 const LyXParagraph::getFont(BufferParams const & bparams,
-                             LyXParagraph::size_type pos) const
+LyXFont const Paragraph::getFont(BufferParams const & bparams,
+                                pos_type pos) const
 {
-       LyXFont tmpfont;
-       LyXLayout const & layout =
-               textclasslist.Style(bparams.textclass, 
-                                   GetLayout());
-       LyXParagraph::size_type main_body = 0;
-       if (layout.labeltype == LABEL_MANUAL)
-               main_body = BeginningOfMainBody();
-
-       if (pos >= 0) {
-               LyXFont layoutfont;
-               if (pos < main_body)
-                       layoutfont = layout.labelfont;
-               else
-                       layoutfont = layout.font;
-               tmpfont = GetFontSettings(bparams, pos);
-               tmpfont.realize(layoutfont);
-       } else {
-               // process layoutfont for pos == -1 and labelfont for pos < -1
-               if (pos == -1)
-                       tmpfont = layout.font;
-               else
-                       tmpfont = layout.labelfont;
-               tmpfont.setLanguage(getParLanguage(bparams));
-       }
+       lyx::Assert(pos >= 0);
+       
+       LyXLayout const & lout =
+               textclasslist[bparams.textclass][layout()];
+       pos_type main_body = 0;
+       if (lout.labeltype == LABEL_MANUAL)
+               main_body = beginningOfMainBody();
+
+       LyXFont layoutfont;
+       if (pos < main_body)
+               layoutfont = lout.labelfont;
+       else
+               layoutfont = lout.font;
+       
+       LyXFont tmpfont = getFontSettings(bparams, pos);
+#ifndef INHERIT_LANGUAGE
+       tmpfont.realize(layoutfont);
+#else
+       tmpfont.realize(layoutfont, bparams.language);
+#endif
+
+       return pimpl_->realizeFont(tmpfont, bparams);
+}
+
+
+LyXFont const Paragraph::getLabelFont(BufferParams const & bparams) const
+{
+       LyXLayout const & lout =
+               textclasslist[bparams.textclass][layout()];
+       
+       LyXFont tmpfont = lout.labelfont;
+       tmpfont.setLanguage(getParLanguage(bparams));
+
+       return pimpl_->realizeFont(tmpfont, bparams);
+}
 
-       // check for environment font information
-       char par_depth = GetDepth();
-       LyXParagraph const * par = this;
-       while (par && par_depth && !tmpfont.resolved()) {
-               par = par->DepthHook(par_depth - 1);
-               if (par) {
-                       tmpfont.realize(textclasslist.
-                                       Style(bparams.textclass,
-                                             par->GetLayout()).font);
-                       par_depth = par->GetDepth();
-               }
-       }
 
-       tmpfont.realize(textclasslist
-                       .TextClass(bparams.textclass)
-                       .defaultfont());
-       return tmpfont;
+LyXFont const Paragraph::getLayoutFont(BufferParams const & bparams) const
+{
+       LyXLayout const & lout =
+               textclasslist[bparams.textclass][layout()];
+
+       LyXFont tmpfont = lout.font;
+       tmpfont.setLanguage(getParLanguage(bparams));
+
+       return pimpl_->realizeFont(tmpfont, bparams);
 }
 
 
 /// Returns the height of the highest font in range
 LyXFont::FONT_SIZE
-LyXParagraph::HighestFontInRange(LyXParagraph::size_type startpos,
-                                LyXParagraph::size_type endpos) const
+Paragraph::highestFontInRange(pos_type startpos, pos_type endpos,
+                             LyXFont::FONT_SIZE const def_size) const
 {
+       if (pimpl_->fontlist.empty())
+               return def_size;
+
        LyXFont::FONT_SIZE maxsize = LyXFont::SIZE_TINY;
-       if (fontlist.empty())
-               return maxsize;
-
-       FontTable end_search(endpos, LyXFont());
-       FontList::const_iterator end_it = lower_bound(fontlist.begin(),
-                                                     fontlist.end(),
-                                                     end_search, matchFT());
-       if (end_it != fontlist.end())
+       Pimpl::FontTable end_search(endpos, LyXFont());
+       Pimpl::FontList::const_iterator end_it =
+               lower_bound(pimpl_->fontlist.begin(),
+                           pimpl_->fontlist.end(),
+                           end_search, Pimpl::matchFT());
+       if (end_it != pimpl_->fontlist.end())
                ++end_it;
 
-       FontTable start_search(startpos, LyXFont());
-       for (FontList::const_iterator cit =
-                    lower_bound(fontlist.begin(),
-                                fontlist.end(),
-                                start_search, matchFT());
-            cit != end_it; ++cit) {
-               LyXFont::FONT_SIZE size = (*cit).font().size();
+       Pimpl::FontTable start_search(startpos, LyXFont());
+       Pimpl::FontList::const_iterator cit =
+               lower_bound(pimpl_->fontlist.begin(),
+                           pimpl_->fontlist.end(),
+                           start_search, Pimpl::matchFT());
+       
+       for (; cit != end_it; ++cit) {
+               LyXFont::FONT_SIZE size = cit->font().size();
+               if (size == LyXFont::INHERIT_SIZE)
+                       size = def_size;
                if (size > maxsize && size <= LyXFont::SIZE_HUGER)
                        maxsize = size;
        }
@@ -935,73 +712,10 @@ LyXParagraph::HighestFontInRange(LyXParagraph::size_type startpos,
 }
 
 
-#ifndef NEW_INSETS
-LyXParagraph::value_type
-LyXParagraph::GetChar(LyXParagraph::size_type pos) const
-{
-       Assert(pos >= 0);
-       
-       if (pos < size()) {
-               return text[pos];
-       }
-       
-       // > because last is the next unused position, and you can 
-       // use it if you want
-       else if (pos > size()) {
-               if (next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE) 
-                       return NextAfterFootnote()
-                               ->GetChar(pos - text.size() - 1);
-               else {
-                       lyxerr << "ERROR (LyXParagraph::GetChar const): "
-                               "position does not exist."
-                              << pos << " (" << static_cast<int>(pos)
-                              << ")\n";
-                       Assert(false);
-               }
-               return '\0';
-       } else {
-               // We should have a footnote environment.
-               if (!next_ || next_->footnoteflag == LyXParagraph::NO_FOOTNOTE) {
-                       // Notice that LyX does request the
-                       // last char from time to time. (Asger)
-                       //lyxerr << "ERROR (LyXParagraph::GetChar): "
-                       //      "expected footnote." << endl;
-                       return '\0';
-               }
-               switch (next_->footnotekind) {
-               case LyXParagraph::FOOTNOTE:
-                       return LyXParagraph::META_FOOTNOTE;
-               case LyXParagraph::MARGIN:
-                       return LyXParagraph::META_MARGIN;
-               case LyXParagraph::FIG:
-               case LyXParagraph::WIDE_FIG:
-                       return LyXParagraph::META_FIG;
-               case LyXParagraph::TAB:
-               case LyXParagraph::WIDE_TAB:
-                       return LyXParagraph::META_TAB;
-               case LyXParagraph::ALGORITHM:
-                       return LyXParagraph::META_ALGORITHM;
-               }
-               return '\0'; // to shut up gcc
-       }
-}
-#else
-LyXParagraph::value_type
-LyXParagraph::GetChar(LyXParagraph::size_type pos) const
-{
-       Assert(pos <= size());
-       if (!size() || pos == size()) return '\0';
-       
-       return text[pos];
-}
-#endif
-
-
-LyXParagraph::value_type
-LyXParagraph::GetUChar(BufferParams const & bparams,
-                      LyXParagraph::size_type pos) const
+Paragraph::value_type
+Paragraph::getUChar(BufferParams const & bparams, pos_type pos) const
 {
-       value_type c = GetChar(pos);
+       value_type c = getChar(pos);
        if (!lyxrc.rtl_support)
                return c;
 
@@ -1032,134 +746,16 @@ LyXParagraph::GetUChar(BufferParams const & bparams,
                uc = '<';
                break;
        }
-       if (uc != c && GetFontSettings(bparams, pos).isRightToLeft())
+       if (uc != c && getFontSettings(bparams, pos).isRightToLeft())
                return uc;
        else
                return c;
 }
 
 
-// return an string of the current word, and the end of the word in lastpos.
-string const LyXParagraph::GetWord(LyXParagraph::size_type & lastpos) const
+void Paragraph::setFont(pos_type pos, LyXFont const & font)
 {
-       Assert(lastpos >= 0);
-
-       // the current word is defined as starting at the first character
-       // from the immediate left of lastpospos which meets the definition
-       // of IsLetter(), continuing to the last character to the right
-       // of this meeting IsLetter.
-
-       string theword;
-
-       // grab a word
-               
-       // move back until we have a letter
-
-       //there's no real reason to have firstpos & lastpos as
-       //separate variables as this is written, but maybe someon
-       // will want to return firstpos in the future.
-
-       //since someone might have typed a punctuation first
-       int firstpos = lastpos;
-       
-       while ((firstpos >= 0) && !IsLetter(firstpos))
-               --firstpos;
-
-       // now find the beginning by looking for a nonletter
-       
-       while ((firstpos>= 0) && IsLetter(firstpos))
-               --firstpos;
-
-       // the above is now pointing to the preceeding non-letter
-       ++firstpos;
-       lastpos = firstpos;
-
-       // so copy characters into theword  until we get a nonletter
-       // note that this can easily exceed lastpos, wich means
-       // that if used in the middle of a word, the whole word
-       // is included
-
-       while (IsLetter(lastpos)) theword += GetChar(lastpos++);
-       
-       return theword;
-}
-
-
-#ifndef NEW_INSETS
-LyXParagraph::size_type LyXParagraph::Last() const
-{
-       if (next_ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
-               return text.size() + NextAfterFootnote()->Last() + 1;
-       // the 1 is the symbol
-       // for the footnote
-       else
-               return text.size();
-}
-#endif
-
-
-#ifndef NEW_INSETS
-LyXParagraph * LyXParagraph::ParFromPos(LyXParagraph::size_type pos)
-{
-       // > because last is the next unused position, and you can 
-       // use it if you want
-       if (pos > size()) {
-               if (next_
-                   && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) 
-                       return NextAfterFootnote()
-                               ->ParFromPos(pos - text.size() - 1);
-               else
-                       lyxerr << "ERROR (LyXParagraph::ParFromPos): "
-                               "position does not exist." << endl;
-               return this;
-       } else
-               return this;
-}
-#endif
-
-
-#ifndef NEW_INSETS
-int LyXParagraph::PositionInParFromPos(LyXParagraph::size_type pos) const
-{
-       // > because last is the next unused position, and you can 
-       // use it if you want
-       if (pos > size()) {
-               if (next_
-                   && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) 
-                       return NextAfterFootnote()
-                               ->PositionInParFromPos(pos - text.size() - 1);
-               else
-                       lyxerr <<
-                               "ERROR (LyXParagraph::PositionInParFromPos): "
-                               "position does not exist." << endl;
-               return pos;
-       }
-       else
-               return pos;
-}
-#endif
-
-
-void LyXParagraph::SetFont(LyXParagraph::size_type pos,
-                          LyXFont const & font)
-{
-#ifndef NEW_INSETS
-       // > because last is the next unused position, and you can 
-       // use it if you want
-       if (pos > size()) {
-               if (next_ &&
-                   next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
-                       NextAfterFootnote()->SetFont(pos - text.size() - 1,
-                                                    font);
-               } else
-                       lyxerr << "ERROR (LyXParagraph::SetFont): "
-                               "position does not exist." << endl;
-               
-               return;
-       }
-#else
-       Assert(pos <= size());
-#endif
+       lyx::Assert(pos <= size());
 
        // First, reduce font against layout/label font
        // Update: The SetCharFont() routine in text2.C already
@@ -1168,912 +764,344 @@ void LyXParagraph::SetFont(LyXParagraph::size_type pos,
        // in a new kernel. (Asger)
        // Next search font table
 
-       FontTable search_font(pos, LyXFont());
-       FontList::iterator it = lower_bound(fontlist.begin(),
-                                           fontlist.end(),
-                                           search_font, matchFT());
-       unsigned int i = it - fontlist.begin();
-       bool notfound = it == fontlist.end();
+       Pimpl::FontTable search_font(pos, LyXFont());
+       Pimpl::FontList::iterator it = lower_bound(pimpl_->fontlist.begin(),
+                                           pimpl_->fontlist.end(),
+                                           search_font, Pimpl::matchFT());
+       unsigned int i = it - pimpl_->fontlist.begin();
+       bool notfound = it == pimpl_->fontlist.end();
 
-       if (!notfound && fontlist[i].font() == font)
+       if (!notfound && pimpl_->fontlist[i].font() == font)
                return;
 
        bool begin = pos == 0 || notfound ||
-               (i > 0 && fontlist[i-1].pos() == pos - 1);
+               (i > 0 && pimpl_->fontlist[i-1].pos() == pos - 1);
        // Is position pos is a beginning of a font block?
-       bool end = !notfound && fontlist[i].pos() == pos;
+       bool end = !notfound && pimpl_->fontlist[i].pos() == pos;
        // Is position pos is the end of a font block?
        if (begin && end) { // A single char block
-               if (i + 1 < fontlist.size() &&
-                   fontlist[i + 1].font() == font) {
+               if (i + 1 < pimpl_->fontlist.size() &&
+                   pimpl_->fontlist[i + 1].font() == font) {
                        // Merge the singleton block with the next block
-                       fontlist.erase(fontlist.begin() + i);
-                       if (i > 0 && fontlist[i - 1].font() == font)
-                               fontlist.erase(fontlist.begin() + i-1);
-               } else if (i > 0 && fontlist[i - 1].font() == font) {
+                       pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i);
+                       if (i > 0 && pimpl_->fontlist[i - 1].font() == font)
+                               pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i-1);
+               } else if (i > 0 && pimpl_->fontlist[i - 1].font() == font) {
                        // Merge the singleton block with the previous block
-                       fontlist[i - 1].pos(pos);
-                       fontlist.erase(fontlist.begin() + i);
+                       pimpl_->fontlist[i - 1].pos(pos);
+                       pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i);
                } else
-                       fontlist[i].font(font);
+                       pimpl_->fontlist[i].font(font);
        } else if (begin) {
-               if (i > 0 && fontlist[i - 1].font() == font)
-                       fontlist[i - 1].pos(pos);
+               if (i > 0 && pimpl_->fontlist[i - 1].font() == font)
+                       pimpl_->fontlist[i - 1].pos(pos);
                else
-                       fontlist.insert(fontlist.begin() + i,
-                                       FontTable(pos, font));
+                       pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i,
+                                       Pimpl::FontTable(pos, font));
        } else if (end) {
-               fontlist[i].pos(pos - 1);
-               if (!(i + 1 < fontlist.size() &&
-                     fontlist[i + 1].font() == font))
-                       fontlist.insert(fontlist.begin() + i + 1,
-                                       FontTable(pos, font));
+               pimpl_->fontlist[i].pos(pos - 1);
+               if (!(i + 1 < pimpl_->fontlist.size() &&
+                     pimpl_->fontlist[i + 1].font() == font))
+                       pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i + 1,
+                                       Pimpl::FontTable(pos, font));
        } else { // The general case. The block is splitted into 3 blocks
-               fontlist.insert(fontlist.begin() + i, 
-                               FontTable(pos - 1, fontlist[i].font()));
-               fontlist.insert(fontlist.begin() + i + 1,
-                               FontTable(pos, font));
+               pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i, 
+                               Pimpl::FontTable(pos - 1, pimpl_->fontlist[i].font()));
+               pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i + 1,
+                               Pimpl::FontTable(pos, font));
        }
 }
 
 
 
-void LyXParagraph::next(LyXParagraph * p)
+void Paragraph::next(Paragraph * p)
 {
        next_ = p;
 }
 
 
 // This function is able to hide closed footnotes.
-LyXParagraph * LyXParagraph::next()
-{
-#ifndef NEW_INSETS
-       if (next_ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
-               LyXParagraph * tmp = next_;
-               while (tmp
-                      && tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
-                       tmp = tmp->next_;
-               if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) 
-                       return tmp->next(); /* there can be more than one
-                                              footnote in a logical
-                                              paragraph */
-               else
-                       return next_;  // This should never happen!
-       } else
-#endif
-               return next_;
-}
-
-
-LyXParagraph const * LyXParagraph::next() const
-{
-#ifndef NEW_INSETS
-       if (next_ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
-               LyXParagraph * tmp = next_;
-               while (tmp
-                      && tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
-                       tmp = tmp->next_;
-               if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) 
-                       return tmp->next(); /* there can be more than one
-                                              footnote in a logical
-                                              paragraph */
-               else
-                       return next_;  // This should never happen!
-       } else
-#endif
-               return next_;
-}
-
-
-#ifndef NEW_INSETS
-LyXParagraph * LyXParagraph::NextAfterFootnote()
-{
-       if (next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
-               LyXParagraph * tmp = next_;
-               while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE)
-                       tmp = tmp->next_;
-               if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) 
-                       return tmp;   /* there can be more than one footnote
-                                        in a logical paragraph */
-               else
-                       return next_;  // This should never happen!
-       } else
-               return next_;
-}
-#endif
-
-
-#ifndef NEW_INSETS
-LyXParagraph const * LyXParagraph::NextAfterFootnote() const
+Paragraph * Paragraph::next()
 {
-       if (next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
-               LyXParagraph * tmp = next_;
-               while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE)
-                       tmp = tmp->next_;
-               if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) 
-                       return tmp;   /* there can be more than one footnote
-                                        in a logical paragraph */
-               else
-                       return next_;  // This should never happen!
-       } else
-               return next_;
-}
-#endif
-
-
-#ifndef NEW_INSETS
-LyXParagraph * LyXParagraph::PreviousBeforeFootnote()
-{
-       LyXParagraph * tmp;
-       if (previous_ && previous_->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
-               tmp = previous_;
-               while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE)
-                       tmp = tmp->previous_;
-               if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) 
-                       return tmp;    /* there can be more than one footnote
-                                         in a logical paragraph */
-               else
-                       return previous_;  // This should never happen!
-       } else
-               return previous_;
-}
-#endif
-
-
-#ifndef NEW_INSETS
-LyXParagraph * LyXParagraph::LastPhysicalPar()
-{
-       if (footnoteflag != LyXParagraph::NO_FOOTNOTE)
-               return this;
-   
-       LyXParagraph * tmp = this;
-       while (tmp->next_
-              && tmp->next_->footnoteflag != LyXParagraph::NO_FOOTNOTE)
-               tmp = tmp->NextAfterFootnote();
-   
-       return tmp;
-}
-#endif
-
-
-#ifndef NEW_INSETS
-LyXParagraph const * LyXParagraph::LastPhysicalPar() const
-{
-       if (footnoteflag != LyXParagraph::NO_FOOTNOTE)
-               return this;
-   
-       LyXParagraph const * tmp = this;
-       while (tmp->next_
-              && tmp->next_->footnoteflag != LyXParagraph::NO_FOOTNOTE)
-               tmp = tmp->NextAfterFootnote();
-   
-       return tmp;
-}
-#endif
-
-
-#ifndef NEW_INSETS
-LyXParagraph * LyXParagraph::FirstPhysicalPar()
-{
-       if (!IsDummy())
-               return this;
-       LyXParagraph * tmppar = this;
-
-       while (tmppar &&
-              (tmppar->IsDummy()
-               || tmppar->footnoteflag != LyXParagraph::NO_FOOTNOTE))
-               tmppar = tmppar->previous_;
-   
-       if (!tmppar) {
-               return this;
-       } else
-               return tmppar;
+       return next_;
 }
-#endif
 
 
-#ifndef NEW_INSETS
-LyXParagraph const * LyXParagraph::FirstPhysicalPar() const
+Paragraph const * Paragraph::next() const
 {
-       if (!IsDummy())
-               return this;
-       LyXParagraph const * tmppar = this;
-
-       while (tmppar &&
-              (tmppar->IsDummy()
-               || tmppar->footnoteflag != LyXParagraph::NO_FOOTNOTE))
-               tmppar = tmppar->previous_;
-   
-       if (!tmppar) {
-               return this;
-       } else
-               return tmppar;
+       return next_;
 }
-#endif
 
 
-void LyXParagraph::previous(LyXParagraph * p)
+void Paragraph::previous(Paragraph * p)
 {
        previous_ = p;
 }
 
 
 // This function is able to hide closed footnotes.
-LyXParagraph * LyXParagraph::previous()
+Paragraph * Paragraph::previous()
 {
-#ifndef NEW_INSETS
-       LyXParagraph * tmp = previous_;
-       if (!tmp)
-               return tmp;
-
-       if (tmp->previous_
-           && tmp->previous_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
-               tmp = tmp->previous_;
-               while (tmp
-                      && tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
-                       tmp = tmp->previous_;
-               if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) 
-                       return tmp->next_->previous();  
-
-               else
-                       return previous_; 
-       } else
-#endif
-               return previous_;
+       return previous_;
 }
 
 
 // This function is able to hide closed footnotes.
-LyXParagraph const * LyXParagraph::previous() const
+Paragraph const * Paragraph::previous() const
 {
-#ifndef NEW_INSETS
-       LyXParagraph * tmp = previous_;
-       if (!tmp)
-               return tmp;
-       if (tmp->previous_
-           && tmp->previous_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
-               tmp = tmp->previous_;
-               while (tmp
-                      && tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
-                       tmp = tmp->previous_;
-               if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) 
-                       return tmp->next_->previous();  
-
-               else
-                       return previous_;
-       } else
-#endif
-               return previous_;
+       return previous_;
 }
 
 
-#ifndef NEW_INSETS
-void LyXParagraph::BreakParagraph(BufferParams const & bparams,
-                                 LyXParagraph::size_type pos,
-                                 int flag)
-{
-       size_type i;
-       size_type j;
-       // create a new paragraph
-       size_type pos_end;
-       size_type pos_first;
-       LyXParagraph * par = ParFromPos(pos);
-       LyXParagraph * firstpar = FirstPhysicalPar();
-   
-       LyXParagraph * tmp = new LyXParagraph(par);
-
-       tmp->footnoteflag = footnoteflag;
-       tmp->footnotekind = footnotekind;
-
-       // this is an idea for a more userfriendly layout handling, I will
-       // see what the users say
-
-       // layout stays the same with latex-environments
-       if (flag) {
-               tmp->SetOnlyLayout(bparams, firstpar->layout);
-               tmp->SetLabelWidthString(firstpar->params.labelWidthString());
-       }
-
-       if (Last() > pos || !Last() || flag == 2) {
-               tmp->SetOnlyLayout(bparams, firstpar->layout);
-               tmp->params.align(firstpar->params.align());
-               tmp->SetLabelWidthString(firstpar->params.labelWidthString());
-      
-               tmp->params.lineBottom(firstpar->params.lineBottom());
-               firstpar->params.lineBottom(false);
-               tmp->params.pagebreakBottom(firstpar->params.pagebreakBottom());
-               firstpar->params.pagebreakBottom(false);
-               tmp->params.spaceBottom(firstpar->params.spaceBottom());
-               firstpar->params.spaceBottom(VSpace(VSpace::NONE));
-      
-               tmp->params.depth(firstpar->params.depth());
-               tmp->params.noindent(firstpar->params.noindent());
-
-               // copy everything behind the break-position
-               // to the new paragraph
-               pos_first = 0;
-               while (ParFromPos(pos_first) != par)
-                       ++pos_first;
-               pos_end = pos_first + par->text.size() - 1;
-
-
-               for (i = j = pos; i <= pos_end; ++i) {
-                       par->CutIntoMinibuffer(bparams, i - pos_first);
-                       if (tmp->InsertFromMinibuffer(j - pos))
-                               ++j;
-               }
-
-               tmp->fitToSize();
-
-               for (i = pos_end; i >= pos; --i)
-                       par->Erase(i - pos_first);
-
-               par->fitToSize();
-       }
-
-       // just an idea of me
-       if (!pos) {
-               tmp->params.lineTop(firstpar->params.lineTop());
-               tmp->params.pagebreakTop(firstpar->params.pagebreakTop());
-               tmp->params.spaceTop(firstpar->params.spaceTop());
-               tmp->bibkey = firstpar->bibkey;
-               firstpar->Clear();
-               // layout stays the same with latex-environments
-               if (flag) {
-                       firstpar->SetOnlyLayout(bparams, tmp->layout);
-                       firstpar->SetLabelWidthString(tmp->params.labelWidthString());
-                       firstpar->params.depth(tmp->params.depth());
-               }
-       }
-}
-#else
-void LyXParagraph::BreakParagraph(BufferParams const & bparams,
-                                 LyXParagraph::size_type pos,
+void Paragraph::breakParagraph(BufferParams const & bparams,
+                                 pos_type pos,
                                  int flag)
 {
        // create a new paragraph
-       LyXParagraph * tmp = new LyXParagraph(this);
+       Paragraph * tmp = new Paragraph(this);
+       tmp->layout(layout());
+       
+       // remember to set the inset_owner
+       tmp->setInsetOwner(inInset());
        
        // this is an idea for a more userfriendly layout handling, I will
        // see what the users say
        
        // layout stays the same with latex-environments
        if (flag) {
-               tmp->SetOnlyLayout(layout);
-               tmp->SetLabelWidthString(params.labelWidthString());
+               tmp->layout(layout());
+               tmp->setLabelWidthString(params().labelWidthString());
        }
        
        if (size() > pos || !size() || flag == 2) {
-               tmp->SetOnlyLayout(layout);
-               tmp->params.align(params.align());
-               tmp->SetLabelWidthString(params.labelWidthString());
+               tmp->layout(layout());
+               tmp->params().align(params().align());
+               tmp->setLabelWidthString(params().labelWidthString());
                
-               tmp->params.lineBottom(params.lineBottom());
-               params.lineBottom(false);
-               tmp->params.pagebreakBottom(params.pagebreakBottom());
-               params.pagebreakBottom(false);
-               tmp->params.spaceBottom(params.spaceBottom());
-               params.spaceBottom(VSpace(VSpace::NONE));
+               tmp->params().lineBottom(params().lineBottom());
+               params().lineBottom(false);
+               tmp->params().pagebreakBottom(params().pagebreakBottom());
+               params().pagebreakBottom(false);
+               tmp->params().spaceBottom(params().spaceBottom());
+               params().spaceBottom(VSpace(VSpace::NONE));
                
-               tmp->params.depth(params.depth());
-               tmp->params.noindent(params.noindent());
+               tmp->params().depth(params().depth());
+               tmp->params().noindent(params().noindent());
                
                // copy everything behind the break-position
                // to the new paragraph
-               size_type pos_end = text.size() - 1;
-               size_type i = pos;
-               size_type j = pos;
+               pos_type pos_end = size() - 1;
+               pos_type i = pos;
+               pos_type j = pos;
                for (; i <= pos_end; ++i) {
-                       CutIntoMinibuffer(bparams, i);
-                       if (tmp->InsertFromMinibuffer(j - pos))
+                       cutIntoMinibuffer(bparams, i);
+                       if (tmp->insertFromMinibuffer(j - pos))
                                ++j;
                }
-               tmp->fitToSize();
-               for (i = pos_end; i >= pos; --i)
-                       Erase(i);
-               
-               fitToSize();
+               for (i = pos_end; i >= pos; --i) {
+                       erase(i);
+               }
        }
        
        // just an idea of me
        if (!pos) {
-               tmp->params.lineTop(params.lineTop());
-               tmp->params.pagebreakTop(params.pagebreakTop());
-               tmp->params.spaceTop(params.spaceTop());
+               tmp->params().lineTop(params().lineTop());
+               tmp->params().pagebreakTop(params().pagebreakTop());
+               tmp->params().spaceTop(params().spaceTop());
                tmp->bibkey = bibkey;
-               Clear();
+               clear();
                // layout stays the same with latex-environments
                if (flag) {
-                       SetOnlyLayout(tmp->layout);
-                       SetLabelWidthString(tmp->params.labelWidthString());
-                       params.depth(tmp->params.depth());
+                       layout(tmp->layout());
+                       setLabelWidthString(tmp->params().labelWidthString());
+                       params().depth(tmp->params().depth());
                }
        }
 }
-#endif
        
 
-void LyXParagraph::MakeSameLayout(LyXParagraph const * par)
+void Paragraph::makeSameLayout(Paragraph const * par)
 {
-#ifndef NEW_INSETS
-       par = par->FirstPhysicalPar();
-       footnoteflag = par->footnoteflag;
-       footnotekind = par->footnotekind;
-#endif
-       layout = par->layout;
-       params.makeSame(par->params);
-       
-       // This can be changed after NEW_INSETS is in effect. (Lgb)
-       SetLabelWidthString(par->params.labelWidthString());
-}
-
-
-#ifndef NEW_INSETS
-LyXParagraph * LyXParagraph::FirstSelfrowPar()
-{
-       LyXParagraph * tmppar = this;
-       while (tmppar && (
-               (tmppar->IsDummy()
-                && tmppar->previous_->footnoteflag == 
-                LyXParagraph::CLOSED_FOOTNOTE)
-               || tmppar->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE))
-               tmppar = tmppar->previous_;
-   
-       if (!tmppar)
-               return this;  // This should never happen!
-       else
-               return tmppar;
+       layout(par->layout());
+       // move to pimpl?
+       params() = par->params();
 }
-#endif
 
 
-int LyXParagraph::StripLeadingSpaces(LyXTextClassList::size_type tclass) 
+int Paragraph::stripLeadingSpaces(lyx::textclass_type tclass) 
 {
-       if (textclasslist.Style(tclass, GetLayout()).free_spacing)
+       if (textclasslist[tclass][layout()].free_spacing ||
+           isFreeSpacing()) {
                return 0;
+       }
        
        int i = 0;
-#ifndef NEW_INSETS
-       if (!IsDummy()) {
-               while (Last()
-#else
-               while (size()
-#endif
-                      && (IsNewline(0) || IsLineSeparator(0))){
-                       Erase(0);
-                       ++i;
-               }
-#ifndef NEW_INSETS
+       while (size() && (isNewline(0) || isLineSeparator(0))) {
+               erase(0);
+               ++i;
        }
-#endif
-       return i;
-}
-
-
-LyXParagraph * LyXParagraph::Clone() const
-{
-       // create a new paragraph
-       LyXParagraph * result = new LyXParagraph;
-   
-       result->MakeSameLayout(this);
-
-       // this is because of the dummy layout of the paragraphs that
-       // follow footnotes
-       result->layout = layout;
 
-       result->inset_owner = inset_owner;
-   
-        // ale970302
-       if (bibkey)
-               result->bibkey = static_cast<InsetBibKey *>
-                                (bibkey->Clone(*current_view->buffer()));
-       else
-               result->bibkey = 0;
-    
-       // copy everything behind the break-position to the new paragraph
-
-       result->text = text;
-       result->fontlist = fontlist;
-       result->insetlist = insetlist;
-       for (InsetList::iterator it = result->insetlist.begin();
-            it != result->insetlist.end(); ++it)
-               (*it).inset = (*it).inset->Clone(*current_view->buffer());
-       return result;
+       return i;
 }
 
 
-bool LyXParagraph::HasSameLayout(LyXParagraph const * par) const
+bool Paragraph::hasSameLayout(Paragraph const * par) const
 {
-#ifndef NEW_INSETS
-       par = par->FirstPhysicalPar();
-#endif
-
        return 
-#ifndef NEW_INSETS
-               par->footnoteflag == footnoteflag &&
-               par->footnotekind == footnotekind &&
-#endif
-               par->layout == layout &&
-               params.sameLayout(par->params);
+               par->layout() == layout() &&
+               params().sameLayout(par->params());
 }
 
 
-void LyXParagraph::BreakParagraphConservative(BufferParams const & bparams,
-                                             LyXParagraph::size_type pos)
+void Paragraph::breakParagraphConservative(BufferParams const & bparams,
+                                          pos_type pos)
 {
-#ifndef NEW_INSETS
-       // create a new paragraph
-       LyXParagraph * par = ParFromPos(pos);
-
-       LyXParagraph * tmp = new LyXParagraph(par);
-   
-       tmp->MakeSameLayout(par);
-
-       // When can pos < Last()?
-       // I guess pos == Last() is possible.
-       if (Last() > pos) {
-               // copy everything behind the break-position to the new
-               // paragraph
-               size_type pos_first = 0;
-               while (ParFromPos(pos_first) != par)
-                       ++pos_first;
-               size_type pos_end = pos_first + par->text.size() - 1;
-
-               size_type i, j;
-               for (i = j = pos; i <= pos_end; ++i) {
-                       par->CutIntoMinibuffer(bparams, i - pos_first);
-                       if (tmp->InsertFromMinibuffer(j - pos))
-                               ++j;
-               }
-
-               tmp->fitToSize();
-
-               for (size_type i = pos_end; i >= pos; --i)
-                       par->Erase(i - pos_first);
-
-               par->fitToSize();
-       }
-#else
        // create a new paragraph
-       LyXParagraph * tmp = new LyXParagraph(this);
-       tmp->MakeSameLayout(this);
+       Paragraph * tmp = new Paragraph(this);
+       tmp->makeSameLayout(this);
 
        // When can pos > Last()?
        // I guess pos == Last() is possible.
        if (size() > pos) {
                // copy everything behind the break-position to the new
                // paragraph
-               size_type pos_end = text.size() - 1;
+               pos_type pos_end = size() - 1;
 
-               size_type i, j;
-               for (i = j = pos; i <= pos_end; ++i) {
-                       CutIntoMinibuffer(bparams, i);
-                       if (tmp->InsertFromMinibuffer(j - pos))
+               //pos_type i = pos;
+               //pos_type j = pos;
+               for (pos_type i = pos, j = pos; i <= pos_end; ++i) {
+                       cutIntoMinibuffer(bparams, i);
+                       if (tmp->insertFromMinibuffer(j - pos))
                                ++j;
                }
-
-               tmp->fitToSize();
                
-               for (size_type i = pos_end; i >= pos; --i)
-                       Erase(i);
-
-               fitToSize();
+               for (pos_type k = pos_end; k >= pos; --k) {
+                       erase(k);
+               }
        }
-#endif
 }
-   
+
 
 // Be carefull, this does not make any check at all.
 // This method has wrong name, it combined this par with the next par.
 // In that sense it is the reverse of break paragraph. (Lgb)
-void LyXParagraph::PasteParagraph(BufferParams const & bparams)
+void Paragraph::pasteParagraph(BufferParams const & bparams)
 {
        // copy the next paragraph to this one
-       LyXParagraph * the_next = next();
-   
+       Paragraph * the_next = next();
+
        // first the DTP-stuff
-#ifndef NEW_INSETS
-       LyXParagraph * firstpar = FirstPhysicalPar();
-       firstpar->params.lineBottom(the_next->params.lineBottom());
-       firstpar->params.spaceBottom(the_next->params.spaceBottom());
-       firstpar->params.pagebreakBottom(the_next->params.pagebreakBottom());
-
-       size_type pos_end = the_next->text.size() - 1;
-       size_type pos_insert = Last();
-#else
-       params.lineBottom(the_next->params.lineBottom());
-       params.spaceBottom(the_next->params.spaceBottom());
-       params.pagebreakBottom(the_next->params.pagebreakBottom());
+       params().lineBottom(the_next->params().lineBottom());
+       params().spaceBottom(the_next->params().spaceBottom());
+       params().pagebreakBottom(the_next->params().pagebreakBottom());
 
-       size_type pos_end = the_next->text.size() - 1;
-       size_type pos_insert = size();
-#endif
+       pos_type pos_end = the_next->pimpl_->size() - 1;
+       pos_type pos_insert = size();
 
        // ok, now copy the paragraph
-       size_type i, j;
-       for (i = j = 0; i <= pos_end; ++i) {
-               the_next->CutIntoMinibuffer(bparams, i);
-               if (InsertFromMinibuffer(pos_insert + j))
+       for (pos_type i = 0, j = 0; i <= pos_end; ++i) {
+               the_next->cutIntoMinibuffer(bparams, i);
+               if (insertFromMinibuffer(pos_insert + j))
                        ++j;
        }
-   
+
        // delete the next paragraph
-       LyXParagraph * ppar = the_next->previous_;
-       LyXParagraph * npar = the_next->next_;
+       Paragraph * ppar = the_next->previous_;
+       Paragraph * npar = the_next->next_;
        delete the_next;
        ppar->next(npar);
 }
 
 
-#ifndef NEW_INSETS
-void LyXParagraph::OpenFootnote(LyXParagraph::size_type pos)
-{
-       LyXParagraph * par = ParFromPos(pos);
-       par = par->next_;
-       while (par && par->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
-               par->footnoteflag = LyXParagraph::OPEN_FOOTNOTE;
-               par = par->next_;
-       }
-}
-
-
-void LyXParagraph::CloseFootnote(LyXParagraph::size_type pos)
-{
-       LyXParagraph * par = ParFromPos(pos);
-       par = par->next_;
-       while (par && par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) {
-               par->footnoteflag = LyXParagraph::CLOSED_FOOTNOTE;
-               par = par->next_;
-       }
-}
-#endif
-
-
-int LyXParagraph::GetEndLabel(BufferParams const & bparams) const
+int Paragraph::getEndLabel(BufferParams const & bparams) const
 {
-       LyXParagraph const * par = this;
-       int par_depth = GetDepth();
+       Paragraph const * par = this;
+       depth_type par_depth = getDepth();
        while (par) {
-               LyXTextClass::LayoutList::size_type layout = par->GetLayout();
+               string const & layout = par->layout();
                int const endlabeltype =
-                       textclasslist.Style(bparams.textclass,
-                                           layout).endlabeltype;
+                       textclasslist[bparams.textclass][layout].endlabeltype;
                if (endlabeltype != END_LABEL_NO_LABEL) {
-                       LyXParagraph const * last = this;
-#ifndef NEW_INSETS
-                       if (footnoteflag == NO_FOOTNOTE)
-                               last = LastPhysicalPar();
-                       else if (next_->footnoteflag == NO_FOOTNOTE)
-                               return endlabeltype;
-#else
-                       last = this;
-#endif
-
-                       if (!last || !last->next_)
+                       if (!next_)
                                return endlabeltype;
 
-                       int next_depth = last->next_->GetDepth();
+                       depth_type const next_depth = next_->getDepth();
                        if (par_depth > next_depth ||
-                           (par_depth == next_depth && layout != last->next_->GetLayout() ))
+                           (par_depth == next_depth
+                            && layout != next_->layout()))
                                return endlabeltype;
                        break;
                }
                if (par_depth == 0)
                        break;
-               par = par->DepthHook(par_depth - 1);
+               par = par->outerHook();
                if (par)
-                       par_depth = par->GetDepth();
+                       par_depth = par->getDepth();
        }
        return END_LABEL_NO_LABEL;
 }
 
 
-LyXTextClass::size_type LyXParagraph::GetLayout() const
+Paragraph::depth_type Paragraph::getDepth() const
 {
-#ifndef NEW_INSETS
-       return FirstPhysicalPar()->layout;
-#else
-       return layout;
-#endif
+       return params().depth();
 }
 
 
-char LyXParagraph::GetDepth() const
+Paragraph::depth_type Paragraph::getMaxDepthAfter(Buffer const * buffer) const
 {
-#ifndef NEW_INSETS
-       return FirstPhysicalPar()->params.depth();
-#else
-       return params.depth();
-#endif
-}
+       bool const isenv = textclasslist[buffer->params.textclass][layout()].isEnvironment();
+
+       if (isenv)
+               return params().depth() + 1;
+       else
+               return params().depth();
 
+}
 
-char LyXParagraph::GetAlign() const
+char Paragraph::getAlign() const
 {
-#ifndef NEW_INSETS
-       return FirstPhysicalPar()->params.align();
-#else
-       return params.align();
-#endif
+       return params().align();
 }
 
 
-string const & LyXParagraph::GetLabelstring() const
+string const & Paragraph::getLabelstring() const
 {
-#ifndef NEW_INSETS
-       return FirstPhysicalPar()->params.labelString();
-#else
-       return params.labelString();
-#endif
+       return params().labelString();
 }
 
 
-int LyXParagraph::GetFirstCounter(int i) const
+int Paragraph::getFirstCounter(int i) const
 {
-#ifndef NEW_INSETS
-       return FirstPhysicalPar()->counter_[i];
-#else
-       return counter_[i];
-#endif
+       return pimpl_->counter_[i];
 }
 
 
 // the next two functions are for the manual labels
-string const LyXParagraph::GetLabelWidthString() const
+string const Paragraph::getLabelWidthString() const
 {
-#ifndef NEW_INSETS
-       if (!FirstPhysicalPar()->params.labelWidthString().empty())
-               return FirstPhysicalPar()->params.labelWidthString();
-#else
-       if (!params.labelWidthString().empty())
-               return params.labelWidthString();
-#endif
+       if (!params().labelWidthString().empty())
+               return params().labelWidthString();
        else
                return _("Senseless with this layout!");
 }
 
 
-void LyXParagraph::SetLabelWidthString(string const & s)
-{
-#ifndef NEW_INSETS
-       LyXParagraph * par = FirstPhysicalPar();
-
-       par->params.labelWidthString(s);
-#else
-       params.labelWidthString(s);
-#endif
-}
-
-
-#ifndef NEW_INSETS
-void LyXParagraph::SetOnlyLayout(BufferParams const & bparams,
-                                LyXTextClass::size_type new_layout)
-{
-       LyXParagraph * par = FirstPhysicalPar();
-       LyXParagraph * ppar = 0;
-       LyXParagraph * npar = 0;
-       
-       par->layout = new_layout;
-       
-        if (par->params.pextraType() == PEXTRA_NONE) {
-                if (par->previous()) {
-                        ppar = par->previous()->FirstPhysicalPar();
-                        while(ppar
-                             && ppar->previous()
-                             && (ppar->params.depth() > par->params.depth()))
-                                ppar = ppar->previous()->FirstPhysicalPar();
-                }
-                if (par->next()) {
-                        npar = par->next()->NextAfterFootnote();
-                        while(npar
-                             && npar->next()
-                             && (npar->params.depth() > par->params.depth()))
-                                npar = npar->next()->NextAfterFootnote();
-                }
-                if (ppar && (ppar->params.pextraType() != PEXTRA_NONE)) {
-                        string p1 = ppar->params.pextraWidth();
-                       string p2 = ppar->params.pextraWidthp();
-                        ppar->SetPExtraType(bparams,
-                                           ppar->params.pextraType(),
-                                            p1, p2);
-                }
-                if ((par->params.pextraType() == PEXTRA_NONE) &&
-                    npar && (npar->params.pextraType() != PEXTRA_NONE)) {
-                        string const p1 = npar->params.pextraWidth();
-                       string const p2 = npar->params.pextraWidthp();
-                        npar->SetPExtraType(bparams, npar->params.pextraType(),
-                                            p1, p2);
-                }
-        }
-}
-#else
-void LyXParagraph::SetOnlyLayout(LyXTextClass::size_type new_layout)
+void Paragraph::setLabelWidthString(string const & s)
 {
-#if 0
-       LyXParagraph * par = this;
-       LyXParagraph * ppar = 0;
-       LyXParagraph * npar = 0;
-       
-       par->layout = new_layout;
-       
-       if (par->previous()) {
-               ppar = par->previous();
-               while(ppar
-                     && ppar->previous()
-                     && (ppar->params.depth() > par->params.depth()))
-                       ppar = ppar->previous();
-       }
-       if (par->next()) {
-               npar = par->next();
-               while(npar
-                     && npar->next()
-                     && (npar->params.depth() > par->params.depth()))
-                       npar = npar->next();
-       }
-#else
-       layout = new_layout;
-#endif
+       params().labelWidthString(s);
 }
-#endif
 
 
-#ifndef NEW_INSETS
-void LyXParagraph::SetLayout(BufferParams const & bparams,
-                            LyXTextClass::size_type new_layout)
+void Paragraph::applyLayout(string const & new_layout)
 {
-       LyXParagraph
-               * par = FirstPhysicalPar(),
-               * ppar = 0,
-               * npar = 0;
-       
-        par->layout = new_layout;
-       par->params.labelWidthString(string());
-       par->params.align(LYX_ALIGN_LAYOUT);
-       par->params.spaceTop(VSpace(VSpace::NONE));
-       par->params.spaceBottom(VSpace(VSpace::NONE));
-       par->params.spacing(Spacing(Spacing::Default));
-       
-        if (par->params.pextraType() == PEXTRA_NONE) {
-                if (par->previous()) {
-                        ppar = par->previous()->FirstPhysicalPar();
-                        while(ppar
-                             && ppar->previous()
-                             && (ppar->params.depth() > par->params.depth()))
-                                ppar = ppar->previous()->FirstPhysicalPar();
-                }
-                if (par->next()) {
-                        npar = par->next()->NextAfterFootnote();
-                        while(npar
-                             && npar->next()
-                             && (npar->params.depth() > par->params.depth()))
-                                npar = npar->next()->NextAfterFootnote();
-                }
-                if (ppar && (ppar->params.pextraType() != PEXTRA_NONE)) {
-                        string const p1 = ppar->params.pextraWidth();
-                       string const p2 = ppar->params.pextraWidthp();
-                        ppar->SetPExtraType(bparams, ppar->params.pextraType(),
-                                            p1, p2);
-                }
-                if ((par->params.pextraType() == PEXTRA_NONE) &&
-                    npar && (npar->params.pextraType() != PEXTRA_NONE)) {
-                        string const p1 = npar->params.pextraWidth();
-                       string const p2 = npar->params.pextraWidthp();
-                        npar->SetPExtraType(bparams, npar->params.pextraType(),
-                                            p1, p2);
-                }
-        }
-}
-#else
-void LyXParagraph::SetLayout(LyXTextClass::size_type new_layout)
-{
-        layout = new_layout;
-       params.labelWidthString(string());
-       params.align(LYX_ALIGN_LAYOUT);
-       params.spaceTop(VSpace(VSpace::NONE));
-       params.spaceBottom(VSpace(VSpace::NONE));
-       params.spacing(Spacing(Spacing::Default));
+       layout(new_layout);
+       params().labelWidthString(string());
+       params().align(LYX_ALIGN_LAYOUT);
+       params().spaceTop(VSpace(VSpace::NONE));
+       params().spaceBottom(VSpace(VSpace::NONE));
+       params().spacing(Spacing(Spacing::Default));
 }
-#endif
 
 
 // if the layout of a paragraph contains a manual label, the beginning of the 
@@ -2083,235 +1111,198 @@ void LyXParagraph::SetLayout(LyXTextClass::size_type new_layout)
 // because there cannot be a newline or a blank <= the beginning of the 
 // main body in TeX.
 
-int LyXParagraph::BeginningOfMainBody() const
+int Paragraph::beginningOfMainBody() const
 {
-#ifndef NEW_INSETS
-       if (FirstPhysicalPar() != this)
-               return -1;
-#endif
        // Unroll the first two cycles of the loop
        // and remember the previous character to
        // remove unnecessary GetChar() calls
-       size_type i = 0;
+       pos_type i = 0;
        if (i < size()
-           && GetChar(i) != LyXParagraph::META_NEWLINE
-               ) {
+           && getChar(i) != Paragraph::META_NEWLINE) {
                ++i;
                char previous_char = 0;
                char temp = 0; 
                if (i < size()
-                   && (previous_char = GetChar(i)) != LyXParagraph::META_NEWLINE) {
+                   && (previous_char = getChar(i)) != Paragraph::META_NEWLINE) {
                        // Yes, this  ^ is supposed to be "= " not "=="
                        ++i;
                        while (i < size()
                               && previous_char != ' '
-                              && (temp = GetChar(i)) != LyXParagraph::META_NEWLINE) {
+                              && (temp = getChar(i)) != Paragraph::META_NEWLINE) {
                                ++i;
                                previous_char = temp;
                        }
                }
        }
 
-#ifndef NEW_INSETS
-       if (i == 0 && i == size() &&
-           !(footnoteflag == LyXParagraph::NO_FOOTNOTE
-             && next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE))
-               ++i;                           /* the cursor should not jump  
-                                               * to the main body if there
-                                               * is nothing in! */
-#endif
        return i;
 }
 
 
-LyXParagraph * LyXParagraph::DepthHook(int deth)
+Paragraph * Paragraph::depthHook(depth_type depth)
 {
-       LyXParagraph * newpar = this;
-       if (deth < 0)
-               return 0;
-   
+       Paragraph * newpar = this;
+
        do {
-#ifndef NEW_INSETS
-               newpar = newpar->FirstPhysicalPar()->previous();
-#else
                newpar = newpar->previous();
-#endif
-       } while (newpar && newpar->GetDepth() > deth
-#ifndef NEW_INSETS
-                && newpar->footnoteflag == footnoteflag
-#endif
-               );
-   
+       } while (newpar && newpar->getDepth() > depth);
+
        if (!newpar) {
-               if (previous() || GetDepth())
-                       lyxerr << "ERROR (LyXParagraph::DepthHook): "
+               if (previous() || getDepth())
+                       lyxerr << "ERROR (Paragraph::DepthHook): "
                                "no hook." << endl;
                newpar = this;
        }
-#ifndef NEW_INSETS
-       return newpar->FirstPhysicalPar();
-#else
+
        return newpar;
-#endif
 }
 
 
-LyXParagraph const * LyXParagraph::DepthHook(int deth) const
+Paragraph const * Paragraph::depthHook(depth_type depth) const
 {
-       LyXParagraph const * newpar = this;
-       if (deth < 0)
-               return 0;
-   
+       Paragraph const * newpar = this;
+
        do {
-#ifndef NEW_INSETS
-               newpar = newpar->FirstPhysicalPar()->previous();
-#else
                newpar = newpar->previous();
-#endif
-       } while (newpar && newpar->GetDepth() > deth
-#ifndef NEW_INSETS
-                && newpar->footnoteflag == footnoteflag
-#endif
-               );
-   
+       } while (newpar && newpar->getDepth() > depth);
+
        if (!newpar) {
-               if (previous() || GetDepth())
-                       lyxerr << "ERROR (LyXParagraph::DepthHook): "
+               if (previous() || getDepth())
+                       lyxerr << "ERROR (Paragraph::DepthHook): "
                                "no hook." << endl;
                newpar = this;
        }
-#ifndef NEW_INSETS
-       return newpar->FirstPhysicalPar();
-#else
+
        return newpar;
-#endif
 }
 
+Paragraph * Paragraph::outerHook()
+{
+       if (!getDepth())
+               return 0;
+       return depthHook(depth_type(getDepth() - 1));
+}
 
-int LyXParagraph::AutoDeleteInsets()
+Paragraph const * Paragraph::outerHook() const
 {
-       int count = 0;
-       InsetList::size_type index = 0;
-       while (index < insetlist.size()) {
-               if (insetlist[index].inset && insetlist[index].inset->AutoDelete()) {
-                       Erase(insetlist[index].pos); 
-                       // Erase() calls to insetlist.erase(&insetlist[index])
-                       // so index shouldn't be increased.
-                       ++count;
-               } else
-                       ++index;
-       }
-       return count;
+       if (!getDepth())
+               return 0;
+       return depthHook(depth_type(getDepth() - 1));
 }
 
 
-LyXParagraph::inset_iterator
-LyXParagraph::InsetIterator(LyXParagraph::size_type pos)
+Paragraph::inset_iterator
+Paragraph::InsetIterator(pos_type pos)
 {
        InsetTable search_inset(pos, 0);
        InsetList::iterator it = lower_bound(insetlist.begin(),
                                             insetlist.end(),
-                                            search_inset, matchIT());
+                                            search_inset, Pimpl::matchIT());
        return inset_iterator(it);
 }
 
 
 // returns -1 if inset not found
-int LyXParagraph::GetPositionOfInset(Inset * inset) const
+int Paragraph::getPositionOfInset(Inset const * inset) const
 {
        // Find the entry.
        for (InsetList::const_iterator cit = insetlist.begin();
             cit != insetlist.end(); ++cit) {
-               if ((*cit).inset == inset) {
-                       return (*cit).pos;
+               if (cit->inset == inset) {
+                       return cit->pos;
                }
        }
        if (inset == bibkey)
                return 0;
 
-#ifndef NEW_INSETS
-       // Think about footnotes.
-       if (footnoteflag == LyXParagraph::NO_FOOTNOTE 
-           && next_ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
-               int const further = 
-                       NextAfterFootnote()->GetPositionOfInset(inset);
-               if (further != -1)
-                       return text.size() + 1 + further;
-       }
-#endif
        return -1;
 }
 
 
-LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf,
-                                      BufferParams const & bparams,
-                                      ostream & os, TexRow & texrow,
-                                      bool moving_arg
-#ifndef NEW_INSETS
-                                      , 
-                                      ostream & foot,
-                                      TexRow & foot_texrow,
-                                      int & foot_count
-#endif
-       )
+Paragraph * Paragraph::TeXOnePar(Buffer const * buf,
+                                 BufferParams const & bparams,
+                                 ostream & os, TexRow & texrow,
+                                 bool moving_arg)
 {
        lyxerr[Debug::LATEX] << "TeXOnePar...     " << this << endl;
-       LyXLayout const & style =
-               textclasslist.Style(bparams.textclass,
-                                   layout);
-
+       Inset const * in = inInset();
        bool further_blank_line = false;
-#ifndef NEW_INSETS
-       if (IsDummy())
-               lyxerr << "ERROR (LyXParagraph::TeXOnePar) is dummy." << endl;
-#endif
-
-       if (params.startOfAppendix()) {
-               os << "\\appendix\n";
-               texrow.newline();
-       }
+       LyXLayout style;
+       
+       // well we have to check if we are in an inset with unlimited
+       // lenght (all in one row) if that is true then we don't allow
+       // any special options in the paragraph and also we don't allow
+       // any environment other then "Standard" to be valid!
+       if ((in == 0) || !in->forceDefaultParagraphs(in)) {
+               style = textclasslist[bparams.textclass][layout()];
+
+               if (params().startOfAppendix()) {
+                       os << "\\appendix\n";
+                       texrow.newline();
+               }
 
-       if (!params.spacing().isDefault()
-           && (!previous() || !previous()->HasSameLayout(this))) {
-               os << params.spacing().writeEnvirBegin() << "\n";
-               texrow.newline();
-       }
+               if (!params().spacing().isDefault()
+                       && (!previous() || !previous()->hasSameLayout(this))) {
+                       os << params().spacing().writeEnvirBegin() << "\n";
+                       texrow.newline();
+               }
        
-       if (tex_code_break_column && style.isCommand()){
-               os << '\n';
-               texrow.newline();
-       }
+               if (tex_code_break_column && style.isCommand()) {
+                       os << '\n';
+                       texrow.newline();
+               }
 
-       if (params.pagebreakTop()) {
-               os << "\\newpage";
-               further_blank_line = true;
-       }
-       if (params.spaceTop().kind() != VSpace::NONE) {
-               os << params.spaceTop().asLatexCommand(bparams);
-               further_blank_line = true;
-       }
-      
-       if (params.lineTop()) {
-               os << "\\lyxline{\\" << getFont(bparams, 0).latexSize() << '}'
-                  << "\\vspace{-1\\parskip}";
-               further_blank_line = true;
-       }
+               if (params().pagebreakTop()) {
+                       os << "\\newpage";
+                       further_blank_line = true;
+               }
+               if (params().spaceTop().kind() != VSpace::NONE) {
+                       os << params().spaceTop().asLatexCommand(bparams);
+                       further_blank_line = true;
+               }
 
-       if (further_blank_line){
-               os << '\n';
-               texrow.newline();
+               if (params().lineTop()) {
+                       os << "\\lyxline{\\" << getFont(bparams, 0).latexSize() << '}'
+                          << "\\vspace{-1\\parskip}";
+                       further_blank_line = true;
+               }
+
+               if (further_blank_line) {
+                       os << '\n';
+                       texrow.newline();
+               }
+       } else {
+               style = textclasslist[bparams.textclass].defaultLayout();
        }
 
        Language const * language = getParLanguage(bparams);
        Language const * doc_language = bparams.language;
-       Language const * previous_language = previous_
-               ? previous_->getParLanguage(bparams) : doc_language;
-       if (language->babel() != doc_language->babel() &&
-           language->babel() != previous_language->babel()) {
-               os << subst(lyxrc.language_command_begin, "$$lang",
-                           language->babel())
-                  << endl;
-               texrow.newline();
+       Language const * previous_language = previous()
+               ? previous()->getParLanguage(bparams) : doc_language;
+
+       if (language->babel() != previous_language->babel()
+           // check if we already put language command in TeXEnvironment()
+           && !(style.isEnvironment()
+                && (!previous() || previous()->layout() != layout() ||
+                        previous()->params().depth() != params().depth())))
+       {
+               if (!lyxrc.language_command_end.empty() &&
+                   previous_language->babel() != doc_language->babel())
+               {
+                       os << subst(lyxrc.language_command_end, "$$lang",
+                                   previous_language->babel())
+                          << endl;
+                       texrow.newline();
+               }
+
+               if (lyxrc.language_command_end.empty() ||
+                   language->babel() != doc_language->babel())
+               {
+                       os << subst(lyxrc.language_command_begin, "$$lang",
+                                   language->babel())
+                          << endl;
+                       texrow.newline();
+               }
        }
 
        if (bparams.inputenc == "auto" &&
@@ -2321,7 +1312,7 @@ LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf,
                   << "}" << endl;
                texrow.newline();
        }
-       
+
        switch (style.latextype) {
        case LATEX_COMMAND:
                os << '\\'
@@ -2330,7 +1321,7 @@ LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf,
                break;
        case LATEX_ITEM_ENVIRONMENT:
                if (bibkey) {
-                       bibkey->Latex(buf, os, false, false);
+                       bibkey->latex(buf, os, false, false);
                } else
                        os << "\\item ";
                break;
@@ -2341,57 +1332,8 @@ LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf,
                break;
        }
 
-       bool need_par = SimpleTeXOnePar(buf, bparams, os, texrow, moving_arg);
+       bool need_par = simpleTeXOnePar(buf, bparams, os, texrow, moving_arg);
  
-       LyXParagraph * par = next_;
-#ifndef NEW_INSETS
-       // Spit out footnotes
-       if (lyxrc.rtl_support) {
-               if (next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE
-                   && next_->footnoteflag != footnoteflag) {
-                       LyXParagraph * p = 0;
-                       bool is_rtl = (size() > 0) 
-                               ? GetFontSettings(bparams,
-                                                 size()-1).isRightToLeft()
-                               : language->RightToLeft();
-                       if ((p = NextAfterFootnote()) != 0 &&
-                            p->size() > 0 &&
-                            p->GetFontSettings(bparams, 0).isRightToLeft() != is_rtl)
-                               is_rtl = getParLanguage(bparams)->RightToLeft();
-                       while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE
-                              && par->footnoteflag != footnoteflag) {
-                               par = par->TeXFootnote(buf, bparams,
-                                                      os, texrow, foot,
-                                                      foot_texrow, foot_count,
-                                                      is_rtl);
-                               par->SimpleTeXOnePar(buf, bparams,
-                                                    os, texrow, moving_arg);
-                               is_rtl = (par->size() > 0)
-                                       ? par->GetFontSettings(bparams,
-                                                              par->size()-1).isRightToLeft()
-                                       : language->RightToLeft();
-                               if (par->next_ &&
-                                   par->next_->footnoteflag != LyXParagraph::NO_FOOTNOTE &&
-                                   (p = par->NextAfterFootnote()) != 0 &&
-                                   p->size() > 0 &&
-                                   p->GetFontSettings(bparams, 0).isRightToLeft() != is_rtl)
-                                       is_rtl = language->RightToLeft();
-                               par = par->next_;
-                       }
-               }
-       } else {
-               while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE
-                      && par->footnoteflag != footnoteflag) {
-                       par = par->TeXFootnote(buf, bparams,
-                                              os, texrow,
-                                              foot, foot_texrow, foot_count,
-                                              false);
-                       par->SimpleTeXOnePar(buf, bparams, os, texrow, moving_arg);
-                       par = par->next_;
-               }
-       }
-#endif
-
        // Make sure that \\par is done with the font of the last
        // character if this has another size as the default.
        // This is necessary because LaTeX (and LyX on the screen)
@@ -2401,13 +1343,12 @@ LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf,
        // Is this really needed ? (Dekel)
        // We do not need to use to change the font for the last paragraph
        // or for a command.
-#ifndef NEW_INSETS
-       LyXFont font = getFont(bparams, Last() - 1);
-#else
-       LyXFont font = getFont(bparams, size() - 1);
-#endif
-       bool is_command = textclasslist.Style(bparams.textclass,
-                                             GetLayout()).isCommand();
+       LyXFont const font =
+               (size() == 0
+                ? getLayoutFont(bparams) : getFont(bparams, size() - 1));
+
+       bool is_command = style.isCommand();
+       
        if (style.resfont.size() != font.size() && next_ && !is_command) {
                if (!need_par)
                        os << "{";
@@ -2417,142 +1358,212 @@ LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf,
        } else if (is_command)
                os << "}";
 
-       if (language->babel() != doc_language->babel() &&
-           (!par
-#ifndef NEW_INSETS
-            || (footnoteflag != NO_FOOTNOTE && par->footnoteflag != footnoteflag)
-#endif
-            || par->getParLanguage(bparams)->babel() != language->babel())) {
-               os << endl 
-                  << subst(lyxrc.language_command_end, "$$lang",
-                           doc_language->babel());
-       }
-       
        switch (style.latextype) {
        case LATEX_ITEM_ENVIRONMENT:
        case LATEX_LIST_ENVIRONMENT:
-                if (par && (params.depth() < par->params.depth())) {
-                        os << '\n';
-                        texrow.newline();
-                }
+               if (next_ && (params().depth() < next_->params().depth())) {
+                       os << '\n';
+                       texrow.newline();
+               }
                break;
        case LATEX_ENVIRONMENT:
                // if its the last paragraph of the current environment
                // skip it otherwise fall through
-               if (par
-                   && (par->layout != layout
-                       || par->params.depth() != params.depth()
-#ifndef NO_PEXTRA
-                       || par->params.pextraType() != params.pextraType()
-#endif
-                           ))
+               if (next_
+                   && (next_->layout() != layout()
+                       || next_->params().depth() != params().depth()))
                        break;
+               // fall through possible
        default:
                // we don't need it for the last paragraph!!!
-               // or for tables in floats
-               //   -- effectively creates a \par where there isn't one which
-               //      breaks a \subfigure or \subtable.
                if (next_) {
-//                 && footnoteflag == LyXParagraph::NO_FOOTNOTE) {
                        os << '\n';
                        texrow.newline();
                }
        }
        
-       further_blank_line = false;
-       if (params.lineBottom()) {
-#ifndef NEW_INSETS
-               os << "\\lyxline{\\" << getFont(bparams,
-                                               Last() - 1).latexSize() << '}';
-#else
-               os << "\\lyxline{\\" << getFont(bparams,
-                                               size() - 1).latexSize() << '}';
-#endif
-               further_blank_line = true;
-       }
+       if ((in == 0) || !in->forceDefaultParagraphs(in)) {
+               further_blank_line = false;
+               if (params().lineBottom()) {
+                       os << "\\lyxline{\\" << font.latexSize() << '}';
+                       further_blank_line = true;
+               }
 
-       if (params.spaceBottom().kind() != VSpace::NONE) {
-               os << params.spaceBottom().asLatexCommand(bparams);
-               further_blank_line = true;
-       }
-      
-       if (params.pagebreakBottom()) {
-               os << "\\newpage";
-               further_blank_line = true;
-       }
+               if (params().spaceBottom().kind() != VSpace::NONE) {
+                       os << params().spaceBottom().asLatexCommand(bparams);
+                       further_blank_line = true;
+               }
 
-       if (further_blank_line){
-               os << '\n';
-               texrow.newline();
-       }
+               if (params().pagebreakBottom()) {
+                       os << "\\newpage";
+                       further_blank_line = true;
+               }
 
-       if (!params.spacing().isDefault()
-           && (!par || !par->HasSameLayout(this))) {
-               os << params.spacing().writeEnvirEnd() << "\n";
-               texrow.newline();
+               if (further_blank_line) {
+                       os << '\n';
+                       texrow.newline();
+               }
+
+               if (!params().spacing().isDefault()
+                       && (!next_ || !next_->hasSameLayout(this))) {
+                       os << params().spacing().writeEnvirEnd() << "\n";
+                       texrow.newline();
+               }
        }
        
        // we don't need it for the last paragraph!!!
-       if (next_
-#ifndef NEW_INSETS
-           && !(footnoteflag != LyXParagraph::NO_FOOTNOTE && par &&
-              par->footnoteflag == LyXParagraph::NO_FOOTNOTE)
-#endif
-               ) {
+       if (next_) {
                os << '\n';
                texrow.newline();
+       } else {
+               // Since \selectlanguage write the language to the aux file,
+               // we need to reset the language at the end of footnote or
+               // float.
+
+               if (language->babel() != doc_language->babel()) {
+                       if (lyxrc.language_command_end.empty())
+                               os << subst(lyxrc.language_command_begin,
+                                           "$$lang",
+                                           doc_language->babel())
+                                  << endl;
+                       else
+                               os << subst(lyxrc.language_command_end,
+                                           "$$lang",
+                                           language->babel())
+                                  << endl;
+                       texrow.newline();
+               }
+       }
+
+       lyxerr[Debug::LATEX] << "TeXOnePar...done " << next_ << endl;
+       return next_;
+}
+
+// This could go to ParagraphParameters if we want to
+int Paragraph::startTeXParParams(BufferParams const & bparams,
+                                ostream & os) const
+{
+       int column = 0;
+       
+       if (params().noindent()) {
+               os << "\\noindent ";
+               column += 10;
+       }
+                       
+       switch (params().align()) {
+       case LYX_ALIGN_NONE:
+       case LYX_ALIGN_BLOCK:
+       case LYX_ALIGN_LAYOUT:
+       case LYX_ALIGN_SPECIAL:
+               break;
+       case LYX_ALIGN_LEFT:
+               if (getParLanguage(bparams)->babel() != "hebrew") {
+                       os << "\\begin{flushleft}";
+                       column += 17;
+               } else {
+                       os << "\\begin{flushright}";
+                       column += 18;
+               }
+               break;
+       case LYX_ALIGN_RIGHT:
+               if (getParLanguage(bparams)->babel() != "hebrew") {
+                       os << "\\begin{flushright}";
+                       column += 18;
+               } else {
+                       os << "\\begin{flushleft}";
+                       column += 17;
+               }
+               break;
+       case LYX_ALIGN_CENTER:
+               os << "\\begin{center}";
+               column += 14;
+               break;
        }
+       
+       return column;
+}
 
-       lyxerr[Debug::LATEX] << "TeXOnePar...done " << par << endl;
-       return par;
+// This could go to ParagraphParameters if we want to
+int Paragraph::endTeXParParams(BufferParams const & bparams,
+                              ostream & os) const
+{
+       int column = 0;
+       
+       switch (params().align()) {
+       case LYX_ALIGN_NONE:
+       case LYX_ALIGN_BLOCK:
+       case LYX_ALIGN_LAYOUT:
+       case LYX_ALIGN_SPECIAL:
+               break;
+       case LYX_ALIGN_LEFT:
+               if (getParLanguage(bparams)->babel() != "hebrew") {
+                       os << "\\end{flushleft}";
+                       column = 15;
+               } else {
+                       os << "\\end{flushright}";
+                       column = 16;
+               }
+               break;
+       case LYX_ALIGN_RIGHT:
+               if (getParLanguage(bparams)->babel() != "hebrew") {
+                       os << "\\end{flushright}";
+                       column+= 16;
+               } else {
+                       os << "\\end{flushleft}";
+                       column = 15;
+               }
+               break;
+       case LYX_ALIGN_CENTER:
+               os << "\\end{center}";
+               column = 12;
+               break;
+       }
+       return column;
 }
 
 
 // This one spits out the text of the paragraph
-bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf,
-                                  BufferParams const & bparams,
-                                  ostream & os, TexRow & texrow,
-                                  bool moving_arg)
+bool Paragraph::simpleTeXOnePar(Buffer const * buf,
+                                BufferParams const & bparams,
+                                ostream & os, TexRow & texrow,
+                                bool moving_arg)
 {
        lyxerr[Debug::LATEX] << "SimpleTeXOnePar...     " << this << endl;
 
        bool return_value = false;
 
-       LyXLayout const & style =
-               textclasslist.Style(bparams.textclass,
-                                   GetLayout());
-       LyXFont basefont, last_font;
+       LyXLayout style;
+       
+       // well we have to check if we are in an inset with unlimited
+       // lenght (all in one row) if that is true then we don't allow
+       // any special options in the paragraph and also we don't allow
+       // any environment other then "Standard" to be valid!
+       bool asdefault =
+               (inInset() && inInset()->forceDefaultParagraphs(inInset()));
+
+       if (asdefault) {
+               style = textclasslist[bparams.textclass].defaultLayout();
+       } else {
+               style = textclasslist[bparams.textclass][layout()];
+       }
+       
+       LyXFont basefont;
 
        // Maybe we have to create a optional argument.
-       size_type main_body;
+       pos_type main_body;
        if (style.labeltype != LABEL_MANUAL)
                main_body = 0;
        else
-               main_body = BeginningOfMainBody();
+               main_body = beginningOfMainBody();
+
+       int column = 0;
 
        if (main_body > 0) {
                os << '[';
-               basefont = getFont(bparams, -2); // Get label font
+               ++column;
+               basefont = getLabelFont(bparams);
        } else {
-               basefont = getFont(bparams, -1); // Get layout font
-       }
-
-       int column = 0;
-
-       if (main_body >= 0
-           && !text.size()
-#ifndef NEW_INSETS
-           && !IsDummy()
-#endif
-               ) {
-               if (style.isCommand()) {
-                       os << '{';
-                       ++column;
-               } else if (params.align() != LYX_ALIGN_LAYOUT) {
-                       os << '{';
-                       ++column;
-                       return_value = true;
-               }
+               basefont = getLayoutFont(bparams);
        }
 
        moving_arg |= style.needprotect;
@@ -2564,20 +1575,27 @@ bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf,
 
        texrow.start(this, 0);
 
-       for (size_type i = 0; i < size(); ++i) {
+       // if the paragraph is empty, the loop will not be entered at all
+       if (!size()) {
+               if (style.isCommand()) {
+                       os << '{';
+                       ++column;
+               }
+               if (!asdefault)
+                       column += startTeXParParams(bparams, os);
+
+       }
+
+       for (pos_type i = 0; i < size(); ++i) {
                ++column;
                // First char in paragraph or after label?
-               if (i == main_body
-#ifndef NEW_INSETS
-                   && !IsDummy()
-#endif
-                       ) {
+               if (i == main_body) {
                        if (main_body > 0) {
                                if (open_font) {
                                        column += running_font.latexWriteEndChanges(os, basefont, basefont);
                                        open_font = false;
                                }
-                               basefont = getFont(bparams, -1); // Now use the layout font
+                               basefont = getLayoutFont(bparams);
                                running_font = basefont;
                                os << ']';
                                ++column;
@@ -2585,80 +1603,32 @@ bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf,
                        if (style.isCommand()) {
                                os << '{';
                                ++column;
-                       } else if (params.align() != LYX_ALIGN_LAYOUT && next_) {
-                               // We do not need \par here (Dekel)
-                               // os << "{\\par";
-                               os << "{";
-                               ++column;
-                               return_value = true;
-                       }
-
-                       if (params.noindent()) {
-                               os << "\\noindent ";
-                               column += 10;
                        }
-                       switch (params.align()) {
-                       case LYX_ALIGN_NONE:
-                       case LYX_ALIGN_BLOCK:
-                       case LYX_ALIGN_LAYOUT:
-                       case LYX_ALIGN_SPECIAL:
-                               break;
-                       case LYX_ALIGN_LEFT:
-                               if (moving_arg)
-                                       os << "\\protect";
-                               if (getParLanguage(bparams)->babel() != "hebrew") {
-                                       os << "\\raggedright ";
-                                       column+= 13;
-                               } else {
-                                       os << "\\raggedleft ";
-                                       column+= 12;
-                               }
-                               break;
-                       case LYX_ALIGN_RIGHT:
-                               if (moving_arg)
-                                       os << "\\protect";
-                               if (getParLanguage(bparams)->babel() != "hebrew") {
-                                       os << "\\raggedleft ";
-                                       column+= 12;
-                               } else {
-                                       os << "\\raggedright ";
-                                       column+= 13;
-                               }
-                               break;
-                       case LYX_ALIGN_CENTER:
-                               if (moving_arg)
-                                       os << "\\protect";
-                               os << "\\centering ";
-                               column+= 11;
-                               break;
-                       }        
+                       
+                       if (!asdefault)
+                               column += startTeXParParams(bparams, os);
                }
-
-               value_type c = GetChar(i);
+               
+               value_type c = getChar(i);
 
                // Fully instantiated font
                LyXFont font = getFont(bparams, i);
-#ifndef NEW_INSETS
-               LyXParagraph * p = 0;
-               if (i == 0
-                   && previous_ && 
-                   previous_->footnoteflag != LyXParagraph::NO_FOOTNOTE &&
-                   (p = PreviousBeforeFootnote()) != 0)
-                       last_font = p->getFont(bparams, p->size() - 1);
-               else
-#endif
-                       last_font = running_font;
+
+               LyXFont const & last_font = running_font;
 
                // Spaces at end of font change are simulated to be
                // outside font change, i.e. we write "\textXX{text} "
                // rather than "\textXX{text }". (Asger)
-               if (open_font && c == ' ' && i <= size() - 2 
-                   && !getFont(bparams, i + 1).equalExceptLatex(running_font) 
-                   && !getFont(bparams, i + 1).equalExceptLatex(font)) {
-                       font = getFont(bparams, i + 1);
+               if (open_font && c == ' ' && i <= size() - 2) {
+                       LyXFont const & next_font = getFont(bparams, i + 1);
+                       if (next_font != running_font
+                           && next_font != font) {
+                               font = next_font;
+                       }
                }
+               
                // We end font definition before blanks
-               if (!font.equalExceptLatex(running_font) && open_font) {
+               if (font != running_font && open_font) {
                        column += running_font.latexWriteEndChanges(os,
                                                                    basefont,
                                                                    (i == main_body-1) ? basefont : font);
@@ -2670,32 +1640,30 @@ bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf,
                if (c == ' ') {
                        // Do not print the separation of the optional argument
                        if (i != main_body - 1) {
-                               SimpleTeXBlanks(os, texrow, i,
-                                               column, font, style);
+                               pimpl_->simpleTeXBlanks(os, texrow, i,
+                                                      column, font, style);
                        }
                }
 
                // Do we need to change font?
-               if (!font.equalExceptLatex(running_font)
-                   && i != main_body-1) {
+               if (font != running_font && i != main_body - 1) {
                        column += font.latexWriteStartChanges(os, basefont,
                                                              last_font);
                        running_font = font;
                        open_font = true;
                }
 
-               if (c == LyXParagraph::META_NEWLINE) {
+               if (c == Paragraph::META_NEWLINE) {
                        // newlines are handled differently here than
                        // the default in SimpleTeXSpecialChars().
-                       if (!style.newline_allowed
-                           || font.latex() == LyXFont::ON) {
+                       if (!style.newline_allowed) {
                                os << '\n';
                        } else {
                                if (open_font) {
                                        column += running_font.latexWriteEndChanges(os, basefont, basefont);
                                        open_font = false;
                                }
-                               basefont = getFont(bparams, -1);
+                               basefont = getLayoutFont(bparams);
                                running_font = basefont;
                                if (font.family() == 
                                    LyXFont::TYPEWRITER_FAMILY) {
@@ -2709,28 +1677,34 @@ bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf,
                        texrow.start(this, i + 1);
                        column = 0;
                } else {
-                       SimpleTeXSpecialChars(buf, bparams,
-                                             os, texrow, moving_arg,
-                                             font, running_font, basefont,
-                                             open_font, style, i, column, c);
+                       pimpl_->simpleTeXSpecialChars(buf, bparams,
+                                                     os, texrow, moving_arg,
+                                                     font, running_font, 
+                                                     basefont, open_font, 
+                                                     style, i, column, c);
                }
        }
 
        // If we have an open font definition, we have to close it
        if (open_font) {
-               LyXParagraph * p = 0;
-               if (next_
-#ifndef NEW_INSETS
-                   && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE
-                   && (p =  NextAfterFootnote()) != 0
+#ifdef FIXED_LANGUAGE_END_DETECTION
+               if (next_) {
+                       running_font
+                               .latexWriteEndChanges(os, basefont,
+                                                     next_->getFont(bparams,
+                                                     0));
+               } else {
+                       running_font.latexWriteEndChanges(os, basefont,
+                                                         basefont);
+               }
 #else
-                       && (p = next_)
+#ifdef WITH_WARNINGS
+//#warning For now we ALWAYS have to close the foreign font settings if they are
+//#warning there as we start another \selectlanguage with the next paragraph if
+//#warning we are in need of this. This should be fixed sometime (Jug)
+#endif
+               running_font.latexWriteEndChanges(os, basefont,  basefont);
 #endif
-               )
-                       running_font.latexWriteEndChanges(os, basefont,
-                                                         p->getFont(bparams, 0));
-               else
-                       running_font.latexWriteEndChanges(os, basefont, basefont);
        }
 
        // Needed if there is an optional argument but no contents.
@@ -2739,19 +1713,23 @@ bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf,
                return_value = false;
        }
 
+       if (!asdefault) {
+               column += endTeXParParams(bparams, os);
+       }
+
        lyxerr[Debug::LATEX] << "SimpleTeXOnePar...done " << this << endl;
        return return_value;
 }
 
 
-bool LyXParagraph::linuxDocConvertChar(char c, string & sgml_string)
+bool Paragraph::sgmlConvertChar(char c, string & sgml_string)
 {
        bool retval = false;
        switch (c) {
-       case LyXParagraph::META_HFILL:
+       case Paragraph::META_HFILL:
                sgml_string.erase();
                break;
-       case LyXParagraph::META_NEWLINE:
+       case Paragraph::META_NEWLINE:
                sgml_string = '\n';
                break;
        case '&': 
@@ -2808,509 +1786,48 @@ bool LyXParagraph::linuxDocConvertChar(char c, string & sgml_string)
 }
 
 
-void LyXParagraph::SimpleTeXBlanks(ostream & os, TexRow & texrow,
-                                  LyXParagraph::size_type const i,
-                                  int & column, LyXFont const & font,
-                                  LyXLayout const & style)
-{
-       if (column > tex_code_break_column
-           && i 
-           && GetChar(i - 1) != ' '
-           && (i < size() - 1)
-           // In LaTeX mode, we don't want to
-           // break lines since some commands
-           // do not like this
-           && ! (font.latex() == LyXFont::ON)
-           // same in FreeSpacing mode
-           && !style.free_spacing
-           // In typewriter mode, we want to avoid 
-           // ! . ? : at the end of a line
-           && !(font.family() == LyXFont::TYPEWRITER_FAMILY
-                && (GetChar(i-1) == '.'
-                    || GetChar(i-1) == '?' 
-                    || GetChar(i-1) == ':'
-                    || GetChar(i-1) == '!'))) {
-               if (tex_code_break_column == 0) {
-                       // in batchmode we need LaTeX to still
-                       // see it as a space not as an extra '\n'
-                       os << " %\n";
-               } else {
-                       os << '\n';
-               }
-               texrow.newline();
-               texrow.start(this, i + 1);
-               column = 0;
-       } else if (font.latex() == LyXFont::OFF) {
-               if (style.free_spacing) {
-                       os << '~';
-               } else {
-                       os << ' ';
-               }
-       }
-}
-
-
-void LyXParagraph::SimpleTeXSpecialChars(Buffer const * buf,
-                                        BufferParams const & bparams,
-                                        ostream & os, TexRow & texrow,
-                                        bool moving_arg,
-                                        LyXFont & font,
-                                        LyXFont & running_font,
-                                        LyXFont & basefont,
-                                        bool & open_font,
-                                        LyXLayout const & style,
-                                        LyXParagraph::size_type & i,
-                                        int & column,
-                                        LyXParagraph::value_type const c)
+Paragraph * Paragraph::TeXEnvironment(Buffer const * buf,
+                                           BufferParams const & bparams,
+                                           ostream & os, TexRow & texrow)
 {
-       // Two major modes:  LaTeX or plain
-       // Handle here those cases common to both modes
-       // and then split to handle the two modes separately.
-       switch (c) {
-       case LyXParagraph::META_INSET: {
-               Inset * inset = GetInset(i);
-               if (inset) {
-                       bool close = false;
-                       int const len = os.tellp();
-                       //ostream::pos_type const len = os.tellp();
-                       if ((inset->LyxCode() == Inset::GRAPHICS_CODE
-                            || inset->LyxCode() == Inset::MATH_CODE
-                            || inset->LyxCode() == Inset::URL_CODE)
-                           && running_font.isRightToLeft()) {
-                               os << "\\L{";
-                               close = true;
-                       }
-
-                       int tmp = inset->Latex(buf, os, moving_arg,
-                                              style.free_spacing);
+       lyxerr[Debug::LATEX] << "TeXEnvironment...     " << this << endl;
 
-                       if (close)
-                               os << "}";
+       LyXLayout const & style =
+               textclasslist[bparams.textclass][layout()];
 
-                       if (tmp) {
-                               column = 0;
-                       } else {
-                               column += int(os.tellp()) - len;
-                       }
-                       for (; tmp--;) {
-                               texrow.newline();
-                       }
-               }
-       }
-       break;
+       Language const * language = getParLanguage(bparams);
+       Language const * doc_language = bparams.language;
+       Language const * previous_language = previous_
+               ? previous_->getParLanguage(bparams) : doc_language;
+       if (language->babel() != previous_language->babel()) {
 
-       case LyXParagraph::META_NEWLINE:
-               if (open_font) {
-                       column += running_font.latexWriteEndChanges(os,
-                                                                   basefont,
-                                                                   basefont);
-                       open_font = false;
+               if (!lyxrc.language_command_end.empty() &&
+                   previous_language->babel() != doc_language->babel()) {
+                       os << subst(lyxrc.language_command_end, "$$lang",
+                                   previous_language->babel())
+                          << endl;
+                       texrow.newline();
                }
-               basefont = getFont(bparams, -1);
-               running_font = basefont;
-               break;
-
-       case LyXParagraph::META_HFILL: 
-               os << "\\hfill{}";
-               column += 7;
-               break;
-
-       default:
-               // And now for the special cases within each mode
-               // Are we in LaTeX mode?
-               if (font.latex() == LyXFont::ON) {
-                       // at present we only have one option
-                       // but I'll leave it as a switch statement
-                       // so its simpler to extend. (ARRae)
-                       switch (c) {
-                       default:
-                               // make sure that we will not print
-                               // error generating chars to the tex
-                               // file. This test would not be needed
-                               // if it were done in the buffer
-                               // itself.
-                               if (c != '\0') {
-                                       os << c;
-                               }
-                               break;
-                       }
-               } else {
-                       // Plain mode (i.e. not LaTeX)
-                       switch (c) {
-                       case '\\': 
-                               os << "\\textbackslash{}";
-                               column += 15;
-                               break;
-               
-                       case '°': case '±': case '²': case '³':  
-                       case '×': case '÷': case '¹': case 'ª':
-                       case 'º': case '¬': case 'µ':
-                               if (bparams.inputenc == "latin1" ||
-                                   (bparams.inputenc == "auto" &&
-                                    font.language()->encoding()->LatexName()
-                                    == "latin1")) {
-                                       os << "\\ensuremath{"
-                                          << c
-                                          << '}';
-                                       column += 13;
-                               } else {
-                                       os << c;
-                               }
-                               break;
-
-                       case '|': case '<': case '>':
-                               // In T1 encoding, these characters exist
-                               if (lyxrc.fontenc == "T1") {
-                                       os << c;
-                                       //... but we should avoid ligatures
-                                       if ((c == '>' || c == '<')
-                                           && i <= size() - 2
-                                           && GetChar(i + 1) == c) {
-                                               //os << "\\textcompwordmark{}";
-                                               // Jean-Marc, have a look at
-                                               // this. I think this works
-                                               // equally well:
-                                               os << "\\,{}";
-                                               // Lgb
-                                               column += 19;
-                                       }
-                                       break;
-                               }
-                               // Typewriter font also has them
-                               if (font.family() == LyXFont::TYPEWRITER_FAMILY) {
-                                       os << c;
-                                       break;
-                               } 
-                               // Otherwise, we use what LaTeX
-                               // provides us.
-                               switch (c) {
-                               case '<':
-                                       os << "\\textless{}";
-                                       column += 10;
-                                       break;
-                               case '>':
-                                       os << "\\textgreater{}";
-                                       column += 13;
-                                       break;
-                               case '|':
-                                       os << "\\textbar{}";
-                                       column += 9;
-                                       break;
-                               }
-                               break;
-
-                       case '-': // "--" in Typewriter mode -> "-{}-"
-                               if (i <= size() - 2
-                                   && GetChar(i + 1) == '-'
-                                   && font.family() == LyXFont::TYPEWRITER_FAMILY) {
-                                       os << "-{}";
-                                       column += 2;
-                               } else {
-                                       os << '-';
-                               }
-                               break;
-
-                       case '\"': 
-                               os << "\\char`\\\"{}";
-                               column += 9;
-                               break;
 
-                       case '£':
-                               if (bparams.inputenc == "default") {
-                                       os << "\\pounds{}";
-                                       column += 8;
-                               } else {
-                                       os << c;
-                               }
-                               break;
-
-                       case '$': case '&':
-                       case '%': case '#': case '{':
-                       case '}': case '_':
-                               os << '\\' << c;
-                               column += 1;
-                               break;
-
-                       case '~':
-                               os << "\\textasciitilde{}";
-                               column += 16;
-                               break;
-
-                       case '^':
-                               os << "\\textasciicircum{}";
-                               column += 17;
-                               break;
-
-                       case '*': case '[': case ']':
-                               // avoid being mistaken for optional arguments
-                               os << '{' << c << '}';
-                               column += 2;
-                               break;
-
-                       case ' ':
-                               // Blanks are printed before font switching.
-                               // Sure? I am not! (try nice-latex)
-                               // I am sure it's correct. LyX might be smarter
-                               // in the future, but for now, nothing wrong is
-                               // written. (Asger)
-                               break;
-
-                       default:
-                               /* idea for labels --- begin*/
-                               // Check for "LyX"
-                               if (c ==  'L'
-                                   && i <= size() - 3
-                                   && font.family() != LyXFont::TYPEWRITER_FAMILY
-                                   && GetChar(i + 1) == 'y'
-                                   && GetChar(i + 2) == 'X') {
-                                       os << "\\LyX{}";
-                                       i += 2;
-                                       column += 5;
-                               }
-                               // Check for "TeX"
-                               else if (c == 'T'
-                                        && i <= size() - 3
-                                        && font.family() != LyXFont::TYPEWRITER_FAMILY
-                                        && GetChar(i + 1) == 'e'
-                                        && GetChar(i + 2) == 'X') {
-                                       os << "\\TeX{}";
-                                       i += 2;
-                                       column += 5;
-                               }
-                               // Check for "LaTeX2e"
-                               else if (c == 'L'
-                                        && i <= size() - 7
-                                        && font.family() != LyXFont::TYPEWRITER_FAMILY
-                                        && GetChar(i + 1) == 'a'
-                                        && GetChar(i + 2) == 'T'
-                                        && GetChar(i + 3) == 'e'
-                                        && GetChar(i + 4) == 'X'
-                                        && GetChar(i + 5) == '2'
-                                        && GetChar(i + 6) == 'e') {
-                                       os << "\\LaTeXe{}";
-                                       i += 6;
-                                       column += 8;
-                               }
-                               // Check for "LaTeX"
-                               else if (c == 'L'
-                                        && i <= size() - 5
-                                        && font.family() != LyXFont::TYPEWRITER_FAMILY
-                                        && GetChar(i + 1) == 'a'
-                                        && GetChar(i + 2) == 'T'
-                                        && GetChar(i + 3) == 'e'
-                                        && GetChar(i + 4) == 'X') {
-                                       os << "\\LaTeX{}";
-                                       i += 4;
-                                       column += 7;
-                                       /* idea for labels --- end*/ 
-                               } else if (c != '\0') {
-                                       os << c;
-                               }
-                               break;
-                       }
+               if (lyxrc.language_command_end.empty() ||
+                   language->babel() != doc_language->babel()) {
+                       os << subst(lyxrc.language_command_begin, "$$lang",
+                                   language->babel())
+                          << endl;
+                       texrow.newline();
                }
        }
-}
-
 
-LyXParagraph * LyXParagraph::TeXDeeper(Buffer const * buf,
-                                      BufferParams const & bparams,
-                                      ostream & os, TexRow & texrow
-#ifndef NEW_INSETS
-                                      ,ostream & foot,
-                                      TexRow & foot_texrow,
-                                      int & foot_count
-#endif
-       )
-{
-       lyxerr[Debug::LATEX] << "TeXDeeper...     " << this << endl;
-       LyXParagraph * par = this;
-
-       while (par &&
-              (par->params.depth() == params.depth())
-#ifndef NEW_INSETS
-              && (par->footnoteflag == footnoteflag)
-#endif
-               ) {
-#ifndef NEW_INSETS
-               if (par->IsDummy())
-                       lyxerr << "ERROR (LyXParagraph::TeXDeeper)" << endl;
-#endif
-               if (textclasslist.Style(bparams.textclass, 
-                                       par->layout).isEnvironment()
-#ifndef NO_PEXTRA
-                   || par->params.pextraType() != PEXTRA_NONE
-#endif
-                       ) {
-                       par = par->TeXEnvironment(buf, bparams,
-                                                 os, texrow
-#ifndef NEW_INSETS
-                                                 ,foot, foot_texrow,
-                                                 foot_count
-#endif
-                               );
-               } else {
-                       par = par->TeXOnePar(buf, bparams,
-                                            os, texrow, false
-#ifndef NEW_INSETS
-                                            ,
-                                            foot, foot_texrow,
-                                            foot_count
-#endif
-                               );
-               }
-       }
-       lyxerr[Debug::LATEX] << "TeXDeeper...done " << par << endl;
-
-       return par;
-}
-
-
-LyXParagraph * LyXParagraph::TeXEnvironment(Buffer const * buf,
-                                           BufferParams const & bparams,
-                                           ostream & os, TexRow & texrow
-#ifndef NEW_INSETS
-                                           ,ostream & foot,
-                                           TexRow & foot_texrow,
-                                           int & foot_count
-#endif
-       )
-{
-#ifndef NO_PEXTRA
-       bool eindent_open = false;
-#endif
-#ifndef NEW_INSETS
-       bool foot_this_level = false;
-#endif
-#ifndef NO_PEXTRA
-       // flags when footnotetext should be appended to file.
-        static bool minipage_open = false;
-        static int minipage_open_depth = 0;
-       char par_sep = bparams.paragraph_separation;
-#endif
-    
-       lyxerr[Debug::LATEX] << "TeXEnvironment...     " << this << endl;
-#ifndef NEW_INSETS
-       if (IsDummy())
-               lyxerr << "ERROR (LyXParagraph::TeXEnvironment)" << endl;
-#endif
-
-       LyXLayout const & style =
-               textclasslist.Style(bparams.textclass,
-                                   layout);
-
-#ifndef NO_PEXTRA
-       if (params.pextraType() == PEXTRA_INDENT) {
-               if (!params.pextraWidth().empty()) {
-                       os << "\\begin{LyXParagraphIndent}{"
-                          << params.pextraWidth() << "}\n";
-               } else {
-                       //float ib = atof(pextra_widthp.c_str())/100;
-                       // string can't handle floats at present (971109)
-                       // so I'll do a conversion by hand knowing that
-                       // the limits are 0.0 to 1.0. ARRae.
-                       os << "\\begin{LyXParagraphIndent}{";
-                       switch (params.pextraWidthp().length()) {
-                       case 3:
-                               os << "1.00";
-                               break;
-                       case 2:
-                               os << "0."
-                                  << params.pextraWidthp();
-                               break;
-                       case 1:
-                               os << "0.0"
-                                  << params.pextraWidthp();
-                       }
-                       os << "\\columnwidth}\n";
-               }
-               texrow.newline();
-               eindent_open = true;
-       }
-       if ((params.pextraType() == PEXTRA_MINIPAGE) && !minipage_open) {
-               if (params.pextraHfill() && previous() &&
-                   (previous()->params.pextraType() == PEXTRA_MINIPAGE)) {
-                       os << "\\hfill{}\n";
-                       texrow.newline();
-               }
-               if (par_sep == BufferParams::PARSEP_INDENT) {
-                       os << "{\\setlength\\parindent{0pt}\n";
-                       texrow.newline();
-               }
-               os << "\\begin{minipage}";
-               switch (params.pextraAlignment()) {
-               case MINIPAGE_ALIGN_TOP:
-                       os << "[t]";
-                       break;
-               case MINIPAGE_ALIGN_MIDDLE:
-                       os << "[m]";
-                       break;
-               case MINIPAGE_ALIGN_BOTTOM:
-                       os << "[b]";
-                       break;
-               }
-               if (!params.pextraWidth().empty()) {
-                       os << '{' << params.pextraWidth() << "}\n";
-               } else {
-                       //float ib = atof(par->pextra_width.c_str())/100;
-                       // string can't handle floats at present
-                       // so I'll do a conversion by hand knowing that
-                       // the limits are 0.0 to 1.0. ARRae.
-                       os << '{';
-                       switch (params.pextraWidthp().length()) {
-                       case 3:
-                               os << "1.00";
-                               break;
-                       case 2:
-                               os << "0."
-                                  << params.pextraWidthp();
-                               break;
-                       case 1:
-                               os << "0.0"
-                                  << params.pextraWidthp();
-                       }
-                       os << "\\columnwidth}\n";
-               }
-               texrow.newline();
-               if (par_sep == BufferParams::PARSEP_INDENT) {
-                       os << "\\setlength\\parindent{\\LyXMinipageIndent}\n";
-                       texrow.newline();
-               }
-               minipage_open = true;
-                minipage_open_depth = params.depth();
-       }
-#endif
-#ifdef WITH_WARNINGS
-#warning Define FANCY_FOOTNOTE_CODE to re-enable Allan footnote code
-       //I disabled it because it breaks when lists span on several
-       //pages (JMarc)
-#endif
-       if (style.isEnvironment()){
+       if (style.isEnvironment()) {
                if (style.latextype == LATEX_LIST_ENVIRONMENT) {
-#ifdef FANCY_FOOTNOTE_CODE
-                       if (foot_count < 0) {
-                               // flag that footnote[mark][text] should be
-                               // used for any footnotes from now on
-                               foot_count = 0;
-                               foot_this_level = true;
-                       }
-#endif
                        os << "\\begin{" << style.latexname() << "}{"
-                          << params.labelWidthString() << "}\n";
+                          << params().labelWidthString() << "}\n";
                } else if (style.labeltype == LABEL_BIBLIO) {
                        // ale970405
                        os << "\\begin{" << style.latexname() << "}{"
                           <<  bibitemWidest(buf)
                           << "}\n";
                } else if (style.latextype == LATEX_ITEM_ENVIRONMENT) {
-#ifdef FANCY_FOOTNOTE_CODE
-                       if (foot_count < 0) {
-                               // flag that footnote[mark][text] should be
-                               // used for any footnotes from now on
-                               foot_count = 0;
-                               foot_this_level = true;
-                       }
-#endif
                        os << "\\begin{" << style.latexname() << '}'
                           << style.latexparam() << '\n';
                } else 
@@ -3318,31 +1835,12 @@ LyXParagraph * LyXParagraph::TeXEnvironment(Buffer const * buf,
                           << style.latexparam() << '\n';
                texrow.newline();
        }
-       LyXParagraph * par = this;
+       Paragraph * par = this;
        do {
-               par = par->TeXOnePar(buf, bparams,
-                                    os, texrow, false
-#ifndef NEW_INSETS
-                                    ,
-                                    foot, foot_texrow, foot_count
-#endif
-                       );
-#ifndef NO_PEXTRA
-                if (minipage_open && par && !style.isEnvironment() &&
-                    (par->params.pextraType() == PEXTRA_MINIPAGE) &&
-                    par->params.pextraStartMinipage()) {
-                       os << "\\end{minipage}\n";
-                       texrow.newline();
-                       if (par_sep == BufferParams::PARSEP_INDENT) {
-                               os << "}\n";
-                               texrow.newline();
-                       }
-                       minipage_open = false;
-                }
-#endif
-               if (par && par->params.depth() > params.depth()) {
-                       if (textclasslist.Style(bparams.textclass,
-                                               par->layout).isParagraph()
+               par = par->TeXOnePar(buf, bparams, os, texrow, false);
+
+               if (par && par->params().depth() > params().depth()) {
+                       if (textclasslist[bparams.textclass][par->layout()].isParagraph()
                            // Thinko!
                            // How to handle this? (Lgb)
                            //&& !suffixIs(os, "\n\n")
@@ -3360,625 +1858,133 @@ LyXParagraph * LyXParagraph::TeXEnvironment(Buffer const * buf,
                                os << '\n';
                                texrow.newline();
                        }
-                       par = par->TeXDeeper(buf, bparams, os, texrow
-#ifndef NEW_INSETS
-                                            ,foot, foot_texrow, foot_count
-#endif
-                               );
-               }
-#ifndef NO_PEXTRA
-               if (par && par->layout == layout && par->params.depth() == params.depth() &&
-                   (par->params.pextraType() == PEXTRA_MINIPAGE) && !minipage_open) {
-                       if (par->params.pextraHfill() && par->previous() &&
-                           (par->previous()->params.pextraType() == PEXTRA_MINIPAGE)){
-                               os << "\\hfill{}\n";
-                                texrow.newline();
-                        }
-                       if (par_sep == BufferParams::PARSEP_INDENT) {
-                               os << "{\\setlength\\parindent{0pt}\n";
-                               texrow.newline();
-                       }
-                       os << "\\begin{minipage}";
-                       switch (par->params.pextraAlignment()) {
-                       case MINIPAGE_ALIGN_TOP:
-                               os << "[t]";
-                               break;
-                       case MINIPAGE_ALIGN_MIDDLE:
-                               os << "[m]";
-                               break;
-                       case MINIPAGE_ALIGN_BOTTOM:
-                               os << "[b]";
-                               break;
-                       }
-                       if (!par->params.pextraWidth().empty()) {
-                               os << '{' << par->params.pextraWidth() << "}\n";
-                       } else {
-                               //float ib = atof(par->pextra_widthp.c_str())/100;
-                               // string can't handle floats at present
-                               // so I'll do a conversion by hand knowing that
-                               // the limits are 0.0 to 1.0. ARRae.
-                               os << '{';
-                               switch (par->params.pextraWidthp().length()) {
-                               case 3:
-                                       os << "1.00";
-                                       break;
-                               case 2:
-                                       os << "0." << par->params.pextraWidthp();
-                                       break;
-                               case 1:
-                                       os << "0.0" << par->params.pextraWidthp();
-                               }
-                               os << "\\columnwidth}\n";
-                       }
-                       texrow.newline();
-                       if (par_sep == BufferParams::PARSEP_INDENT) {
-                               os << "\\setlength\\parindent{\\LyXMinipageIndent}\n";
-                               texrow.newline();
-                       }
-                       minipage_open = true;
-                        minipage_open_depth = par->params.depth();
+                       par = par->pimpl_->TeXDeeper(buf, bparams, os, texrow);
                }
-#endif
        } while (par
-                && par->layout == layout
-                && par->params.depth() == params.depth()
-#ifndef NO_PEXTRA
-                && par->params.pextraType() == params.pextraType()
-#endif
-#ifndef NEW_INSETS
-                && par->footnoteflag == footnoteflag
-#endif
-               );
+                && par->layout() == layout()
+                && par->params().depth() == params().depth());
  
        if (style.isEnvironment()) {
                os << "\\end{" << style.latexname() << "}\n";
-
-#ifndef NEW_INSETS
-               // maybe this should go after the minipage closes?
-               if (foot_this_level) {
-                       if (foot_count >= 1) {
-                               if (foot_count > 1) {
-                                       os << "\\addtocounter{footnote}{-"
-                                          << foot_count - 1
-                                          << '}';
-                               }
-                               os << foot;
-                               texrow += foot_texrow;
-                               foot.clear();
-                               foot_texrow.reset();
-                               foot_count = 0;
-                       }
-               }
-#endif
-       }
-#ifndef NO_PEXTRA
-        if (minipage_open && (minipage_open_depth == params.depth()) &&
-            (!par || par->params.pextraStartMinipage() ||
-             par->params.pextraType() != PEXTRA_MINIPAGE)) {
-                os << "\\end{minipage}\n";
-               texrow.newline();
-                if (par_sep == BufferParams::PARSEP_INDENT) {
-                        os << "}\n";
-                       texrow.newline();
-                }
-                if (par && par->params.pextraType() != PEXTRA_MINIPAGE) {
-                        os << "\\medskip\n\n";
-                       texrow.newline();
-                       texrow.newline();
-                }
-                minipage_open = false;
-        }
-       if (eindent_open) {
-               os << "\\end{LyXParagraphIndent}\n";
-               texrow.newline();
-       }
-        if (!(par && (par->params.pextraType() == PEXTRA_MINIPAGE) 
-             && par->params.pextraHfill())) {
-                os << '\n';
                texrow.newline();
        }
-#endif
+
        lyxerr[Debug::LATEX] << "TeXEnvironment...done " << par << endl;
        return par;  // ale970302
 }
 
 
-#ifndef NEW_INSETS
-LyXParagraph * LyXParagraph::TeXFootnote(Buffer const * buf,
-                                        BufferParams const & bparams,
-                                        ostream & os, TexRow & texrow,
-                                        ostream & foot, TexRow & foot_texrow,
-                                        int & foot_count,
-                                        bool parent_is_rtl)
+bool Paragraph::isHfill(pos_type pos) const
 {
-       lyxerr[Debug::LATEX] << "TeXFootnote...  " << this << endl;
-       if (footnoteflag == LyXParagraph::NO_FOOTNOTE)
-               lyxerr << "ERROR (LyXParagraph::TeXFootnote): "
-                       "No footnote!" << endl;
-
-       LyXParagraph * par = this;
-       LyXLayout const & style =
-               textclasslist.Style(bparams.textclass, 
-                                   previous_->GetLayout());
-       
-       if (style.needprotect && footnotekind != LyXParagraph::FOOTNOTE){
-               lyxerr << "ERROR (LyXParagraph::TeXFootnote): "
-                       "Float other than footnote in command"
-                       " with moving argument is illegal" << endl;
-       }
-
-       if (footnotekind != LyXParagraph::FOOTNOTE
-           && footnotekind != LyXParagraph::MARGIN
-           && os.tellp()
-           // Thinko
-           // How to solve this?
-           //&& !suffixIs(file, '\n')
-               ) {
-               // we need to ensure that real floats like tables and figures
-               // have their \begin{} on a new line otherwise we can get
-               // incorrect results when using the endfloat.sty package
-               // especially if two floats follow one another.  ARRae 981022
-               // NOTE: if the file is length 0 it must have just been
-               //       written out so we assume it ended with a '\n'
-               // Thinkee:
-               // As far as I can see there is never any harm in writing
-               // a '\n' too much. Please tell me if I am wrong. (Lgb)
-               os << '\n';
-               texrow.newline();
-       }
-
-       bool moving_arg = false;
-       bool need_closing = false;
-       bool is_rtl = isRightToLeftPar(bparams);
-
-       if (is_rtl != parent_is_rtl) {
-               if (is_rtl)
-                       os << "\\R{";
-               else
-                       os << "\\L{";
-               need_closing = true;
-       }
-       
-       bool footer_in_body = true;
-       switch (footnotekind) {
-       case LyXParagraph::FOOTNOTE:
-               if (style.intitle) {
-                       os << "\\thanks{\n";
-                       footer_in_body = false;
-                       moving_arg = true;
-               } else {
-                       if (foot_count == -1) {
-                               // we're at depth 0 so we can use:
-                               os << "\\footnote{%\n";
-                               footer_in_body = false;
-                       } else {
-                               os << "\\footnotemark{}%\n";
-                               if (foot_count) {
-                                       // we only need this when there are
-                                       // multiple footnotes
-                                       os << "\\stepcounter{footnote}";
-                               }
-                               os << "\\footnotetext{%\n";
-                               foot_texrow.start(this, 0);
-                               foot_texrow.newline();
-                               ++foot_count;
-                       }
-               }
-               break;
-       case LyXParagraph::MARGIN:
-               os << "\\marginpar{\n";
-               break;
-       case LyXParagraph::FIG:
-               if (params.pextraType() == PEXTRA_FLOATFLT
-                   && (!params.pextraWidth().empty()
-                       || !params.pextraWidthp().empty())) {
-                       if (!params.pextraWidth().empty())
-                               os << "\\begin{floatingfigure}{"
-                                  << params.pextraWidth() << "}\n";
-                       else
-                               os << "\\begin{floatingfigure}{"
-                                  << lyx::atoi(params.pextraWidthp()) / 100.0
-                                  << "\\textwidth}\n";
-               } else {
-                       os << "\\begin{figure}";
-                       if (!bparams.float_placement.empty()) { 
-                               os << '[' << bparams.float_placement << "]\n";
-                       } else {
-                               os << '\n';
-                       }
-               }
-               break;
-       case LyXParagraph::TAB:
-               os << "\\begin{table}";
-               if (!bparams.float_placement.empty()) { 
-                       os << '[' << bparams.float_placement << "]\n";
-               } else {
-                       os << '\n';
-               }
-               break;
-       case LyXParagraph::WIDE_FIG:
-               os << "\\begin{figure*}";
-               if (!bparams.float_placement.empty()) { 
-                       os << '[' << bparams.float_placement << "]\n";
-               } else {
-                       os << '\n';
-               }
-               break;
-       case LyXParagraph::WIDE_TAB:
-               os << "\\begin{table*}";
-               if (!bparams.float_placement.empty()) { 
-                       os << '[' << bparams.float_placement << "]\n";
-               } else {
-                       os << '\n';
-               }
-               break;
-       case LyXParagraph::ALGORITHM:
-               os << "\\begin{algorithm}\n";
-               break;
-       }
-       texrow.newline();
-   
-       if (footnotekind != LyXParagraph::FOOTNOTE
-           || !footer_in_body) {
-               // Process text for all floats except footnotes in body
-               do {
-                       LyXLayout const & style =
-                               textclasslist
-                               .Style(bparams.textclass, par->layout);
-                       if (par->IsDummy())
-                               lyxerr << "ERROR (LyXParagraph::TeXFootnote)"
-                                      << endl;
-                       if (style.isEnvironment()
-                           || par->params.pextraType() == PEXTRA_MINIPAGE) { /* && !minipage_open ?? */
-                               // Allows the use of minipages within float
-                               // environments. Shouldn't be circular because
-                               // we don't support footnotes inside
-                               // floats (yet). ARRae
-                               par = par->TeXEnvironment(buf, bparams, os,
-                                                         texrow,
-                                                         foot, foot_texrow,
-                                                         foot_count);
-                       } else {
-                               par = par->TeXOnePar(buf, bparams,
-                                                    os, texrow, moving_arg,
-                                                    foot, foot_texrow,
-                                                    foot_count);
-                       }
-                       
-                       if (par && !par->IsDummy() && par->params.depth() > params.depth()) {
-                               par = par->TeXDeeper(buf, bparams, os, texrow,
-                                                    foot, foot_texrow,
-                                                    foot_count);
-                       }
-               } while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE);
-       } else {
-               // process footnotes > depth 0 or in environments separately
-               // NOTE: Currently don't support footnotes within footnotes
-               //       even though that is possible using the \footnotemark
-               std::ostringstream dummy;
-               TexRow dummy_texrow;
-               int dummy_count = 0;
-               do {
-                       LyXLayout const & style =
-                               textclasslist
-                               .Style(bparams.textclass, par->layout);
-                       if (par->IsDummy())
-                               lyxerr << "ERROR (LyXParagraph::TeXFootnote)"
-                                      << endl;
-                       if (style.isEnvironment()
-                           || par->params.pextraType() == PEXTRA_MINIPAGE) { /* && !minipage_open ?? */
-                               // Allows the use of minipages within float
-                               // environments. Shouldn't be circular because
-                               // we don't support footnotes inside
-                               // floats (yet). ARRae
-                               par = par->TeXEnvironment(buf, bparams,
-                                                         foot, foot_texrow,
-                                                         dummy, dummy_texrow,
-                                                         dummy_count);
-                       } else {
-                               par = par->TeXOnePar(buf, bparams,
-                                                    foot, foot_texrow,
-                                                    moving_arg,
-                                                    dummy, dummy_texrow,
-                                                    dummy_count);
-                       }
-
-                       if (par && !par->IsDummy() && par->params.depth() > params.depth()) {
-                               par = par->TeXDeeper(buf, bparams,
-                                                    foot, foot_texrow,
-                                                    dummy, dummy_texrow,
-                                                    dummy_count);
-                       }
-               } while (par
-                        && par->footnoteflag != LyXParagraph::NO_FOOTNOTE);
-               if (dummy_count) {
-                       lyxerr << "ERROR (LyXParagraph::TeXFootnote): "
-                               "Footnote in a Footnote -- not supported"
-                              << endl;
-               }
-       }
-
-       switch (footnotekind) {
-       case LyXParagraph::FOOTNOTE:
-               if (footer_in_body) {
-                       // This helps tell which of the multiple
-                       // footnotetexts an error was in.
-                       foot << "}%\n";
-                       foot_texrow.newline();
-               } else {
-                       os << '}';
-               }
-               break;
-       case LyXParagraph::MARGIN:
-               os << '}';
-               break;
-       case LyXParagraph::FIG:
-               if (params.pextraType() == PEXTRA_FLOATFLT
-                   && (!params.pextraWidth().empty()
-                       || !params.pextraWidthp().empty()))
-                       os << "\\end{floatingfigure}";
-               else
-                       os << "\\end{figure}";
-               break;
-       case LyXParagraph::TAB:
-               os << "\\end{table}";
-               break;
-       case LyXParagraph::WIDE_FIG:
-               os << "\\end{figure*}";
-               break;
-       case LyXParagraph::WIDE_TAB:
-               os << "\\end{table*}";
-               break;
-       case LyXParagraph::ALGORITHM:
-               os << "\\end{algorithm}";
-               break;
-       }
-
-       if (need_closing)
-               os << "}";
-
-       if (footnotekind != LyXParagraph::FOOTNOTE
-           && footnotekind != LyXParagraph::MARGIN) {
-               // we need to ensure that real floats like tables and figures
-               // have their \end{} on a line of their own otherwise we can
-               // get incorrect results when using the endfloat.sty package.
-               os << "\n";
-               texrow.newline();
-       }
-
-       lyxerr[Debug::LATEX] << "TeXFootnote...done " << par->next_ << endl;
-       return par;
-}
-
-
-bool LyXParagraph::IsDummy() const
-{
-       return (footnoteflag == LyXParagraph::NO_FOOTNOTE && previous_
-               && previous_->footnoteflag != LyXParagraph::NO_FOOTNOTE);
-}
-#endif
-
-#ifndef NO_PEXTRA
-void LyXParagraph::SetPExtraType(BufferParams const & bparams,
-                                int type, string const & width,
-                                string const & widthp)
-{
-       params.pextraType(type);
-       params.pextraWidth(width);
-       params.pextraWidthp(widthp);
-
-       if (textclasslist.Style(bparams.textclass, 
-                               layout).isEnvironment()) {
-               LyXParagraph * par = this;
-               LyXParagraph * ppar = par;
-
-               while (par && (par->layout == layout)
-                      && (par->params.depth() == params.depth())) {
-                       ppar = par;
-                       par = par->previous();
-#ifndef NEW_INSETS
-                       if (par)
-                               par = par->FirstPhysicalPar();
-#endif
-                       while (par && par->params.depth() > params.depth()) {
-                               par = par->previous();
-#ifndef NEW_INSETS
-                               if (par)
-                                       par = par->FirstPhysicalPar();
-#endif
-                       }
-               }
-               par = ppar;
-               while (par && (par->layout == layout)
-                      && (par->params.depth() == params.depth())) {
-                       par->params.pextraType(type);
-                       par->params.pextraWidth(width);
-                       par->params.pextraWidthp(widthp);
-#ifndef NEW_INSETS
-                       par = par->NextAfterFootnote();
-#else
-                       par = par->next();
-#endif
-                       if (par && (par->params.depth() > params.depth()))
-                               par->SetPExtraType(bparams,
-                                                  type, width, widthp);
-#ifndef NEW_INSETS
-                       while (par && ((par->params.depth() > params.depth()) || par->IsDummy()))
-                               par = par->NextAfterFootnote();
-#else
-                       while (par && par->params.depth() > params.depth())
-                               par = par->next();
-#endif
-               }
-       }
-}
-
-
-void LyXParagraph::UnsetPExtraType(BufferParams const & bparams)
-{
-       if (params.pextraType() == PEXTRA_NONE)
-               return;
-    
-       params.pextraType(PEXTRA_NONE);
-       params.pextraWidth(string());
-       params.pextraWidthp(string());
-
-       if (textclasslist.Style(bparams.textclass, 
-                               layout).isEnvironment()) {
-               LyXParagraph * par = this;
-               LyXParagraph * ppar = par;
-
-               while (par && (par->layout == layout)
-                      && (par->params.depth() == params.depth())) {
-                       ppar = par;
-                       par = par->previous();
-#ifndef NEW_INSETS
-                       if (par)
-                               par = par->FirstPhysicalPar();
-#endif
-                       while (par && par->params.depth() > params.depth()) {
-                               par = par->previous();
-#ifndef NEW_INSETS
-                               if (par)
-                                       par = par->FirstPhysicalPar();
-#endif
-                       }
-               }
-               par = ppar;
-               while (par && (par->layout == layout)
-                      && (par->params.depth() == params.depth())) {
-                       par->params.pextraType(PEXTRA_NONE);
-                       par->params.pextraWidth(string());
-                       par->params.pextraWidthp(string());
-#ifndef NEW_INSETS
-                       par = par->NextAfterFootnote();
-#else
-                       par = par->next();
-#endif
-                       if (par && (par->params.depth() > params.depth()))
-                               par->UnsetPExtraType(bparams);
-#ifndef NEW_INSETS
-                       while (par && ((par->params.depth() > params.depth()) || par->IsDummy()))
-                               par = par->NextAfterFootnote();
-#else
-                       while (par && par->params.depth() > params.depth())
-                               par = par->next();
-#endif
-               }
-       }
-}
-#endif
-
-
-bool LyXParagraph::IsHfill(size_type pos) const
-{
-       return IsHfillChar(GetChar(pos));
+       return IsHfillChar(getChar(pos));
 }
 
 
-bool LyXParagraph::IsInset(size_type pos) const
+bool Paragraph::isInset(pos_type pos) const
 {
-       return IsInsetChar(GetChar(pos));
+       return IsInsetChar(getChar(pos));
 }
 
 
-#ifndef NEW_INSETS
-bool LyXParagraph::IsFloat(size_type pos) const
+bool Paragraph::isNewline(pos_type pos) const
 {
-       return IsFloatChar(GetChar(pos));
+       return pos >= 0 && IsNewlineChar(getChar(pos));
 }
-#endif
 
 
-bool LyXParagraph::IsNewline(size_type pos) const
+bool Paragraph::isSeparator(pos_type pos) const
 {
-       return pos >= 0 && IsNewlineChar(GetChar(pos));
+       return IsSeparatorChar(getChar(pos));
 }
 
 
-bool LyXParagraph::IsSeparator(size_type pos) const
+bool Paragraph::isLineSeparator(pos_type pos) const
 {
-       return IsSeparatorChar(GetChar(pos));
+       value_type const c = getChar(pos);
+       return IsLineSeparatorChar(c)
+               || (IsInsetChar(c) && getInset(pos)->isLineSeparator());
 }
 
 
-bool LyXParagraph::IsLineSeparator(size_type pos) const
+bool Paragraph::isKomma(pos_type pos) const
 {
-       return IsLineSeparatorChar(GetChar(pos));
-}
-
-
-bool LyXParagraph::IsKomma(size_type pos) const
-{
-       return IsKommaChar(GetChar(pos));
+       return IsKommaChar(getChar(pos));
 }
 
 
 /// Used by the spellchecker
-bool LyXParagraph::IsLetter(LyXParagraph::size_type pos) const
+bool Paragraph::isLetter(pos_type pos) const
 {
-       value_type const c = GetChar(pos);
+       value_type const c = getChar(pos);
        if (IsLetterChar(c))
                return true;
-       // '\0' is not a letter, allthough every string contains "" (below)
-       if (c == '\0')
-               return false;
+       if (isInset(pos)) 
+               return getInset(pos)->isLetter();
        // We want to pass the ' and escape chars to ispell
        string const extra = lyxrc.isp_esc_chars + '\'';
-       char ch[2] = { c, 0 };
-       return contains(extra, ch);
+       return contains(extra, c);
 }
  
  
-bool LyXParagraph::IsWord(size_type pos ) const
+bool Paragraph::isWord(pos_type pos) const
 {
-       return IsWordChar(GetChar(pos)) ;
+       return IsWordChar(getChar(pos)) ;
 }
 
 
 Language const *
-LyXParagraph::getParLanguage(BufferParams const & bparams) const 
+Paragraph::getParLanguage(BufferParams const & bparams) const 
 {
-#ifndef NEW_INSETS
-       if (IsDummy())
-               return FirstPhysicalPar()->getParLanguage(bparams);
-       else
+       if (size() > 0) {
+#ifndef INHERIT_LANGUAGE
+               return getFirstFontSettings().language();
+#else
+               Language const * lang = getFirstFontSettings().language();
+#ifdef WITH_WARNINGS
+#warning We should make this somewhat better, any ideas? (Jug)
 #endif
-       if (size() > 0)
-               return GetFirstFontSettings().language();
-       else if (previous_)
+               if (lang == inherit_language || lang == ignore_language)
+                       lang = bparams.language;
+               return lang;
+#endif
+       } else if (previous_)
                return previous_->getParLanguage(bparams);
        else
                return bparams.language;
 }
 
 
-bool LyXParagraph::isRightToLeftPar(BufferParams const & bparams) const
+bool Paragraph::isRightToLeftPar(BufferParams const & bparams) const
 {
        return lyxrc.rtl_support
                && getParLanguage(bparams)->RightToLeft();
 }
 
 
-void LyXParagraph::ChangeLanguage(BufferParams const & bparams,
+void Paragraph::changeLanguage(BufferParams const & bparams,
                                  Language const * from, Language const * to)
 {
-       for (size_type i = 0; i < size(); ++i) {
-               LyXFont font = GetFontSettings(bparams, i);
+       for (pos_type i = 0; i < size(); ++i) {
+               LyXFont font = getFontSettings(bparams, i);
                if (font.language() == from) {
                        font.setLanguage(to);
-                       SetFont(i, font);
+                       setFont(i, font);
                }
        }
 }
 
 
-bool LyXParagraph::isMultiLingual(BufferParams const & bparams)
+bool Paragraph::isMultiLingual(BufferParams const & bparams)
 {
        Language const * doc_language = bparams.language;
-       for (FontList::const_iterator cit = fontlist.begin();
-            cit != fontlist.end(); ++cit)
-               if ((*cit).font().language() != doc_language)
+       for (Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
+            cit != pimpl_->fontlist.end(); ++cit)
+               if (cit->font().language() != ignore_language &&
+                   cit->font().language() != latex_language &&
+#ifdef INHERIT_LANGUAGE
+                       cit->font().language() != inherit_language &&
+#endif
+                       cit->font().language() != doc_language)
                        return true;
        return false;
 }
@@ -3986,123 +1992,227 @@ bool LyXParagraph::isMultiLingual(BufferParams const & bparams)
 
 // Convert the paragraph to a string.
 // Used for building the table of contents
-string const LyXParagraph::String(Buffer const * buffer, bool label)
+string const Paragraph::asString(Buffer const * buffer, bool label)
 {
        BufferParams const & bparams = buffer->params;
        string s;
-#ifndef NEW_INSETS
-       if (label && !IsDummy() && !params.labelString().empty())
-#else
-       if (label && !params.labelString().empty())
-#endif
-               s += params.labelString() + ' ';
+       if (label && !params().labelString().empty())
+               s += params().labelString() + ' ';
        string::size_type const len = s.size();
 
-       for (LyXParagraph::size_type i = 0; i < size(); ++i) {
-               value_type c = GetChar(i);
+       for (pos_type i = 0; i < size(); ++i) {
+               value_type c = getChar(i);
                if (IsPrintable(c))
                        s += c;
                else if (c == META_INSET &&
-                        GetInset(i)->LyxCode() == Inset::MATH_CODE) {
-                       std::ostringstream ost;
-                       GetInset(i)->Ascii(buffer, ost);
+                        getInset(i)->lyxCode() == Inset::MATH_CODE) {
+                       ostringstream ost;
+                       getInset(i)->ascii(buffer, ost);
                        s += subst(ost.str().c_str(),'\n',' ');
                }
        }
 
-#ifndef NEW_INSETS
-       if (next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE 
-           && footnoteflag == LyXParagraph::NO_FOOTNOTE)
-               s += NextAfterFootnote()->String(buffer, false);
+       if (isRightToLeftPar(bparams))
+               reverse(s.begin() + len,s.end());
 
-       if (!IsDummy()) {
-#endif
-               if (isRightToLeftPar(bparams))
-                       reverse(s.begin() + len,s.end());
-#ifndef NEW_INSETS
-       }
-#endif
        return s;
 }
 
 
-string const LyXParagraph::String(Buffer const * buffer, 
-                           LyXParagraph::size_type beg,
-                           LyXParagraph::size_type end)
+string const Paragraph::asString(Buffer const * buffer, 
+                                pos_type beg, pos_type end, bool label)
 {
-       string s;
+       ostringstream ost;
 
-#ifndef NEW_INSETS
-       if (beg == 0 && !IsDummy() && !params.labelString().empty())
-#else
-       if (beg == 0 && !params.labelString().empty())
-#endif
-               s += params.labelString() + ' ';
+       if (beg == 0 && label && !params().labelString().empty())
+               ost << params().labelString() << ' ';
 
-       for (LyXParagraph::size_type i = beg; i < end; ++i) {
-               value_type c = GetUChar(buffer->params, i);
+       for (pos_type i = beg; i < end; ++i) {
+               value_type const c = getUChar(buffer->params, i);
                if (IsPrintable(c))
-                       s += c;
+                       ost << c;
+               else if (c == META_NEWLINE)
+                       ost << '\n';
+               else if (c == META_HFILL)
+                       ost << '\t'; 
                else if (c == META_INSET) {
-                       std::ostringstream ost;
-                       GetInset(i)->Ascii(buffer, ost);
-                       s += ost.str().c_str();
+                       getInset(i)->ascii(buffer, ost);
                }
        }
 
-       return s;
+       return ost.str().c_str();
 }
 
 
-void LyXParagraph::SetInsetOwner(Inset * i)
+void Paragraph::setInsetOwner(Inset * i)
 {
-       inset_owner = i;
+       pimpl_->inset_owner = i;
        for (InsetList::const_iterator cit = insetlist.begin();
             cit != insetlist.end(); ++cit) {
-               if ((*cit).inset)
-                       (*cit).inset->setOwner(i);
+               if (cit->inset)
+                       cit->inset->setOwner(i);
        }
 }
 
 
-void LyXParagraph::deleteInsetsLyXText(BufferView * bv)
+void Paragraph::deleteInsetsLyXText(BufferView * bv)
 {
        // then the insets
        for (InsetList::const_iterator cit = insetlist.begin();
             cit != insetlist.end(); ++cit) {
-               if ((*cit).inset) {
-                       if ((*cit).inset->IsTextInset()) {
+               if (cit->inset) {
+                       if (cit->inset->isTextInset()) {
                                static_cast<UpdatableInset *>
-                                       ((*cit).inset)->deleteLyXText(bv);
+                                       (cit->inset)->deleteLyXText(bv, true);
                        }
                }
        }
 }
 
 
-void LyXParagraph::resizeInsetsLyXText(BufferView * bv)
+void Paragraph::resizeInsetsLyXText(BufferView * bv)
 {
        // then the insets
        for (InsetList::const_iterator cit = insetlist.begin();
-            cit != insetlist.end(); ++cit) {
-               if ((*cit).inset) {
-                       if ((*cit).inset->IsTextInset()) {
+            cit != insetlist.end(); ++cit)
+       {
+               if (cit->inset) {
+                       if (cit->inset->isTextInset()) {
                                static_cast<UpdatableInset *>
-                                       ((*cit).inset)->resizeLyXText(bv);
+                                       (cit->inset)->resizeLyXText(bv, true);
                        }
                }
        }
 }
 
 
-void LyXParagraph::fitToSize()
+void Paragraph::setContentsFromPar(Paragraph * par)
+{
+       pimpl_->setContentsFromPar(par);
+}
+
+
+lyx::pos_type Paragraph::size() const
+{
+       return pimpl_->size();
+}
+
+
+Paragraph::value_type Paragraph::getChar(pos_type pos) const
+{
+       return pimpl_->getChar(pos);
+}
+
+
+int Paragraph::id() const
+{
+       return pimpl_->id_;
+}
+
+
+void  Paragraph::id(int id_arg)
+{
+       pimpl_->id_ = id_arg;
+}
+
+
+string const & Paragraph::layout() const
+{
+       return layout_;
+}
+
+
+void Paragraph::layout(string const & new_layout)
+{
+       layout_ = new_layout;
+}
+
+
+bool Paragraph::isFirstInSequence() const
+{
+       Paragraph const * dhook = depthHook(getDepth());
+       return (dhook == this
+               || dhook->layout() != layout()
+               || dhook->getDepth() != getDepth());
+}
+
+
+Inset * Paragraph::inInset() const
+{
+       return pimpl_->inset_owner;
+}
+
+
+void Paragraph::clearContents()
+{
+       pimpl_->clear();
+}
+
+
+void Paragraph::setCounter(int i, int v)
+{
+       pimpl_->counter_[i] = v;
+}
+
+
+int Paragraph::getCounter(int i) const
+{
+       return pimpl_->counter_[i];
+}
+
+
+void Paragraph::incCounter(int i)
+{
+       pimpl_->counter_[i]++;
+}
+
+
+void Paragraph::setChar(pos_type pos, value_type c)
+{
+       pimpl_->setChar(pos, c);
+}
+
+
+Paragraph::inset_iterator::inset_iterator(Paragraph::InsetList::iterator const & iter)
+ : it(iter) 
+{}
+
+
+Paragraph::inset_iterator Paragraph::inset_iterator_begin()
+{
+       return inset_iterator(insetlist.begin());
+}
+
+
+Paragraph::inset_iterator Paragraph::inset_iterator_end()
+{
+       return inset_iterator(insetlist.end());
+}
+
+
+ParagraphParameters & Paragraph::params()
 {
-       TextContainer tmp(text.begin(), text.end());
-       text.swap(tmp);
+       return pimpl_->params;
 }
 
 
-void LyXParagraph::setContentsFromPar(LyXParagraph * par)
+ParagraphParameters const & Paragraph::params() const
 {
-       text = par->text;
+       return pimpl_->params;
+}
+
+
+Paragraph * Paragraph::getParFromID(int id) const
+{
+       return pimpl_->getParFromID(id);
+}
+
+
+bool Paragraph::isFreeSpacing() const
+{
+       // for now we just need this, later should we need this in some
+       // other way we can always add a function to Inset::() too.
+       if (pimpl_->inset_owner && pimpl_->inset_owner->owner())
+               return (pimpl_->inset_owner->owner()->lyxCode() == Inset::ERT_CODE);
+       return false;
 }