X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsetfloat.C;h=41da3b33a9aaf25a36e5c03b10cb248381ac3239;hb=5603df4a5b7e511b31026c9a4f8f55b2b10fde57;hp=7882fe3348a1e8a4dd5cc65aed127652c0671377;hpb=f1c24d100985c6df2eb5ec390017b69c78fe49c7;p=lyx.git diff --git a/src/insets/insetfloat.C b/src/insets/insetfloat.C index 7882fe3348..41da3b33a9 100644 --- a/src/insets/insetfloat.C +++ b/src/insets/insetfloat.C @@ -1,36 +1,48 @@ -/* This file is part of - * ====================================================== +/** + * \file insetfloat.C + * This file is part of LyX, the document processor. + * Licence details can be found in the file COPYING. * - * LyX, The Document Processor + * \author Jürgen Vigna + * \author Lars Gullik Bjønnes * - * Copyright 1998-2001 The LyX Team. - * - * ====================================================== */ + * Full author contact details are available in file CREDITS. + */ #include -#ifdef __GNUG__ -#pragma implementation -#endif - #include "insetfloat.h" -#include "gettext.h" -#include "lyxfont.h" + +#include "buffer.h" +#include "bufferparams.h" #include "BufferView.h" -#include "lyxtext.h" -#include "insets/insettext.h" -#include "support/LOstream.h" -#include "support/lstrings.h" -#include "FloatList.h" -#include "LaTeXFeatures.h" +#include "cursor.h" #include "debug.h" +#include "dispatchresult.h" #include "Floating.h" -#include "buffer.h" -#include "frontends/LyXView.h" -#include "frontends/Dialogs.h" +#include "FloatList.h" +#include "funcrequest.h" +#include "gettext.h" +#include "LaTeXFeatures.h" +#include "LColor.h" +#include "lyxlex.h" +#include "outputparams.h" +#include "paragraph.h" +#include "pariterator.h" + +#include "support/lstrings.h" +#include "support/tostr.h" +#include "support/std_sstream.h" + +using lyx::support::contains; -using std::ostream; using std::endl; +using std::string; +using std::auto_ptr; +using std::istringstream; +using std::ostream; +using std::ostringstream; + // With this inset it will be possible to support the latex package // float.sty, and I am sure that with this and some additional support @@ -101,10 +113,15 @@ using std::endl; namespace { -string floatname(string const & type) +// this should not be hardcoded, but be part of the definition +// of the float (JMarc) +string const caplayout("Caption"); + +string floatname(string const & type, BufferParams const & bp) { - FloatList::const_iterator it = floatList[type]; - if (it == floatList.end()) + FloatList const & floats = bp.getLyXTextClass().floats(); + FloatList::const_iterator it = floats[type]; + if (it == floats.end()) return type; return _(it->second.name()); @@ -114,102 +131,148 @@ string floatname(string const & type) InsetFloat::InsetFloat(BufferParams const & bp, string const & type) - : InsetCollapsable(bp), wide_(false) + : InsetCollapsable(bp) { - string lab(_("float: ")); - lab += floatname(type); - setLabel(lab); + setLabel(_("float: ") + floatname(type, bp)); LyXFont font(LyXFont::ALL_SANE); font.decSize(); font.decSize(); font.setColor(LColor::collapsable); setLabelFont(font); - floatType_ = type; + params_.type = type; setInsetName(type); + LyXTextClass const & tclass = bp.getLyXTextClass(); + if (tclass.hasLayout(caplayout)) + paragraphs().begin()->layout(tclass[caplayout]); } -InsetFloat::InsetFloat(InsetFloat const & in, bool same_id) - : InsetCollapsable(in, same_id), floatType_(in.floatType_), - floatPlacement_(in.floatPlacement_), wide_(in.wide_) -{} +InsetFloat::~InsetFloat() +{ + InsetFloatMailer(*this).hideDialog(); +} -InsetFloat::~InsetFloat() +void InsetFloat::priv_dispatch(LCursor & cur, FuncRequest & cmd) { - hideDialog(); + switch (cmd.action) { + + case LFUN_INSET_MODIFY: { + InsetFloatParams params; + InsetFloatMailer::string2params(cmd.argument, params); + params_.placement = params.placement; + params_.wide = params.wide; + params_.sideways = params.sideways; + wide(params_.wide, cur.buffer().params()); + sideways(params_.sideways, cur.buffer().params()); + cur.bv().update(); + break; + } + + case LFUN_INSET_DIALOG_UPDATE: { + InsetFloatMailer(*this).updateDialog(&cur.bv()); + break; + } + + case LFUN_MOUSE_RELEASE: { + if (cmd.button() == mouse_button::button3 && hitButton(cmd)) { + InsetFloatMailer(*this).showDialog(&cur.bv()); + break; + } + InsetCollapsable::priv_dispatch(cur, cmd); + break; + } + + default: + InsetCollapsable::priv_dispatch(cur, cmd); + break; + } } -void InsetFloat::write(Buffer const * buf, ostream & os) const +void InsetFloatParams::write(ostream & os) const { - os << "Float " // getInsetName() - << floatType_ << '\n'; + os << "Float " << type << '\n'; + + if (!placement.empty()) + os << "placement " << placement << "\n"; - if (floatPlacement_.empty()) { - os << "placement " - << floatList.getType(floatType_).placement() << "\n"; + if (wide) + os << "wide true\n"; + else + os << "wide false\n"; + + if (sideways) + os << "sideways true\n"; + else + os << "sideways false\n"; +} + + +void InsetFloatParams::read(LyXLex & lex) +{ + string token; + lex >> token; + if (token == "placement") { + lex >> placement; } else { - os << "placement " << floatPlacement_ << "\n"; + // take countermeasures + lex.pushToken(token); } - if (wide_) { - os << "wide true\n"; + lex >> token; + if (token == "wide") { + lex >> wide; } else { - os << "wide false\n"; + lyxerr << "InsetFloat::Read:: Missing wide!" + << endl; + // take countermeasures + lex.pushToken(token); + } + lex >> token; + if (token == "sideways") { + lex >> sideways; + } else { + lyxerr << "InsetFloat::Read:: Missing sideways!" + << endl; + // take countermeasures + lex.pushToken(token); } +} + +void InsetFloat::write(Buffer const & buf, ostream & os) const +{ + params_.write(os); InsetCollapsable::write(buf, os); } -void InsetFloat::read(Buffer const * buf, LyXLex & lex) +void InsetFloat::read(Buffer const & buf, LyXLex & lex) { - if (lex.isOK()) { - lex.next(); - string token = lex.getString(); - if (token == "placement") { - lex.next(); - floatPlacement_ = lex.getString(); - } else { - lyxerr << "InsetFloat::Read: Missing placement!" - << endl; - // take countermeasures - lex.pushToken(token); - } - lex.next(); - token = lex.getString(); - if (token == "wide") { - lex.next(); - 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); - } - } + params_.read(lex); + wide(params_.wide, buf.params()); + sideways(params_.sideways, buf.params()); InsetCollapsable::read(buf, lex); } void InsetFloat::validate(LaTeXFeatures & features) const { - if (contains(placement(), "H")) { + if (contains(params_.placement, 'H')) { features.require("float"); } - features.useFloat(floatType_); + if (params_.sideways) + features.require("rotating"); + + features.useFloat(params_.type); InsetCollapsable::validate(features); } -Inset * InsetFloat::clone(Buffer const &, bool same_id) const +auto_ptr InsetFloat::clone() const { - return new InsetFloat(*const_cast(this), same_id); + return auto_ptr(new InsetFloat(*this)); } @@ -219,22 +282,30 @@ string const InsetFloat::editMessage() const } -int InsetFloat::latex(Buffer const * buf, - ostream & os, bool fragile, bool fp) const +int InsetFloat::latex(Buffer const & buf, ostream & os, + OutputParams const & runparams) const { - string const tmptype = (wide_ ? floatType_ + "*" : floatType_); + FloatList const & floats = buf.params().getLyXTextClass().floats(); + string tmptype = (params_.wide ? params_.type + "*" : params_.type); + if (params_.sideways) { + if (params_.type == "table") + tmptype = "sidewaystable"; + else if (params_.type == "figure") + tmptype = "sidewaysfigure"; + } // 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() + string const buf_placement = buf.params().float_placement; + string const def_placement = floats.defaultPlacement(params_.type); + if (!params_.placement.empty() + && params_.placement != def_placement) { + placement = params_.placement; + } else if (params_.placement.empty() + && !buf_placement.empty() && buf_placement != def_placement) { placement = buf_placement; } @@ -242,14 +313,15 @@ int InsetFloat::latex(Buffer const * buf, // The \n is used to force \begin{} to appear in a new line. // The % is needed to prevent two consecutive \n chars in the case // when the current output line is empty. - os << "%\n\\begin{" << tmptype << "}"; + os << "%\n\\begin{" << tmptype << '}'; // We only output placement if different from the def_placement. - if (!placement.empty()) { - os << "[" << placement << "]"; + // sidewaysfloats always use their own page + if (!placement.empty() && !params_.sideways) { + os << '[' << placement << ']'; } - os << "\n"; + os << '\n'; - int const i = inset.latex(buf, os, fragile, fp); + int const i = InsetText::latex(buf, os, runparams); // The \n is used to force \end{} to appear in a new line. // In this case, we do not case if the current output line is empty. @@ -259,72 +331,156 @@ int InsetFloat::latex(Buffer const * buf, } -int InsetFloat::docbook(Buffer const * buf, ostream & os, bool mixcont) const +int InsetFloat::linuxdoc(Buffer const & buf, ostream & os, + OutputParams const & runparams) const +{ + FloatList const & floats = buf.params().getLyXTextClass().floats(); + string const tmptype = params_.type; + // Figure out the float placement to use. + // From lowest to highest: + // - float default placement + // - document wide default placement + // - specific float placement + // This is the same as latex, as linuxdoc is modeled after latex. + + string placement; + string const buf_placement = buf.params().float_placement; + string const def_placement = floats.defaultPlacement(params_.type); + if (!params_.placement.empty() + && params_.placement != def_placement) { + placement = params_.placement; + } else if (params_.placement.empty() + && !buf_placement.empty() + && buf_placement != def_placement) { + placement = buf_placement; + } + + os << "\n<" << tmptype ; + // We only output placement if different from the def_placement. + if (!placement.empty()) { + os << " loc=\"" << placement << '"'; + } + os << ">"; + + int const i = InsetText::linuxdoc(buf, os, runparams); + os << "\n"; + + return i; +} + + +int InsetFloat::docbook(Buffer const & buf, ostream & os, + OutputParams const & runparams) const { - os << "<" << floatType_ << ">"; - int const i = inset.docbook(buf, os, mixcont); - os << ""; + os << '<' << params_.type << '>'; + int const i = InsetText::docbook(buf, os, runparams); + os << "'; return i; } -bool InsetFloat::insetAllowed(Inset::Code code) const +bool InsetFloat::insetAllowed(InsetOld::Code code) const { - if (code == Inset::FLOAT_CODE) - return false; - if (inset.getLockingInset() != const_cast(this)) - return inset.insetAllowed(code); - if ((code == Inset::FOOT_CODE) || (code == Inset::MARGIN_CODE)) - return false; - return true; + return code != InsetOld::FLOAT_CODE + && code != InsetOld::FOOT_CODE + && code != InsetOld::MARGIN_CODE; } bool InsetFloat::showInsetDialog(BufferView * bv) const { - if (!inset.showInsetDialog(bv)) { - bv->owner()->getDialogs()->showFloat(const_cast(this)); - } + if (!InsetText::showInsetDialog(bv)) + InsetFloatMailer(const_cast(*this)).showDialog(bv); return true; } -string const & InsetFloat::type() const +void InsetFloat::wide(bool w, BufferParams const & bp) { - return floatType_; + params_.wide = w; + string lab = _("float: ") + floatname(params_.type, bp); + if (params_.wide) + lab += '*'; + setLabel(lab); } -void InsetFloat::placement(string const & p) +void InsetFloat::sideways(bool s, BufferParams const & bp) { - // FIX: Here we should only allow the placement to be set - // if a valid value. - floatPlacement_ = p; + params_.sideways = s; + string lab = _("float: ") + floatname(params_.type, bp); + if (params_.sideways) + lab += _(" (sideways)"); + setLabel(lab); } -string const & InsetFloat::placement() const +void InsetFloat::addToToc(lyx::toc::TocList & toclist, Buffer const & buf) const { - return floatPlacement_; + ParConstIterator pit = par_const_iterator_begin(*this); + ParConstIterator end = par_const_iterator_end(*this); + + // Find a caption layout in one of the (child inset's) pars + for (; pit != end; ++pit) { + if (pit->layout()->name() == caplayout) { + string const name = floatname(params_.type, buf.params()); + string const str = + tostr(toclist[name].size() + 1) + + ". " + pit->asString(buf, false); + lyx::toc::TocItem const item(pit->id(), 0 , str); + toclist[name].push_back(item); + } + } } -void InsetFloat::wide(bool w) -{ - wide_ = w; +string const InsetFloatMailer::name_("float"); - string lab(_("float:")); - lab += floatname(floatType_); +InsetFloatMailer::InsetFloatMailer(InsetFloat & inset) + : inset_(inset) +{} - if (wide_) - lab += "*"; - setLabel(lab); +string const InsetFloatMailer::inset2string(Buffer const &) const +{ + return params2string(inset_.params()); +} + + +void InsetFloatMailer::string2params(string const & in, + InsetFloatParams & params) +{ + params = InsetFloatParams(); + if (in.empty()) + return; + + istringstream data(in); + LyXLex lex(0,0); + lex.setStream(data); + + string name; + lex >> name; + if (!lex || name != name_) + return print_mailer_error("InsetFloatMailer", in, 1, name_); + + // This is part of the inset proper that is usually swallowed + // by LyXText::readInset + string id; + lex >> id; + if (!lex || id != "Float") + return print_mailer_error("InsetBoxMailer", in, 2, "Float"); + + // We have to read the type here! + lex >> params.type; + params.read(lex); } -bool InsetFloat::wide() const +string const InsetFloatMailer::params2string(InsetFloatParams const & params) { - return wide_; + ostringstream data; + data << name_ << ' '; + params.write(data); + return data.str(); }