reformatting and remove using delc

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

diff --git a/src/insets/insetminipage.C b/src/insets/insetminipage.C
index bd5e6ba1ad2545709a3f72f4f55df325f5eb7c5a..0065b5fe0ffaecd4f8669461069a4a93fb79fdf2 100644 (file)
--- a/src/insets/insetminipage.C
+++ b/src/insets/insetminipage.C
@@ -69,7 +69,7 @@ InsetMinipage::InsetMinipage()
        setLabelFont(font);
        setAutoCollapse(false);
        setInsetName("Minipage");
-       collapsed = false;
+       width_ = "100%"; // set default to 100% of column_width
 }
 
 
@@ -84,39 +84,157 @@ void InsetMinipage::Write(Buffer const * buf, ostream & os) const
        os << getInsetName() << "\n"
           << "position " << pos_ << "\n"
           << "inner_position " << inner_pos_ << "\n"
-//        << "height " << height_ << "\n"
-          << "width " << widthp_ << "\n";
+          << "height \"" << height_ << "\"\n"
+          << "width \"" << width_ << "\"\n";
        InsetCollapsable::Write(buf, os);
 }
 
 
 void InsetMinipage::Read(Buffer const * buf, LyXLex & lex)
 {
-       #warning Read and set args correctly. (Lgb)
-       lex.next();
-       string token = lex.GetString();
-       lyxerr << "minipage token: " << token << endl;
-       lex.next(); lex.next();
-       lex.next();
-       lex.next();
+    string token;
+
+    if (lex.IsOK()) {
        lex.next();
        token = lex.GetString();
-       lyxerr << "minipage token: " << token << endl;
-       
-       InsetCollapsable::Read(buf, lex);
+       if (token == "position") {
+           lex.next();
+           pos_ = static_cast<Position>(lex.GetInteger());
+           token = string();
+       } else {
+               lyxerr << "InsetMinipage::Read: Missing 'position'-tag!"
+                      << endl;
+       }
+    }
+    if (lex.IsOK()) {
+       if (token.empty()) {
+           lex.next();
+           token = lex.GetString();
+       }
+       if (token == "inner_position") {
+           lex.next();
+           inner_pos_ = static_cast<InnerPosition>(lex.GetInteger());
+           token = string();
+       } else {
+               lyxerr << "InsetMinipage::Read: Missing 'inner_position'-tag!"
+                      << endl;
+       }
+    }
+    if (lex.IsOK()) {
+       if (token.empty()) {
+           lex.next();
+           token = lex.GetString();
+       }
+       if (token == "height") {
+           lex.next();
+           height_ = lex.GetString();
+           token = string();
+       } else {
+               lyxerr << "InsetMinipage::Read: Missing 'height'-tag!"
+                      << endl;
+       }
+    }
+    if (lex.IsOK()) {
+       if (token.empty()) {
+           lex.next();
+           token = lex.GetString();
+       }
+       if (token == "width") {
+           lex.next();
+           width_ = lex.GetString();
+           token = string();
+       } else {
+               lyxerr << "InsetMinipage::Read: Missing 'width'-tag!"
+                      << endl;
+       }
+    }
+#warning Remove me before final 1.2.0 (Jug)
+    // this is only for compatibility to the intermediate format and should
+    // vanish till the final 1.2.0!
+    if (lex.IsOK()) {
+       if (token.empty()) {
+           lex.next();
+           token = lex.GetString();
+       }
+       if (token == "widthp") {
+           lex.next();
+           // only do this if the width_-string was not already set!
+           if (width_.empty())
+               width_ = lex.GetString() + "%";
+           token = string();
+       } else {
+               lyxerr << "InsetMinipage::Read: Missing 'widthp_'-tag!"
+                      << endl;
+       }
+    }
+    if (!token.empty())
+       lex.pushToken(token);
+    InsetCollapsable::Read(buf, lex);
 }
 
 
 Inset * InsetMinipage::Clone(Buffer const &) const
 {
        InsetMinipage * result = new InsetMinipage;
-       result->inset->init(inset);
+       result->inset.init(&inset);
        
        result->collapsed = collapsed;
+       result->pos_ = pos_;
+       result->inner_pos_ = inner_pos_;
+       result->height_ = height_;
+       result->width_ = width_;
        return result;
 }
 
 
+int InsetMinipage::ascent(BufferView * bv, LyXFont const & font) const
+{
+       if (collapsed)
+               return ascent_collapsed(bv->painter(), font);
+       else {
+               // Take placement into account.
+               int i = 0;
+               switch (pos_) {
+               case top:
+                       i = InsetCollapsable::ascent(bv, font);
+                       break;
+               case center:
+                       i = (InsetCollapsable::ascent(bv, font)
+                            + InsetCollapsable::descent(bv, font)) / 2;
+                       break;
+               case bottom:
+                       i = InsetCollapsable::descent(bv, font);
+                       break;
+               }
+               return i;
+       }
+}
+
+
+int InsetMinipage::descent(BufferView * bv, LyXFont const & font) const
+{
+       if (collapsed)
+               return descent_collapsed(bv->painter(), font);
+       else {
+               // Take placement into account.
+               int i = 0;
+               switch (pos_) {
+               case top:
+                       i = InsetCollapsable::descent(bv, font);
+                       break;
+               case center:
+                       i = (InsetCollapsable::ascent(bv, font)
+                            + InsetCollapsable::descent(bv, font)) / 2;
+                       break;
+               case bottom:
+                       i = InsetCollapsable::ascent(bv, font);
+                       break;
+               }
+               return i;
+       }
+}
+
+
 string const InsetMinipage::EditMessage() const
 {
        return _("Opened Minipage Inset");
@@ -138,13 +256,12 @@ int InsetMinipage::Latex(Buffer const * buf,
                s_pos += "b";
                break;
        }
+       os << "\\begin{minipage}[" << s_pos << "]{"
+          << LyXLength(width_).asLatexString() << "}%\n";
        
-       os << "\\begin{minipage}[" << s_pos << "]{."
-          << widthp_ << "\\columnwidth}%\n";
-       
-       int i = inset->Latex(buf, os, fragile, fp);
+       int i = inset.Latex(buf, os, fragile, fp);
+
        os << "\\end{minipage}%\n";
-       
        return i + 2;
 }
 
@@ -183,13 +300,13 @@ void InsetMinipage::innerPos(InsetMinipage::InnerPosition ip)
 }
 
 
-LyXLength const & InsetMinipage::height() const
+string const & InsetMinipage::height() const
 {
        return height_;
 }
 
 
-void InsetMinipage::height(LyXLength const & ll)
+void InsetMinipage::height(string const & ll)
 {
        height_ = ll;
 }
@@ -206,21 +323,12 @@ void InsetMinipage::width(string const & ll)
        width_ = ll;
 }
 
-int InsetMinipage::widthp() const
-{
-       return widthp_;
-}
-
-
-void InsetMinipage::widthp(int ll)
-{
-       widthp_ = ll;
-}
-
 
-void InsetMinipage::widthp(string const & ll)
+bool InsetMinipage::ShowInsetDialog(BufferView * bv) const
 {
-       widthp_ = strToInt(ll);
+    if (!inset.ShowInsetDialog(bv))
+       bv->owner()->getDialogs()->showMinipage(const_cast<InsetMinipage *>(this));
+    return true;
 }
 
 
@@ -228,19 +336,18 @@ void InsetMinipage::InsetButtonRelease(BufferView * bv, int x, int y,
                                       int button)
 {
     if (button == 3) {
-#if 0
-// we have to check first if we have a locking inset and if this locking inset
-// has a popup menu with the 3rd button
-       if (the_locking_inset) {
-           UpdatableInset * i;
-           if ((i=the_locking_inset->GetFirstLockingInsetOfType(TABULAR_CODE))) {
-               i->InsetButtonRelease(bv, x, y, button);
-               return;
-           }
-       }
-#endif
-       bv->owner()->getDialogs()->showMinipage(this);
+       ShowInsetDialog(bv);
        return;
     }
     InsetCollapsable::InsetButtonRelease(bv, x, y, button);
 }
+
+
+int InsetMinipage::getMaxWidth(BufferView * bv, UpdatableInset const * inset)
+    const
+{
+    if (!width_.empty())
+       return VSpace(width_).inPixels(bv);
+    // this should not happen!
+    return InsetCollapsable::getMaxWidth(bv, inset);
+}