*
* LyX, The Document Processor
*
- * Copyright 1998 The LyX Team.
+ * Copyright 1998-2001 The LyX Team.
*
- *======================================================*/
+ * ====================================================== */
#include <config.h>
#include "gettext.h"
#include "lyxfont.h"
#include "BufferView.h"
-#include "Painter.h"
#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;
// \newfloat{algorithm}{htbp}{loa}[<sect>]
// \floatname{algorithm}{Algorithm}
//
+// The intention is that floats should be definable from two places:
+// - layout files
+// - the "gui" (i.e. by the user)
+//
+// From layout files.
+// This should only be done for floats defined in a documentclass and that
+// does not need any additional packages. The two most known floats in this
+// category is "table" and "figure". Floats defined in layout files are only
+// stored in lyx files if the user modifies them.
+//
+// By the user.
+// There should be a gui dialog (and also a collection of lyxfuncs) where
+// the user can modify existing floats and/or create new ones.
+//
+// The individual floats will also have some settable
+// variables: wide and placement.
+//
// Lgb
-InsetFloat::InsetFloat() : InsetCollapsable()
+InsetFloat::InsetFloat(string const & type)
+ : InsetCollapsable(), wide_(false)
{
- setLabel(_("float"));
- LyXFont font(LyXFont::ALL_SANE);
- font.decSize();
- font.decSize();
- font.setColor(LColor::footnote);
- setLabelFont(font);
- setAutoCollapse(false);
- setInsetName("Float");
- floatType = "table";
- floatPlacement = "H";
+ string lab(_("float:"));
+ lab += type;
+ setLabel(lab);
+ LyXFont font(LyXFont::ALL_SANE);
+ font.decSize();
+ font.decSize();
+ font.setColor(LColor::collapsable);
+ setLabelFont(font);
+ floatType_ = type;
+ setInsetName(type);
}
-void InsetFloat::Write(Buffer const * buf, ostream & os) const
+InsetFloat::InsetFloat(InsetFloat const & in, bool same_id)
+ : InsetCollapsable(in, same_id), floatType_(in.floatType_),
+ floatPlacement_(in.floatPlacement_), wide_(in.wide_)
+{}
+
+
+InsetFloat::~InsetFloat()
{
- os << getInsetName()
- << "\ntype " << floatType
- << "\nplacement " << floatPlacement << "\n";
- InsetCollapsable::Write(buf, os);
+ hideDialog();
}
-void InsetFloat::Read(Buffer const * buf, LyXLex & lex)
+void InsetFloat::write(Buffer const * buf, ostream & os) const
{
- if (lex.IsOK()) {
+ os << "Float " // getInsetName()
+ << floatType_ << '\n';
+
+ if (floatPlacement_.empty()) {
+ os << "placement "
+ << floatList.getType(floatType_).placement() << "\n";
+ } else {
+ os << "placement " << floatPlacement_ << "\n";
+ }
+ if (wide_) {
+ os << "wide true\n";
+ } else {
+ os << "wide false\n";
+ }
+
+ InsetCollapsable::write(buf, os);
+}
+
+
+void InsetFloat::read(Buffer const * buf, LyXLex & lex)
+{
+ if (lex.isOK()) {
lex.next();
- string token = lex.GetString();
- if (token == "type") {
+ string token = lex.getString();
+ if (token == "placement") {
lex.next();
- floatType = lex.GetString();
+ floatPlacement_ = lex.getString();
+ } else {
+ lyxerr << "InsetFloat::Read: Missing placement!"
+ << endl;
+ // take countermeasures
+ lex.pushToken(token);
}
lex.next();
- token = lex.GetString();
- if (token == "placement") {
+ token = lex.getString();
+ if (token == "wide") {
lex.next();
- floatPlacement = lex.GetString();
+ string const tmptoken = lex.getString();
+ if (tmptoken == "true")
+ wide(true);
+ else
+ wide(false);
+ } else {
+ lyxerr << "InsetFloat::Read:: Missing wide!"
+ << endl;
+ // take countermeasures
+ lex.pushToken(token);
}
}
- InsetCollapsable::Read(buf, lex);
+ InsetCollapsable::read(buf, lex);
}
-void InsetFloat::Validate(LaTeXFeatures & features) const
+void InsetFloat::validate(LaTeXFeatures & features) const
{
- features.usedFloats.insert(floatType);
+ if (contains(placement(), "H")) {
+ features.require("floats");
+ }
+
+ features.useFloat(floatType_);
+ InsetCollapsable::validate(features);
}
-Inset * InsetFloat::Clone() const
+Inset * InsetFloat::clone(Buffer const &, bool same_id) const
{
- InsetFloat * result = new InsetFloat;
- result->inset->init(inset);
-
- result->collapsed = collapsed;
- return result;
+ return new InsetFloat(*const_cast<InsetFloat *>(this), same_id);
}
-char const * InsetFloat::EditMessage() const
+string const InsetFloat::editMessage() const
{
- return _("Opened Float Inset");
+ return _("Opened Float Inset");
}
-int InsetFloat::Latex(Buffer const * buf,
+int InsetFloat::latex(Buffer const * buf,
ostream & os, bool fragile, bool fp) const
{
- os << "\\begin{" << floatType << "}";
- if (!floatPlacement.empty()
- && floatPlacement != floatList.defaultPlacement(floatType))
- os << "[" << floatPlacement << "]";
+ string const tmptype = (wide_ ? floatType_ + "*" : floatType_);
+ // Figure out the float placement to use.
+ // From lowest to highest:
+ // - float default placement
+ // - document wide default placement
+ // - specific float placement
+ string placement;
+ string const buf_placement = buf->params.float_placement;
+ string const def_placement = floatList.defaultPlacement(floatType_);
+ if (!floatPlacement_.empty()
+ && floatPlacement_ != def_placement) {
+ placement = floatPlacement_;
+ } else if (!buf_placement.empty()
+ && 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 i = inset->Latex(buf, os, fragile, fp);
- os << "\\end{" << floatType << "}%\n";
-
- return i + 2;
+ int const i = inset.latex(buf, os, fragile, fp);
+ os << "\\end{" << tmptype << "}%\n";
+
+ return i + 2;
}
-bool InsetFloat::InsertInset(BufferView * bv, Inset * in)
+int InsetFloat::docbook(Buffer const * buf, ostream & os) const
{
- if (!InsertInsetAllowed(in))
- return false;
+ os << "<" << floatType_ << ">";
+ int const i = inset.docbook(buf, os);
+ os << "</" << floatType_ << ">";
- return inset->InsertInset(bv, in);
+ 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)) {
- return false;
- }
- return true;
+ 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;
}
-#if 0
-LyXFont InsetFloat::GetDrawFont(BufferView * bv,
- LyXParagraph * p, int pos) const
+
+bool InsetFloat::showInsetDialog(BufferView * bv) const
{
- LyXFont fn = getLyXText(bv)->GetFont(bv->buffer(), p, pos);
- fn.decSize().decSize();
- return fn;
+ if (!inset.showInsetDialog(bv)) {
+ bv->owner()->getDialogs()->showFloat(const_cast<InsetFloat *>(this));
+ }
+ return true;
}
-#endif
-void InsetFloat::InsetButtonRelease(BufferView * bv, int x, int y, int button)
+
+string const & InsetFloat::type() const
{
- if (x >= 0
- && 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;
+ return floatType_;
+}
+
+
+void InsetFloat::placement(string const & p)
+{
+ // FIX: Here we should only allow the placement to be set
+ // if a valid value.
+ floatPlacement_ = p;
+}
+
+
+string const & InsetFloat::placement() const
+{
+ return floatPlacement_;
+}
+
+
+void InsetFloat::wide(bool w)
+{
+ wide_ = w;
+ if (wide_) {
+ string lab(_("float:"));
+ lab += floatType_;
+ lab += "*";
+ setLabel(lab);
} else {
- InsetCollapsable::InsetButtonRelease(bv, x, y, button);
+ string lab(_("float:"));
+ lab += floatType_;
+ setLabel(lab);
}
}
+
+
+bool InsetFloat::wide() const
+{
+ return wide_;
+}
projects / lyx.git / blobdiff