X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetCaption.cpp;h=0850363bc43f98d40f8004b7227a3572411855ec;hb=96dea61f22c04529e726cab36acf0240d41fa778;hp=ad3ef8462aee3fcc9f7e2489bf6843dc512b2c56;hpb=f1cba8ff64b369792fd49f5ddf90e8126ab476ac;p=lyx.git diff --git a/src/insets/InsetCaption.cpp b/src/insets/InsetCaption.cpp index ad3ef8462a..0850363bc4 100644 --- a/src/insets/InsetCaption.cpp +++ b/src/insets/InsetCaption.cpp @@ -25,12 +25,17 @@ #include "FuncRequest.h" #include "FuncStatus.h" #include "InsetList.h" +#include "Language.h" #include "MetricsInfo.h" #include "output_latex.h" +#include "output_xhtml.h" #include "OutputParams.h" #include "Paragraph.h" -#include "paragraph_funcs.h" +#include "ParIterator.h" +#include "TexRow.h" +#include "texstream.h" #include "TextClass.h" +#include "TextMetrics.h" #include "TocBackend.h" #include "frontends/FontMetrics.h" @@ -47,39 +52,30 @@ using namespace lyx::support; namespace lyx { -InsetCaption::InsetCaption(Buffer const & buf) - : InsetText(buf) +InsetCaption::InsetCaption(Buffer * buf, string const & type) + : InsetText(buf, InsetText::PlainLayout), + labelwidth_(0), is_subfloat_(false), type_(type) { - setAutoBreakRows(true); setDrawFrame(true); - setFrameColor(Color_captionframe); - // caption insets should use the plain layout - paragraphs().back().setPlainLayout(buf.params().documentClass()); + setFrameColor(Color_collapsibleframe); } void InsetCaption::write(ostream & os) const { - os << "Caption\n"; - text().write(buffer(), os); + os << "Caption"; + if (!type_.empty()) + os << ' ' << type_; + os << '\n'; + text().write(os); } -void InsetCaption::read(Lexer & lex) +docstring InsetCaption::layoutName() const { -#if 0 - // We will enably this check again when the compability - // code is removed from Buffer::Read (Lgb) - lex.setContext("InsetCaption::Read: consistency check"); - lex >> "Caption"; -#endif - InsetText::read(lex); -} - - -docstring InsetCaption::editMessage() const -{ - return _("Opened Caption Inset"); + if (type_.empty()) + return from_ascii("Caption"); + return from_utf8("Caption:" + type_); } @@ -93,29 +89,29 @@ void InsetCaption::cursorPos(BufferView const & bv, void InsetCaption::setCustomLabel(docstring const & label) { - if (!isAscii(label) || label.empty()) - // This must be a user defined layout. We cannot translate - // this, since gettext accepts only ascii keys. - custom_label_ = label; - else - custom_label_ = _(to_ascii(label)); + custom_label_ = translateIfPossible(label); } -void InsetCaption::addToToc(DocIterator const & cpit) +void InsetCaption::addToToc(DocIterator const & cpit, bool output_active, + UpdateType utype, TocBackend & backend) const { - if (type_.empty()) - return; - + string const & type = floattype_.empty() ? "senseless" : floattype_; DocIterator pit = cpit; - pit.push_back(CursorSlice(*this)); - - Toc & toc = buffer().tocBackend().toc(type_); - docstring const str = full_label_ + ". " + text().getPar(0).asString(); - toc.push_back(TocItem(pit, 0, str)); - + pit.push_back(CursorSlice(const_cast(*this))); + int length = (utype == OutputUpdate) ? + // For output (e.g. xhtml) all (bug #8603) or nothing + (output_active ? INT_MAX : 0) : + // TOC for LyX interface + TOC_ENTRY_LENGTH; + docstring str; + if (length > 0) { + str = full_label_; + text().forOutliner(str, length); + } + backend.builder(type).captionItem(pit, str, output_active); // Proceed with the rest of the inset. - InsetText::addToToc(cpit); + InsetText::addToToc(cpit, output_active, utype, backend); } @@ -139,6 +135,15 @@ void InsetCaption::metrics(MetricsInfo & mi, Dimension & dim) const } +void InsetCaption::drawBackground(PainterInfo & pi, int x, int y) const +{ + TextMetrics & tm = pi.base.bv->textMetrics(&text()); + int const h = tm.height() + 2 * TEXT_TO_INSET_OFFSET; + int const yy = y - TEXT_TO_INSET_OFFSET - tm.ascent(); + pi.pain.fillRectangle(x, yy, labelwidth_, h, pi.backgroundColor(this)); +} + + void InsetCaption::draw(PainterInfo & pi, int x, int y) const { // We must draw the label, we should get the label string @@ -151,7 +156,9 @@ void InsetCaption::draw(PainterInfo & pi, int x, int y) const FontInfo tmpfont = pi.base.font; pi.base.font = pi.base.bv->buffer().params().getFont().fontInfo(); - pi.pain.text(x, y, full_label_, pi.base.font); + pi.base.font.setColor(pi.textColor(pi.base.font.color()).baseColor); + int const xx = x + TEXT_TO_INSET_OFFSET; + pi.pain.text(xx, y, full_label_, pi.base.font); InsetText::draw(pi, x + labelwidth_, y); pi.base.font = tmpfont; } @@ -174,12 +181,15 @@ Inset * InsetCaption::editXY(Cursor & cur, int x, int y) bool InsetCaption::insetAllowed(InsetCode code) const { switch (code) { - case FLOAT_CODE: - case TABULAR_CODE: - case WRAP_CODE: + // code that is not allowed in a caption case CAPTION_CODE: + case FLOAT_CODE: + case FOOT_CODE: case NEWPAGE_CODE: + case MARGIN_CODE: case MATHMACRO_CODE: + case TABULAR_CODE: + case WRAP_CODE: return false; default: return InsetText::insetAllowed(code); @@ -187,18 +197,50 @@ bool InsetCaption::insetAllowed(InsetCode code) const } -bool InsetCaption::getStatus(Cursor & cur, FuncRequest const & cmd, - FuncStatus & status) const +void InsetCaption::doDispatch(Cursor & cur, FuncRequest & cmd) { - switch (cmd.action) { + switch (cmd.action()) { + + case LFUN_INSET_MODIFY: { + if (cmd.getArg(0) == "changetype") { + cur.recordUndoInset(this); + type_ = cmd.getArg(1); + cur.forceBufferUpdate(); + break; + } + } + // no "changetype": + // fall through + + default: + InsetText::doDispatch(cur, cmd); + break; + } +} - case LFUN_BREAK_PARAGRAPH: - status.setEnabled(false); - return true; - case LFUN_OPTIONAL_INSERT: - status.setEnabled(cur.paragraph().insetList().find(OPTARG_CODE) == -1); - return true; +bool InsetCaption::getStatus(Cursor & cur, FuncRequest const & cmd, + FuncStatus & status) const +{ + switch (cmd.action()) { + + case LFUN_INSET_MODIFY: { + string const first_arg = cmd.getArg(0); + if (first_arg == "changetype") { + string const type = cmd.getArg(1); + status.setOnOff(type == type_); + bool varia = type != "Unnumbered"; + // check if the immediate parent inset allows caption variation + if (cur.depth() > 1) { + varia = cur[cur.depth() - 2].inset().allowsCaptionVariation(type); + } + status.setEnabled(varia + && buffer().params().documentClass().hasInsetLayout( + from_ascii("Caption:" + type))); + return true; + } + return InsetText::getStatus(cur, cmd, status); + } case LFUN_INSET_TOGGLE: // pass back to owner @@ -211,36 +253,31 @@ bool InsetCaption::getStatus(Cursor & cur, FuncRequest const & cmd, } -int InsetCaption::latex(odocstream & os, - OutputParams const & runparams_in) const +void InsetCaption::latex(otexstream & os, + OutputParams const & runparams_in) const { - if (in_subfloat_) + if (runparams_in.inFloat == OutputParams::SUBFLOAT) // caption is output as an optional argument - return 0; + return; // This is a bit too simplistic to take advantage of // caption options we must add more later. (Lgb) // This code is currently only able to handle the simple // \caption{...}, later we will make it take advantage // of the one of the caption packages. (Lgb) OutputParams runparams = runparams_in; - // FIXME: actually, it is moving only when there is no - // optional argument. - runparams.moving_arg = true; - os << "\\caption"; - int l = latexOptArgInsets(paragraphs()[0], os, runparams, 1); - os << '{'; - l += InsetText::latex(os, runparams); - os << "}\n"; + InsetText::latex(os, runparams); + // Backwards compatibility: We always had a linebreak after + // the caption (see #8514) + os << breakln; runparams_in.encoding = runparams.encoding; - return l + 1; } -int InsetCaption::plaintext(odocstream & os, - OutputParams const & runparams) const +int InsetCaption::plaintext(odocstringstream & os, + OutputParams const & runparams, size_t max_length) const { os << '[' << full_label_ << "\n"; - InsetText::plaintext(os, runparams); + InsetText::plaintext(os, runparams, max_length); os << "\n]"; return PLAINTEXT_NEWLINE + 1; // one char on a separate line @@ -258,38 +295,90 @@ int InsetCaption::docbook(odocstream & os, } -int InsetCaption::getArgument(odocstream & os, - OutputParams const & runparams) const +docstring InsetCaption::xhtml(XHTMLStream & xs, OutputParams const & rp) const { - return InsetText::latex(os, runparams); + if (rp.html_disable_captions) + return docstring(); + InsetLayout const & il = getLayout(); + string const & tag = il.htmltag(); + string attr = il.htmlattr(); + if (!type_.empty()) { + string const our_class = "float-caption-" + type_; + size_t const loc = attr.find("class='"); + if (loc != string::npos) + attr.insert(loc + 7, our_class + " "); + else + attr = attr + " class='" + our_class + "'"; + } + xs << html::StartTag(tag, attr); + docstring def = getCaptionAsHTML(xs, rp); + xs << html::EndTag(tag); + return def; } -int InsetCaption::getOptArg(odocstream & os, +void InsetCaption::getArgument(otexstream & os, OutputParams const & runparams) const { - return latexOptArgInsets(paragraphs()[0], os, runparams, 1); + InsetLayout const & il = getLayout(); + + if (!il.leftdelim().empty()) + os << il.leftdelim(); + + OutputParams rp = runparams; + if (isPassThru()) + rp.pass_thru = true; + if (il.isNeedProtect()) + rp.moving_arg = true; + rp.par_begin = 0; + rp.par_end = paragraphs().size(); + + // Output the contents of the inset + if (!paragraphs().empty()) + os.texrow().forceStart(paragraphs()[0].id(), 0); + latexParagraphs(buffer(), text(), os, rp); + runparams.encoding = rp.encoding; + + if (!il.rightdelim().empty()) + os << il.rightdelim(); } -int InsetCaption::getCaptionText(odocstream & os, +int InsetCaption::getCaptionAsPlaintext(odocstream & os, OutputParams const & runparams) const { os << full_label_ << ' '; - return InsetText::plaintext(os, runparams); + odocstringstream ods; + int const retval = InsetText::plaintext(ods, runparams); + os << ods.str(); + return retval; } -void InsetCaption::updateLabels(ParIterator const & it) +docstring InsetCaption::getCaptionAsHTML(XHTMLStream & xs, + OutputParams const & runparams) const +{ + xs << full_label_ << ' '; + InsetText::XHTMLOptions const opts = + InsetText::WriteLabel | InsetText::WriteInnerTag; + return InsetText::insetAsXHTML(xs, runparams, opts); +} + + +void InsetCaption::updateBuffer(ParIterator const & it, UpdateType utype) { Buffer const & master = *buffer().masterBuffer(); DocumentClass const & tclass = master.params().documentClass(); + string const & lang = it.paragraph().getParLanguage(master.params())->code(); Counters & cnts = tclass.counters(); string const & type = cnts.current_float(); + if (utype == OutputUpdate) { + // counters are local to the caption + cnts.saveLastCounter(); + } // Memorize type for addToToc(). - type_ = type; - in_subfloat_ = cnts.isSubfloat(); - if (type.empty()) + floattype_ = type; + if (type.empty() || type == "senseless") full_label_ = master.B_("Senseless!!! "); else { // FIXME: life would be _much_ simpler if listings was @@ -300,22 +389,44 @@ void InsetCaption::updateLabels(ParIterator const & it) else name = master.B_(tclass.floats().getType(type).name()); docstring counter = from_utf8(type); - if (in_subfloat_) { + if ((is_subfloat_ = cnts.isSubfloat())) { + // only standard captions allowed in subfloats + type_ = "Standard"; counter = "sub-" + from_utf8(type); name = bformat(_("Sub-%1$s"), master.B_(tclass.floats().getType(type).name())); } + docstring sec; + docstring const lstring = getLayout().labelstring(); + docstring const labelstring = isAscii(lstring) ? + master.B_(to_ascii(lstring)) : lstring; if (cnts.hasCounter(counter)) { - cnts.step(counter); - full_label_ = bformat(from_ascii("%1$s %2$s:"), - name, - cnts.theCounter(counter)); - } else - full_label_ = bformat(from_ascii("%1$s #:"), name); + // for longtables, we step the counter upstream + if (!cnts.isLongtable()) + cnts.step(counter, utype); + sec = cnts.theCounter(counter, lang); + } + if (labelstring != master.B_("standard")) { + if (!sec.empty()) + sec += from_ascii(" "); + sec += bformat(from_ascii("(%1$s)"), labelstring); + } + if (!sec.empty()) + full_label_ = bformat(from_ascii("%1$s %2$s: "), name, sec); + else + full_label_ = bformat(from_ascii("%1$s #: "), name); } // Do the real work now. - InsetText::updateLabels(it); + InsetText::updateBuffer(it, utype); + if (utype == OutputUpdate) + cnts.restoreLastCounter(); +} + + +string InsetCaption::contextMenuName() const +{ + return "context-caption"; }