X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsetfloat.C;h=7c164979a50f4fa3d838fdab20450524cc26a35c;hb=b1fb034c3be30101b06286f74815a708142d52e8;hp=cc893bc70d5fe5381d8803c415bea9a6e6b10e47;hpb=eb7220abe64a6e301c51974fb34bb916ac41d64b;p=lyx.git diff --git a/src/insets/insetfloat.C b/src/insets/insetfloat.C index cc893bc70d..7c164979a5 100644 --- a/src/insets/insetfloat.C +++ b/src/insets/insetfloat.C @@ -1,33 +1,45 @@ -/* This file is part of - * ====================================================== - * - * LyX, The Document Processor - * - * Copyright 1998 The LyX Team. +/** + * \file insetfloat.C + * This file is part of LyX, the document processor. + * Licence details can be found in the file COPYING. * - *======================================================*/ + * \author Jürgen Vigna + * \author Lars Gullik Bjønnes + * + * Full author contact details are available in file CREDITS + */ #include -#ifdef __GNUG__ -#pragma implementation -#endif - #include "insetfloat.h" +#include "insettext.h" + +#include "buffer.h" +#include "BufferView.h" +#include "debug.h" +#include "Floating.h" +#include "FloatList.h" +#include "funcrequest.h" #include "gettext.h" +#include "iterators.h" +#include "LaTeXFeatures.h" +#include "Lsstream.h" #include "lyxfont.h" -#include "BufferView.h" -#include "Painter.h" +#include "lyxlex.h" #include "lyxtext.h" -#include "insets/insettext.h" +#include "Lsstream.h" + #include "support/LOstream.h" -#include "FloatList.h" -#include "LaTeXFeatures.h" -#include "debug.h" +#include "support/lstrings.h" +#include "support/tostr.h" + +#include "frontends/LyXView.h" +#include "frontends/Dialogs.h" using std::ostream; using std::endl; + // 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 // classes we can support similar functionality in other formats @@ -57,7 +69,7 @@ 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} @@ -76,129 +88,348 @@ using std::endl; // \newfloat{algorithm}{htbp}{loa}[] // \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() +namespace { + +// 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 & floats = bp.getLyXTextClass().floats(); + FloatList::const_iterator it = floats[type]; + if (it == floats.end()) + return type; + + return _(it->second.name()); +} + +} // namespace anon + + +InsetFloat::InsetFloat(BufferParams const & bp, string const & type) + : InsetCollapsable(bp) { - 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 += floatname(type, bp); + setLabel(lab); + LyXFont font(LyXFont::ALL_SANE); + font.decSize(); + font.decSize(); + font.setColor(LColor::collapsable); + setLabelFont(font); + params_.type = type; + setInsetName(type); + LyXTextClass const & tclass = bp.getLyXTextClass(); + if (tclass.hasLayout(caplayout)) + inset.paragraphs.begin()->layout(tclass[caplayout]); } -void InsetFloat::Write(Buffer const * buf, ostream & os) const +InsetFloat::InsetFloat(InsetFloat const & in, bool same_id) + : InsetCollapsable(in, same_id), params_(in.params_) +{} + + +InsetFloat::~InsetFloat() +{ + InsetFloatMailer mailer(*this); + mailer.hideDialog(); +} + + +dispatch_result InsetFloat::localDispatch(FuncRequest const & cmd) +{ + Inset::RESULT result = UNDISPATCHED; + + switch (cmd.action) { + case LFUN_INSET_MODIFY: { + InsetFloatParams params; + InsetFloatMailer::string2params(cmd.argument, params); + + params_.placement = params.placement; + params_.wide = params.wide; + + wide(params_.wide, cmd.view()->buffer()->params); + cmd.view()->updateInset(this); + result = DISPATCHED; + } + break; + + case LFUN_INSET_DIALOG_UPDATE: { + InsetFloatMailer mailer(*this); + mailer.updateDialog(cmd.view()); + } + break; + + default: + result = InsetCollapsable::localDispatch(cmd); + } + + return result; +} + + +void InsetFloatParams::write(ostream & os) const { - os << getInsetName() - << "\ntype " << floatType - << "\nplacement " << floatPlacement << "\n"; - InsetCollapsable::Write(buf, os); + os << "Float " // getInsetName() + << type << '\n'; + + if (!placement.empty()) { + os << "placement " << placement << "\n"; + } + if (wide) { + os << "wide true\n"; + } else { + os << "wide false\n"; + } } -void InsetFloat::Read(Buffer const * buf, LyXLex & lex) +void InsetFloatParams::read(LyXLex & lex) { - if (lex.IsOK()) { + if (lex.isOK()) { lex.next(); - string token = lex.GetString(); - if (token == "type") { + string token = lex.getString(); + if (token == "placement") { lex.next(); - floatType = lex.GetString(); + placement = lex.getString(); + } else { + // 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(); + wide = (tmptoken == "true"); + } else { + lyxerr << "InsetFloat::Read:: Missing wide!" + << endl; + // take countermeasures + lex.pushToken(token); } } - InsetCollapsable::Read(buf, lex); } -void InsetFloat::Validate(LaTeXFeatures & features) const +void InsetFloat::write(Buffer const * buf, ostream & os) const +{ + params_.write(os); + InsetCollapsable::write(buf, os); +} + + +void InsetFloat::read(Buffer const * buf, LyXLex & lex) { - features.usedFloats.insert(floatType); + params_.read(lex); + wide(params_.wide, buf->params); + InsetCollapsable::read(buf, lex); } -Inset * InsetFloat::Clone() const +void InsetFloat::validate(LaTeXFeatures & features) const { - InsetFloat * result = new InsetFloat; - result->inset->init(inset); + if (contains(params_.placement, "H")) { + features.require("float"); + } - result->collapsed = collapsed; - return result; + features.useFloat(params_.type); + InsetCollapsable::validate(features); } -char const * InsetFloat::EditMessage() const +Inset * InsetFloat::clone(Buffer const &, bool same_id) const { - return _("Opened Float Inset"); + return new InsetFloat(*const_cast(this), same_id); } -int InsetFloat::Latex(Buffer const * buf, +string const InsetFloat::editMessage() const +{ + return _("Opened Float Inset"); +} + + +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 << "]"; - os << "%\n"; - - int i = inset->Latex(buf, os, fragile, fp); - os << "\\end{" << floatType << "}%\n"; - - return i + 2; + FloatList const & floats = buf->params.getLyXTextClass().floats(); + string const tmptype = (params_.wide ? params_.type + "*" : params_.type); + // 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 = 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; + } + + // 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 << '}'; + // 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); + + // 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. + os << "\n\\end{" << tmptype << "}\n"; + + return i + 4; } -bool InsetFloat::InsertInset(BufferView * bv, Inset * in) +int InsetFloat::docbook(Buffer const * buf, ostream & os, bool mixcont) const { - if (!InsertInsetAllowed(in)) - return false; + os << '<' << params_.type << '>'; + int const i = inset.docbook(buf, os, mixcont); + os << "'; - 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(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)) { + InsetFloat * tmp = const_cast(this); + InsetFloatMailer mailer(*tmp); + mailer.showDialog(bv); + } + return true; } -#endif -void InsetFloat::InsetButtonRelease(BufferView * bv, int x, int y, int button) + +void InsetFloat::wide(bool w, BufferParams const & bp) { - 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; - } else { - InsetCollapsable::InsetButtonRelease(bv, x, y, button); + params_.wide = w; + + string lab(_("float:")); + lab += floatname(params_.type, bp); + + if (params_.wide) + lab += '*'; + + setLabel(lab); +} + + +void InsetFloat::addToToc(toc::TocList & toclist, Buffer const * buf) const +{ + ParIterator pit(inset.paragraphs.begin(), inset.paragraphs); + ParIterator end(inset.paragraphs.end(), inset.paragraphs); + +a // 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); + toc::TocItem const item(pit->id(), 0 , str); + toclist[name].push_back(item); + } + } +} + + +string const InsetFloatMailer::name_("float"); + +InsetFloatMailer::InsetFloatMailer(InsetFloat & inset) + : inset_(inset) +{} + + +string const InsetFloatMailer::inset2string() const +{ + return params2string(inset_.params()); +} + + +void InsetFloatMailer::string2params(string const & in, + InsetFloatParams & params) +{ + params = InsetFloatParams(); + + if (in.empty()) + return; + + istringstream data(STRCONV(in)); + LyXLex lex(0,0); + lex.setStream(data); + + if (lex.isOK()) { + lex.next(); + string const token = lex.getString(); + if (token != name_) + return; + } + + // This is part of the inset proper that is usually swallowed + // by Buffer::readInset + if (lex.isOK()) { + lex.next(); + string const token = lex.getString(); + if (token != "Float" || !lex.eatLine()) + return; } + + if (lex.isOK()) { + params.read(lex); + } +} + + +string const InsetFloatMailer::params2string(InsetFloatParams const & params) +{ + ostringstream data; + data << name_ << ' '; + params.write(data); + return STRCONV(data.str()); }