/* This file is part of
* ======================================================
- *
+ *
* LyX, The Document Processor
- *
+ *
* Copyright 1998-2001 The LyX Team.
*
* ====================================================== */
#include "lyxtext.h"
#include "insets/insettext.h"
#include "support/LOstream.h"
+#include "support/lstrings.h"
#include "FloatList.h"
#include "LaTeXFeatures.h"
#include "debug.h"
#include "Floating.h"
#include "buffer.h"
+#include "LyXView.h"
+#include "frontends/Dialogs.h"
using std::ostream;
using std::endl;
// within - This (optional) argument determines whether floats of this
// class will be numbered within some sectional unit of the
// document. For example, if within is equal to chapter, the
-// floats will be numbered within chapters.
+// floats will be numbered within chapters.
// \floatstyle{style}
// style - plain, boxed, ruled
// \floatname{float}{floatname}
//
// Lgb
-InsetFloat::InsetFloat(string const & type)
- : InsetCollapsable(), wide_(false)
+namespace {
+
+string floatname(string const & type)
{
- string lab(_("float:"));
- lab += type;
+ FloatList::const_iterator it = floatList[type];
+ if (it == floatList.end())
+ return type;
+
+ return _(it->second.name());
+}
+
+} // namespace anon
+
+
+InsetFloat::InsetFloat(BufferParams const & bp, string const & type)
+ : InsetCollapsable(bp), wide_(false)
+{
+ string lab(_("float: "));
+ lab += floatname(type);
setLabel(lab);
LyXFont font(LyXFont::ALL_SANE);
font.decSize();
font.decSize();
font.setColor(LColor::collapsable);
setLabelFont(font);
- setAutoCollapse(false);
floatType_ = type;
setInsetName(type);
}
+InsetFloat::InsetFloat(InsetFloat const & in, bool same_id)
+ : InsetCollapsable(in, same_id), floatType_(in.floatType_),
+ floatPlacement_(in.floatPlacement_), wide_(in.wide_)
+{}
+
+
+InsetFloat::~InsetFloat()
+{
+ hideDialog();
+}
+
+
void InsetFloat::write(Buffer const * buf, ostream & os) const
{
os << "Float " // getInsetName()
} else {
os << "wide false\n";
}
-
+
InsetCollapsable::write(buf, os);
}
void InsetFloat::read(Buffer const * buf, LyXLex & lex)
{
- if (lex.IsOK()) {
+ if (lex.isOK()) {
lex.next();
- string token = lex.GetString();
+ string token = lex.getString();
if (token == "placement") {
lex.next();
- floatPlacement_ = lex.GetString();
+ floatPlacement_ = lex.getString();
} else {
lyxerr << "InsetFloat::Read: Missing placement!"
<< endl;
+ // take countermeasures
+ lex.pushToken(token);
}
lex.next();
- token = lex.GetString();
+ token = lex.getString();
if (token == "wide") {
lex.next();
- string const tmptoken = lex.GetString();
+ string const tmptoken = lex.getString();
if (tmptoken == "true")
wide(true);
else
} else {
lyxerr << "InsetFloat::Read:: Missing wide!"
<< endl;
+ // take countermeasures
+ lex.pushToken(token);
}
}
InsetCollapsable::read(buf, lex);
void InsetFloat::validate(LaTeXFeatures & features) const
{
- features.usedFloats.insert(floatType_);
+ if (contains(placement(), "H")) {
+ features.require("float");
+ }
+
+ features.useFloat(floatType_);
InsetCollapsable::validate(features);
}
Inset * InsetFloat::clone(Buffer const &, bool same_id) const
{
- InsetFloat * result = new InsetFloat(floatType_);
- result->inset.init(&inset, same_id);
-
- result->collapsed = collapsed;
- if (same_id)
- result->id_ = id_;
- return result;
+ return new InsetFloat(*const_cast<InsetFloat *>(this), same_id);
}
&& buf_placement != def_placement) {
placement = buf_placement;
}
-
+
os << "\\begin{" << tmptype << "}";
// We only output placement if different from the def_placement.
if (!placement.empty()) {
os << "[" << placement << "]";
}
-
+
os << "%\n";
-
+
int const i = inset.latex(buf, os, fragile, fp);
os << "\\end{" << tmptype << "}%\n";
-
+
return i + 2;
}
-int InsetFloat::docBook(Buffer const * buf, ostream & os) const
+int InsetFloat::docbook(Buffer const * buf, ostream & os) const
{
os << "<" << floatType_ << ">";
- int const i = inset.docBook(buf, os);
+ int const i = inset.docbook(buf, os);
os << "</" << floatType_ << ">";
return i;
}
-bool InsetFloat::insertInsetAllowed(Inset * in) const
+bool InsetFloat::insetAllowed(Inset::Code code) const
{
- if ((in->lyxCode() == Inset::FOOT_CODE) ||
- (in->lyxCode() == Inset::MARGIN_CODE)) {
+ if (code == Inset::FLOAT_CODE)
+ return false;
+ if (inset.getLockingInset() != const_cast<InsetFloat *>(this))
+ return inset.insetAllowed(code);
+ if ((code == Inset::FOOT_CODE) || (code == Inset::MARGIN_CODE))
return false;
- }
return true;
}
-void InsetFloat::insetButtonRelease(BufferView * bv, int x, int y, int button)
+bool InsetFloat::showInsetDialog(BufferView * bv) const
{
- if (x >= top_x
- && x < button_length
- && y >= button_top_y
- && y < button_bottom_y
- && button == 3) {
- // This obviously need to change.
- lyxerr << "InsetFloat: Let's edit this floats parameters!"
- << endl;
- //bv->owner()->getDialogs()->showFloat(this);
- } else {
- InsetCollapsable::insetButtonRelease(bv, x, y, button);
+ if (!inset.showInsetDialog(bv)) {
+ bv->owner()->getDialogs()->showFloat(const_cast<InsetFloat *>(this));
}
+ return true;
}
-string const & InsetFloat::type() const
+string const & InsetFloat::type() const
{
return floatType_;
}
void InsetFloat::placement(string const & p)
{
- // Here we should only allow the placement to be set
+ // FIX: Here we should only allow the placement to be set
// if a valid value.
-#ifdef WITH_WARNINGS
-#warning FIX!
-#endif
floatPlacement_ = p;
}
void InsetFloat::wide(bool w)
{
wide_ = w;
- if (wide_) {
- string lab(_("float:"));
- lab += floatType_;
+
+ string lab(_("float:"));
+ lab += floatname(floatType_);
+
+ if (wide_)
lab += "*";
- setLabel(lab);
- } else {
- string lab(_("float:"));
- lab += floatType_;
- setLabel(lab);
- }
+
+ setLabel(lab);
}