*/
bool file_fully_loaded;
- /// our Text that should be wrapped in an InsetText
- InsetText inset;
-
///
mutable TocBackend toc_backend;
mutable EmbeddedFileList bibfilesCache_;
mutable RefCache ref_cache_;
+
+ /// our Text that should be wrapped in an InsetText
+ InsetText inset;
};
/// Creates the per buffer temporary directory
Buffer::Impl::Impl(Buffer & parent, FileName const & file, bool readonly_)
: parent_buffer(0), lyx_clean(true), bak_clean(true), unnamed(false),
read_only(readonly_), filename(file), file_fully_loaded(false),
- inset(params), toc_backend(&parent), macro_lock(false),
+ toc_backend(&parent), macro_lock(false),
embedded_files(), timestamp_(0), checksum_(0), wa_(0),
undo_(parent)
{
temppath = createBufferTmpDir();
- inset.setBuffer(parent);
- inset.setAutoBreakRows(true);
lyxvc.setBuffer(&parent);
if (use_gui)
wa_ = new frontend::WorkAreaManager;
{
LYXERR(Debug::INFO, "Buffer::Buffer()");
+ d->inset.setBuffer(*this);
+ d->inset.initParagraphs(*this);
+ d->inset.setAutoBreakRows(true);
d->inset.getText(0)->setMacrocontextPosition(par_iterator_begin());
}
lyx::dispatch(FuncRequest(LFUN_LINE_BEGIN));
lyx::dispatch(FuncRequest(LFUN_LINE_END_SELECT));
lyx::dispatch(FuncRequest(LFUN_CUT));
- Inset * inset = new InsetEnvironment(params, layout);
+ Inset * inset = new InsetEnvironment(bv.buffer(), layout);
insertInset(cur, inset);
//inset->edit(cur, true);
//lyx::dispatch(FuncRequest(LFUN_PASTE));
case LFUN_FLEX_INSERT: {
string s = cmd.getArg(0);
- return new InsetFlex(params, params.documentClassPtr(), s);
+ return new InsetFlex(buf, buf.params().documentClassPtr(), s);
}
case LFUN_NOTE_INSERT: {
string arg = cmd.getArg(0);
if (arg.empty())
arg = "Note";
- return new InsetNote(params, arg);
+ return new InsetNote(buf, arg);
}
case LFUN_BOX_INSERT: {
string arg = cmd.getArg(0);
if (arg.empty())
arg = "Boxed";
- return new InsetBox(params, arg);
+ return new InsetBox(buf, arg);
}
case LFUN_BRANCH_INSERT: {
docstring arg = cmd.argument();
if (arg.empty())
arg = from_ascii("none");
- return new InsetBranch(params, InsetBranchParams(arg));
+ return new InsetBranch(buf, InsetBranchParams(arg));
}
case LFUN_ERT_INSERT:
- return new InsetERT(params);
+ return new InsetERT(buf);
case LFUN_LISTING_INSERT:
- return new InsetListings(params);
+ return new InsetListings(buf);
case LFUN_FOOTNOTE_INSERT:
- return new InsetFoot(params);
+ return new InsetFoot(buf);
case LFUN_MARGINALNOTE_INSERT:
- return new InsetMarginal(params);
+ return new InsetMarginal(buf);
case LFUN_OPTIONAL_INSERT:
- return new InsetOptArg(params);
+ return new InsetOptArg(buf);
case LFUN_BIBITEM_INSERT:
return new InsetBibitem(InsetCommandParams(BIBITEM_CODE));
case LFUN_FLOAT_INSERT: {
// check if the float type exists
string const argument = to_utf8(cmd.argument());
- if (params.documentClass().floats().typeExist(argument))
- return new InsetFloat(params, argument);
+ if (buf.params().documentClass().floats().typeExist(argument))
+ return new InsetFloat(buf, argument);
lyxerr << "Non-existent float type: " << argument << endl;
}
// check if the float type exists
string const argument = to_utf8(cmd.argument());
if (params.documentClass().floats().typeExist(argument)) {
- auto_ptr<InsetFloat> p(new InsetFloat(params, argument));
+ auto_ptr<InsetFloat> p(new InsetFloat(buf, argument));
p->wide(true, params);
return p.release();
}
case LFUN_WRAP_INSERT: {
string const argument = to_utf8(cmd.argument());
if (argument == "figure" || argument == "table")
- return new InsetWrap(params, argument);
+ return new InsetWrap(buf, argument);
lyxerr << "Non-existent wrapfig type: " << argument << endl;
return 0;
}
case LFUN_INDEX_INSERT:
- return new InsetIndex(params);
+ return new InsetIndex(buf);
case LFUN_NOMENCL_INSERT: {
InsetCommandParams icp(NOMENCL_CODE);
}
case LFUN_CAPTION_INSERT: {
- auto_ptr<InsetCaption> inset(new InsetCaption(params));
+ auto_ptr<InsetCaption> inset(new InsetCaption(buf));
inset->setAutoBreakRows(true);
inset->setDrawFrame(true);
inset->setFrameColor(Color_captionframe);
return new InsetTOC(InsetCommandParams(TOC_CODE));
case LFUN_ENVIRONMENT_INSERT:
- return new InsetEnvironment(params, cmd.argument());
+ return new InsetEnvironment(buf, cmd.argument());
case LFUN_INFO_INSERT:
- return new InsetInfo(params, to_utf8(cmd.argument()));
+ return new InsetInfo(buf, to_utf8(cmd.argument()));
#if 0
case LFUN_THEOREM_INSERT:
return new InsetTheorem;
case ERT_CODE: {
InsetCollapsable::CollapseStatus st;
InsetERTMailer::string2params(to_utf8(cmd.argument()), st);
- return new InsetERT(params, st);
+ return new InsetERT(buf, st);
}
case LISTINGS_CODE: {
InsetListingsParams par;
InsetListingsMailer::string2params(to_utf8(cmd.argument()), par);
- return new InsetListings(params, par);
+ return new InsetListings(buf, par);
}
case EXTERNAL_CODE: {
}
case INDEX_CODE:
- return new InsetIndex(params);
+ return new InsetIndex(buf);
case NOMENCL_CODE: {
InsetCommandParams icp(code);
case REF_CODE: {
InsetCommandParams icp(code);
InsetCommandMailer::string2params(name, to_utf8(cmd.argument()), icp);
- return new InsetRef(icp, buf);
+ return new InsetRef(buf, icp);
}
case TOC_CODE: {
break;
case REF_CODE:
if (!inscmd["name"].empty() || !inscmd["reference"].empty())
- inset.reset(new InsetRef(inscmd, buf));
+ inset.reset(new InsetRef(buf, inscmd));
break;
case TOC_CODE:
inset.reset(new InsetTOC(inscmd));
} else if (tmptok == "Graphics") {
inset.reset(new InsetGraphics);
} else if (tmptok == "Note") {
- inset.reset(new InsetNote(buf.params(), tmptok));
+ inset.reset(new InsetNote(buf, tmptok));
} else if (tmptok == "Box") {
- inset.reset(new InsetBox(buf.params(), tmptok));
+ inset.reset(new InsetBox(buf, tmptok));
} else if (tmptok == "Flex") {
lex.next();
string s = lex.getString();
- inset.reset(new InsetFlex(buf.params(),
+ inset.reset(new InsetFlex(buf,
buf.params().documentClassPtr(), s));
} else if (tmptok == "Branch") {
- inset.reset(new InsetBranch(buf.params(),
+ inset.reset(new InsetBranch(buf,
InsetBranchParams()));
} else if (tmptok == "Environment") {
lex.next();
- inset.reset(new InsetEnvironment(buf.params(), lex.getDocString()));
+ inset.reset(new InsetEnvironment(buf, lex.getDocString()));
} else if (tmptok == "ERT") {
- inset.reset(new InsetERT(buf.params()));
+ inset.reset(new InsetERT(buf));
} else if (tmptok == "listings") {
- inset.reset(new InsetListings(buf.params()));
+ inset.reset(new InsetListings(buf));
} else if (tmptok == "InsetSpace") {
inset.reset(new InsetSpace);
} else if (tmptok == "Tabular") {
inset.reset(new InsetTabular(buf));
} else if (tmptok == "Text") {
- inset.reset(new InsetText(buf.params()));
+ inset.reset(new InsetText(buf));
} else if (tmptok == "VSpace") {
inset.reset(new InsetVSpace);
} else if (tmptok == "Foot") {
- inset.reset(new InsetFoot(buf.params()));
+ inset.reset(new InsetFoot(buf));
} else if (tmptok == "Marginal") {
- inset.reset(new InsetMarginal(buf.params()));
+ inset.reset(new InsetMarginal(buf));
} else if (tmptok == "OptArg") {
- inset.reset(new InsetOptArg(buf.params()));
+ inset.reset(new InsetOptArg(buf));
} else if (tmptok == "Float") {
lex.next();
string tmptok = lex.getString();
- inset.reset(new InsetFloat(buf.params(), tmptok));
+ inset.reset(new InsetFloat(buf, tmptok));
} else if (tmptok == "Wrap") {
lex.next();
string tmptok = lex.getString();
- inset.reset(new InsetWrap(buf.params(), tmptok));
+ inset.reset(new InsetWrap(buf, tmptok));
#if 0
} else if (tmptok == "Theorem") {
inset.reset(new InsetList);
#endif
} else if (tmptok == "Caption") {
- inset.reset(new InsetCaption(buf.params()));
+ inset.reset(new InsetCaption(buf));
} else if (tmptok == "Index") {
- inset.reset(new InsetIndex(buf.params()));
+ inset.reset(new InsetIndex(buf));
} else if (tmptok == "FloatList") {
inset.reset(new InsetFloatList);
} else if (tmptok == "Info") {
- inset.reset(new InsetInfo(buf.params()));
+ inset.reset(new InsetInfo(buf));
} else {
lyxerr << "unknown Inset type '" << tmptok
<< "'" << endl;
} // anon
-InsetBox::InsetBox(BufferParams const & bp, string const & label)
- : InsetCollapsable(bp), params_(label)
+InsetBox::InsetBox(Buffer const & buffer, string const & label)
+ : InsetCollapsable(buffer), params_(label)
{
if (forceEmptyLayout())
- paragraphs().back().setLayout(bp.documentClass().emptyLayout());
+ paragraphs().back().setLayout(buffer.params().documentClass().emptyLayout());
}
class InsetBox : public InsetCollapsable {
public:
///
- InsetBox(BufferParams const &, std::string const &);
+ InsetBox(Buffer const &, std::string const &);
///
~InsetBox();
///
namespace lyx {
-InsetBranch::InsetBranch(BufferParams const & bp,
- InsetBranchParams const & params)
- : InsetCollapsable(bp), params_(params)
-{}
-
-
-InsetBranch::InsetBranch(InsetBranch const & in)
- : InsetCollapsable(in), params_(in.params_)
+InsetBranch::InsetBranch(Buffer const & buf, InsetBranchParams const & params)
+ : InsetCollapsable(buf), params_(params)
{}
}
-Inset * InsetBranch::clone() const
-{
- return new InsetBranch(*this);
-}
-
-
docstring InsetBranch::editMessage() const
{
return _("Opened Branch Inset");
class InsetBranch : public InsetCollapsable {
public:
///
- InsetBranch(BufferParams const &, InsetBranchParams const &);
+ InsetBranch(Buffer const &, InsetBranchParams const &);
///
~InsetBranch();
///
docstring toolTip(BufferView const & bv, int x, int y) const;
protected:
///
- InsetBranch(InsetBranch const &);
- ///
- virtual void doDispatch(Cursor & cur, FuncRequest & cmd);
+ void doDispatch(Cursor & cur, FuncRequest & cmd);
///
docstring name() const { return from_ascii("Branch"); }
private:
+ ///
friend class InsetBranchParams;
-
- virtual Inset * clone() const;
-
+ ///
+ Inset * clone() const { return new InsetBranch(*this); }
///
InsetBranchParams params_;
};
}
-InsetCaption::InsetCaption(BufferParams const & bp)
- : InsetText(bp)
+InsetCaption::InsetCaption(Buffer const & buf)
+ : InsetText(buf)
{
setAutoBreakRows(true);
setDrawFrame(true);
setFrameColor(Color_captionframe);
- //FIXME Do we need to set all paragraphs here? or will there
- //always only be one?
- paragraphs().back().setLayout(bp.documentClass().emptyLayout());
+ // There will always be only one
+ paragraphs().back().setLayout(buf.params().documentClass().emptyLayout());
}
public:
///
InsetCaption(InsetCaption const &);
- InsetCaption(BufferParams const &);
+ InsetCaption(Buffer const &);
///
virtual ~InsetCaption() {}
///
}
-InsetCollapsable::InsetCollapsable(BufferParams const & bp,
+InsetCollapsable::InsetCollapsable(Buffer const & buf,
CollapseStatus status, DocumentClass * dc)
- : InsetText(bp), status_(status),
+ : InsetText(buf), status_(status),
openinlined_(false), autoOpen_(false), mouse_hover_(false)
{
setLayout(dc);
setAutoBreakRows(true);
setDrawFrame(true);
setFrameColor(Color_collapsableframe);
- paragraphs().back().setLayout(bp.documentClass().emptyLayout());
+ paragraphs().back().setLayout(buf.params().documentClass().emptyLayout());
}
class InsetCollapsable : public InsetText {
public:
///
- InsetCollapsable(BufferParams const &,
+ InsetCollapsable(Buffer const &,
CollapseStatus status = Inset::Open, DocumentClass * tc = 0);
///
InsetCollapsable(InsetCollapsable const & rhs);
namespace lyx {
-InsetERT::InsetERT(BufferParams const & bp, CollapseStatus status)
- : InsetCollapsable(bp, status)
+InsetERT::InsetERT(Buffer const & buf, CollapseStatus status)
+ : InsetCollapsable(buf, status)
{}
class InsetERT : public InsetCollapsable {
public:
///
- InsetERT(BufferParams const &, CollapseStatus status = Open);
+ InsetERT(Buffer const &, CollapseStatus status = Open);
#if 0
///
InsetERT(BufferParams const &,
#include "InsetEnvironment.h"
+#include "Buffer.h"
#include "BufferParams.h"
-#include "support/gettext.h"
#include "Layout.h"
#include "OutputParams.h"
#include "output_latex.h"
#include "TexRow.h"
#include "TextClass.h"
+#include "support/gettext.h"
+
using namespace std;
namespace lyx {
-InsetEnvironment::InsetEnvironment
- (BufferParams const & bp, docstring const & name)
- : InsetText(bp), layout_(bp.documentClass()[name]), name_(name)
+InsetEnvironment::InsetEnvironment(Buffer const & buf, docstring const & name)
+ : InsetText(buf), layout_(buf.params().documentClass()[name]), name_(name)
{
setAutoBreakRows(true);
setDrawFrame(true);
{}
-Inset * InsetEnvironment::clone() const
-{
- return new InsetEnvironment(*this);
-}
-
-
void InsetEnvironment::write(ostream & os) const
{
os << "Environment " << to_utf8(name()) << "\n";
class InsetEnvironment : public InsetText {
public:
///
- InsetEnvironment(BufferParams const &, docstring const & name);
+ InsetEnvironment(Buffer const &, docstring const & name);
///
docstring name() const { return name_; }
///
InsetEnvironment(InsetEnvironment const &);
private:
///
- Inset * clone() const;
+ Inset * clone() const { return new InsetEnvironment(*this); }
/// the layout
LayoutPtr layout_;
///
namespace lyx {
-InsetFlex::InsetFlex(BufferParams const & bp,
+InsetFlex::InsetFlex(Buffer const & buf,
DocumentClass * dc, string const & layoutName)
- : InsetCollapsable(bp, Collapsed, dc),
+ : InsetCollapsable(buf, Collapsed, dc),
name_(layoutName)
{
setLayout(dc); // again, because now the name is initialized
{}
-Inset * InsetFlex::clone() const
-{
- return new InsetFlex(*this);
-}
-
-
docstring InsetFlex::editMessage() const
{
return _("Opened Flex Inset");
class InsetFlex : public InsetCollapsable {
public:
///
- InsetFlex(BufferParams const &, DocumentClass * dc,
+ InsetFlex(Buffer const &, DocumentClass * dc,
std::string const & layoutName);
///
docstring name() const { return from_utf8(name_); }
InsetFlex(InsetFlex const &);
private:
- virtual Inset * clone() const;
+ Inset * clone() const { return new InsetFlex(*this); }
///
std::string name_;
// Lgb
-InsetFloat::InsetFloat(BufferParams const & bp, string const & type)
- : InsetCollapsable(bp), name_(from_utf8(type))
+InsetFloat::InsetFloat(Buffer const & buf, string const & type)
+ : InsetCollapsable(buf), name_(from_utf8(type))
{
- setLabel(_("float: ") + floatName(type, bp));
+ setLabel(_("float: ") + floatName(type, buf.params()));
params_.type = type;
}
class InsetFloat : public InsetCollapsable {
public:
///
- InsetFloat(BufferParams const &, std::string const &);
+ InsetFloat(Buffer const &, std::string const &);
///
~InsetFloat();
///
namespace lyx {
-InsetFoot::InsetFoot(BufferParams const & bp)
- : InsetFootlike(bp)
+InsetFoot::InsetFoot(Buffer const & buf)
+ : InsetFootlike(buf)
{}
{}
-Inset * InsetFoot::clone() const
-{
- return new InsetFoot(*this);
-}
-
-
docstring InsetFoot::editMessage() const
{
return _("Opened Footnote Inset");
class InsetFoot : public InsetFootlike {
public:
///
- InsetFoot(BufferParams const &);
+ InsetFoot(Buffer const &);
///
InsetCode lyxCode() const { return FOOT_CODE; }
///
protected:
InsetFoot(InsetFoot const &);
private:
- Inset * clone() const;
+ Inset * clone() const { return new InsetFoot(*this); }
};
namespace lyx {
-InsetFootlike::InsetFootlike(BufferParams const & bp)
- : InsetCollapsable(bp)
+InsetFootlike::InsetFootlike(Buffer const & buf)
+ : InsetCollapsable(buf)
{}
class InsetFootlike : public InsetCollapsable {
public:
///
- InsetFootlike(BufferParams const &);
+ InsetFootlike(Buffer const &);
///
InsetFootlike(InsetFootlike const &);
///
namespace lyx {
-InsetIndex::InsetIndex(BufferParams const & bp)
- : InsetCollapsable(bp)
+InsetIndex::InsetIndex(Buffer const & buf)
+ : InsetCollapsable(buf)
{}
class InsetIndex : public InsetCollapsable {
public:
///
- InsetIndex(BufferParams const &);
+ InsetIndex(Buffer const &);
///
InsetIndex(InsetIndex const &);
///
namespace lyx {
-InsetInfo::InsetInfo(BufferParams const & bp, string const & name)
- : InsetText(bp), type_(UNKNOWN_INFO), name_(),
+InsetInfo::InsetInfo(Buffer const & buf, string const & name)
+ : InsetText(buf), type_(UNKNOWN_INFO), name_(),
mouse_hover_(false)
{
setAutoBreakRows(true);
};
///
- InsetInfo(BufferParams const & bp, std::string const & info = std::string());
+ InsetInfo(Buffer const & buf, std::string const & info = std::string());
///
Inset * editXY(Cursor & cur, int x, int y);
///
char const lstinline_delimiters[] =
"!*()-=+|;:'\"`,<.>/?QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm";
-InsetListings::InsetListings(BufferParams const & bp, InsetListingsParams const & par)
- : InsetCollapsable(bp, par.status())
+InsetListings::InsetListings(Buffer const & buf, InsetListingsParams const & par)
+ : InsetCollapsable(buf, par.status())
{}
class InsetListings : public InsetCollapsable {
public:
///
- InsetListings(BufferParams const &, InsetListingsParams const & par = InsetListingsParams());
+ InsetListings(Buffer const &, InsetListingsParams const & par = InsetListingsParams());
///
~InsetListings();
///
namespace lyx {
-InsetMarginal::InsetMarginal(BufferParams const & bp)
- : InsetFootlike(bp)
+InsetMarginal::InsetMarginal(Buffer const & buf)
+ : InsetFootlike(buf)
{}
class InsetMarginal : public InsetFootlike {
public:
///
- InsetMarginal(BufferParams const &);
+ InsetMarginal(Buffer const &);
///
InsetCode lyxCode() const { return MARGIN_CODE; }
///
}
-InsetNote::InsetNote(BufferParams const & bp, string const & label)
- : InsetCollapsable(bp)
+InsetNote::InsetNote(Buffer const & buf, string const & label)
+ : InsetCollapsable(buf)
{
params_.type = notetranslator().find(label);
}
class InsetNote : public InsetCollapsable {
public:
///
- InsetNote(BufferParams const &, std::string const &);
+ InsetNote(Buffer const &, std::string const &);
///
~InsetNote();
///
namespace lyx {
-InsetOptArg::InsetOptArg(BufferParams const & ins)
- : InsetCollapsable(ins)
+InsetOptArg::InsetOptArg(Buffer const & buf)
+ : InsetCollapsable(buf)
{}
*/
class InsetOptArg : public InsetCollapsable {
public:
- InsetOptArg(BufferParams const &);
+ InsetOptArg(Buffer const &);
/// code of the inset
InsetCode lyxCode() const { return OPTARG_CODE; }
}
-InsetQuotes::InsetQuotes(char_type c, BufferParams const & params)
- : language_(params.quotes_language), times_(params.quotes_times)
+InsetQuotes::InsetQuotes(Buffer const & buf, char_type c)
+ : language_(buf.params().quotes_language), times_(buf.params().quotes_times)
{
getPosition(c);
}
*/
explicit InsetQuotes(std::string const & str = "eld");
/// Create the right quote inset after character c
- InsetQuotes(char_type c, BufferParams const & params);
+ InsetQuotes(Buffer const & buffer, char_type c);
/// Direct access to inner/outer quotation marks
InsetQuotes(char_type c, quote_language l, quote_times t);
///
namespace lyx {
-InsetRef::InsetRef(InsetCommandParams const & p, Buffer const & buf)
+InsetRef::InsetRef(Buffer const & buf, InsetCommandParams const & p)
: InsetCommand(p, "ref"), isLatex(buf.isLatex())
{}
static std::string const & getName(int type);
- InsetRef(InsetCommandParams const &, Buffer const &);
+ InsetRef(Buffer const & buffer, InsetCommandParams const &);
/// verify label and reference.
/**
/////////////////////////////////////////////////////////////////////
-Tabular::CellData::CellData(Buffer const & buffer)
+Tabular::CellData::CellData(Buffer const & buf)
: cellno(0),
width(0),
multicolumn(Tabular::CELL_NORMAL),
right_line(false),
usebox(BOX_NONE),
rotate(false),
- inset(new InsetText(buffer.params()))
+ inset(new InsetText(buf))
{
- inset->setBuffer(const_cast<Buffer &>(buffer));
- inset->paragraphs().back().setLayout(buffer.params().documentClass().emptyLayout());
+ inset->setBuffer(const_cast<Buffer &>(buf));
+ inset->paragraphs().back().setLayout(buf.params().documentClass().emptyLayout());
}
/////////////////////////////////////////////////////////////////////
-InsetText::InsetText(BufferParams const & bp)
+InsetText::InsetText(Buffer const & buf)
: drawFrame_(false), frame_color_(Color_insetframe)
{
- paragraphs().push_back(Paragraph());
- Paragraph & ourpar = paragraphs().back();
- ourpar.setEmptyOrDefaultLayout(bp.documentClass());
- ourpar.setInsetOwner(this);
+ initParagraphs(buf);
}
{}
+void InsetText::initParagraphs(Buffer const & buf)
+{
+ BOOST_ASSERT(paragraphs().empty());
+ buffer_ = const_cast<Buffer *>(&buf);
+ paragraphs().push_back(Paragraph());
+ Paragraph & ourpar = paragraphs().back();
+ ourpar.setEmptyOrDefaultLayout(buf.params().documentClass());
+ ourpar.setInsetOwner(this);
+}
+
void InsetText::setParagraphOwner()
{
for_each(paragraphs().begin(), paragraphs().end(),
class InsetText : public Inset {
public:
///
- explicit InsetText(BufferParams const &);
+ explicit InsetText(Buffer const & buffer);
///
InsetText();
///
InsetText(InsetText const &);
+ ///
+ void initParagraphs(Buffer const & buffer);
///
Dimension const dimension(BufferView const &) const;
namespace lyx {
-InsetWrap::InsetWrap(BufferParams const & bp, string const & type)
- : InsetCollapsable(bp), name_(from_utf8(type))
+InsetWrap::InsetWrap(Buffer const & buf, string const & type)
+ : InsetCollapsable(buf), name_(from_utf8(type))
{
- setLabel(_("wrap: ") + floatName(type, bp));
+ setLabel(_("wrap: ") + floatName(type, buf.params()));
params_.type = type;
params_.lines = 0;
params_.placement = "o";
class InsetWrap : public InsetCollapsable {
public:
///
- InsetWrap(BufferParams const &, std::string const &);
+ InsetWrap(Buffer const &, std::string const &);
///
~InsetWrap();
///