2001-12-28 Lars Gullik Bj�nnes <larsbj@birdstep.com>

[lyx.git] / src / insets / insetfloat.C

diff --git a/src/insets/insetfloat.C b/src/insets/insetfloat.C
index 04e8dba12941e84525681beda29c0cb0b1127592..1d4c3614cb81a9fbc0dc6b67415468138b08ec09 100644 (file)
--- a/src/insets/insetfloat.C
+++ b/src/insets/insetfloat.C
@@ -20,10 +20,14 @@
 #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;
@@ -106,13 +110,24 @@ InsetFloat::InsetFloat(string const & type)
        font.decSize();
        font.setColor(LColor::collapsable);
        setLabelFont(font);
-       setAutoCollapse(false);
        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()
+{
+       hideDialog();
+}
+
+
+void InsetFloat::write(Buffer const * buf, ostream & os) const
 {
        os << "Float " // getInsetName()
           << floatType_ << '\n';
@@ -129,27 +144,29 @@ void InsetFloat::Write(Buffer const * buf, ostream & os) const
                os << "wide false\n";
        }
        
-       InsetCollapsable::Write(buf, os);
+       InsetCollapsable::write(buf, os);
 }
 
 
-void InsetFloat::Read(Buffer const * buf, LyXLex & lex)
+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
@@ -157,86 +174,100 @@ void InsetFloat::Read(Buffer const * buf, LyXLex & lex)
                } 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(Buffer const &) const
+Inset * InsetFloat::clone(Buffer const &, bool same_id) const
 {
-       InsetFloat * result = new InsetFloat(floatType_);
-       result->inset.init(&inset);
-
-       result->collapsed = collapsed;
-       return result;
+       return new InsetFloat(*const_cast<InsetFloat *>(this), same_id);
 }
 
 
-string const InsetFloat::EditMessage() const
+string const InsetFloat::editMessage() const
 {
        return _("Opened Float Inset");
 }
 
 
-int InsetFloat::Latex(Buffer const * buf,
+int InsetFloat::latex(Buffer const * buf,
                      ostream & os, bool fragile, bool fp) const
 {
        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 << "}";
-       if (!floatPlacement_.empty()
-           && floatPlacement_ != floatList.defaultPlacement(floatType_))
-               os << "[" << floatPlacement_ << "]";
+       // 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);
+       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;
 }
 
 
@@ -248,11 +279,8 @@ string const & InsetFloat::type() const
 
 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;
 }