X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetCaption.cpp;h=b1c4e08d1a4b1a9c0b51763c16c95db3ff32ff61;hb=dbb1ac30e9a87007af7c53f0f93ec9e21826f90b;hp=75ab04a986d193ead9dadce1ec0c2bda5377b69d;hpb=85fa1e9efd3c2caeadc7cc396486137fab962117;p=lyx.git diff --git a/src/insets/InsetCaption.cpp b/src/insets/InsetCaption.cpp index 75ab04a986..b1c4e08d1a 100644 --- a/src/insets/InsetCaption.cpp +++ b/src/insets/InsetCaption.cpp @@ -3,7 +3,7 @@ * This file is part of LyX, the document processor. * Licence details can be found in the file COPYING. * - * \author Lars Gullik Bjønnes + * \author Lars Gullik Bjønnes * * Full author contact details are available in file CREDITS. */ @@ -16,80 +16,60 @@ #include "Buffer.h" #include "BufferParams.h" +#include "BufferView.h" #include "Counters.h" #include "Cursor.h" -#include "BufferView.h" +#include "Dimension.h" #include "Floating.h" #include "FloatList.h" #include "FuncRequest.h" #include "FuncStatus.h" -#include "gettext.h" -#include "Color.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 "TextClass.h" +#include "TextMetrics.h" #include "TocBackend.h" #include "frontends/FontMetrics.h" #include "frontends/Painter.h" +#include "support/gettext.h" #include "support/lstrings.h" #include - -using std::endl; -using std::string; -using std::ostream; - +using namespace std; +using namespace lyx::support; namespace lyx { -InsetCaption::InsetCaption(InsetCaption const & ic) - : InsetText(ic), textclass_(ic.textclass_) +InsetCaption::InsetCaption(Buffer * buf) + : InsetText(buf, InsetText::PlainLayout) { setAutoBreakRows(true); setDrawFrame(true); - setFrameColor(Color::captionframe); -} - -InsetCaption::InsetCaption(BufferParams const & bp) - : InsetText(bp), textclass_(bp.getTextClass()) -{ - setAutoBreakRows(true); - setDrawFrame(true); - setFrameColor(Color::captionframe); + setFrameColor(Color_collapsableframe); } -void InsetCaption::write(Buffer const & buf, ostream & os) const +void InsetCaption::write(ostream & os) const { os << "Caption\n"; - text_.write(buf, os); -} - - -void InsetCaption::read(Buffer const & buf, Lexer & lex) -{ -#if 0 - // We will enably this check again when the compability - // code is removed from Buffer::Read (Lgb) - string const token = lex.GetString(); - if (token != "Caption") { - lyxerr << "InsetCaption::Read: consistency check failed." - << endl; - } -#endif - InsetText::read(buf, lex); + text().write(os); } -docstring const InsetCaption::editMessage() const +docstring InsetCaption::layoutName() const { - return _("Opened Caption Inset"); + if (type_.empty()) + return from_ascii("Caption"); + return from_utf8("Caption:" + type_); } @@ -103,7 +83,7 @@ void InsetCaption::cursorPos(BufferView const & bv, void InsetCaption::setCustomLabel(docstring const & label) { - if (!support::isAscii(label) || label.empty()) + 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; @@ -112,21 +92,28 @@ void InsetCaption::setCustomLabel(docstring const & label) } -void InsetCaption::addToToc(TocList & toclist, Buffer const & buf, ParConstIterator const &) const +void InsetCaption::addToToc(DocIterator const & cpit) const { if (type_.empty()) return; - ParConstIterator pit = par_const_iterator_begin(*this); + DocIterator pit = cpit; + pit.push_back(CursorSlice(const_cast(*this))); - Toc & toc = toclist[type_]; - docstring const str = full_label_ + ". " + pit->asString(buf, false); + Toc & toc = buffer().tocBackend().toc(type_); + docstring str = full_label_ + ". "; + text().forToc(str, TOC_ENTRY_LENGTH); toc.push_back(TocItem(pit, 0, str)); + + // Proceed with the rest of the inset. + InsetText::addToToc(cpit); } -bool InsetCaption::metrics(MetricsInfo & mi, Dimension & dim) const +void InsetCaption::metrics(MetricsInfo & mi, Dimension & dim) const { + FontInfo tmpfont = mi.base.font; + mi.base.font = mi.base.bv->buffer().params().getFont().fontInfo(); labelwidth_ = theFontMetrics(mi.base.font).width(full_label_); // add some space to separate the label from the inset text labelwidth_ += 2 * TEXT_TO_INSET_OFFSET; @@ -135,13 +122,20 @@ bool InsetCaption::metrics(MetricsInfo & mi, Dimension & dim) const // Correct for button and label width mi.base.textwidth -= dim.wid; InsetText::metrics(mi, textdim); + mi.base.font = tmpfont; mi.base.textwidth += dim.wid; - dim.des = std::max(dim.des - textdim.asc + dim.asc, textdim.des); + dim.des = max(dim.des - textdim.asc + dim.asc, textdim.des); dim.asc = textdim.asc; dim.wid += textdim.wid; - bool const changed = dim_ != dim; - dim_ = dim; - return changed; +} + + +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)); } @@ -155,15 +149,20 @@ void InsetCaption::draw(PainterInfo & pi, int x, int y) const // Answer: the text inset (in buffer_funcs.cpp: setCaption). - pi.pain.text(x, y, full_label_, pi.base.font); + FontInfo tmpfont = pi.base.font; + pi.base.font = pi.base.bv->buffer().params().getFont().fontInfo(); + 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; } -void InsetCaption::edit(Cursor & cur, bool left) +void InsetCaption::edit(Cursor & cur, bool front, EntryDirection entry_from) { cur.push(*this); - InsetText::edit(cur, left); + InsetText::edit(cur, front, entry_from); } @@ -174,14 +173,18 @@ Inset * InsetCaption::editXY(Cursor & cur, int x, int y) } -bool InsetCaption::insetAllowed(Inset::Code code) const +bool InsetCaption::insetAllowed(InsetCode code) const { switch (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: - case CAPTION_CODE: - case PAGEBREAK_CODE: return false; default: return InsetText::insetAllowed(code); @@ -192,27 +195,33 @@ bool InsetCaption::insetAllowed(Inset::Code code) const bool InsetCaption::getStatus(Cursor & cur, FuncRequest const & cmd, FuncStatus & status) const { - switch (cmd.action) { + switch (cmd.action()) { - case LFUN_BREAK_PARAGRAPH: - case LFUN_BREAK_PARAGRAPH_KEEP_LAYOUT: - case LFUN_BREAK_PARAGRAPH_SKIP: - status.enabled(false); + case LFUN_PARAGRAPH_BREAK: + status.setEnabled(false); return true; - case LFUN_OPTIONAL_INSERT: - status.enabled(numberOfOptArgs(cur.paragraph()) == 0); + case LFUN_ARGUMENT_INSERT: + status.setEnabled(cur.paragraph().insetList().find(ARG_CODE) == -1); return true; + case LFUN_INSET_TOGGLE: + // pass back to owner + cur.undispatched(); + return false; + default: return InsetText::getStatus(cur, cmd, status); } } -int InsetCaption::latex(Buffer const & buf, odocstream & os, - OutputParams const & runparams_in) const +void InsetCaption::latex(otexstream & os, + OutputParams const & runparams_in) const { + if (runparams_in.inFloat == OutputParams::SUBFLOAT) + // caption is output as an optional argument + 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 @@ -223,84 +232,125 @@ int InsetCaption::latex(Buffer const & buf, odocstream & os, // optional argument. runparams.moving_arg = true; os << "\\caption"; - int l = latexOptArgInsets(buf, paragraphs()[0], os, runparams, 1); + latexArgInsets(paragraphs()[0], os, runparams, 0, 1); os << '{'; - l += InsetText::latex(buf, os, runparams); + InsetText::latex(os, runparams); os << "}\n"; runparams_in.encoding = runparams.encoding; - return l + 1; } -int InsetCaption::plaintext(Buffer const & buf, odocstream & os, +int InsetCaption::plaintext(odocstream & os, OutputParams const & runparams) const { os << '[' << full_label_ << "\n"; - InsetText::plaintext(buf, os, runparams); + InsetText::plaintext(os, runparams); os << "\n]"; return PLAINTEXT_NEWLINE + 1; // one char on a separate line } -int InsetCaption::docbook(Buffer const & buf, odocstream & os, +int InsetCaption::docbook(odocstream & os, OutputParams const & runparams) const { int ret; os << ""; - ret = InsetText::docbook(buf, os, runparams); + ret = InsetText::docbook(os, runparams); os << "\n"; return ret; } -int InsetCaption::getArgument(Buffer const & buf, odocstream & os, +docstring InsetCaption::xhtml(XHTMLStream & xs, OutputParams const & rp) const +{ + if (rp.html_disable_captions) + return docstring(); + string attr = "class='float-caption"; + if (!type_.empty()) + attr += " float-caption-" + type_; + attr += "'"; + xs << html::StartTag("div", attr); + docstring def = getCaptionAsHTML(xs, rp); + xs << html::EndTag("div"); + return def; +} + + +void InsetCaption::getArgument(otexstream & os, + OutputParams const & runparams) const +{ + InsetText::latex(os, runparams); +} + + +void InsetCaption::getOptArg(otexstream & os, + OutputParams const & runparams) const +{ + latexArgInsets(paragraphs()[0], os, runparams, 0, 1); +} + + +int InsetCaption::getCaptionAsPlaintext(odocstream & os, OutputParams const & runparams) const { - return InsetText::latex(buf, os, runparams); + os << full_label_ << ' '; + return InsetText::plaintext(os, runparams); } -int InsetCaption::getOptArg(Buffer const & buf, odocstream & os, +docstring InsetCaption::getCaptionAsHTML(XHTMLStream & xs, OutputParams const & runparams) const { - return latexOptArgInsets(buf, paragraphs()[0], os, runparams, 1); + xs << full_label_ << ' '; + InsetText::XHTMLOptions const opts = + InsetText::WriteLabel | InsetText::WriteInnerTag; + return InsetText::insetAsXHTML(xs, runparams, opts); } -void InsetCaption::updateLabels(Buffer const & buf, ParIterator const & it) +void InsetCaption::updateBuffer(ParIterator const & it, UpdateType utype) { - using support::bformat; - TextClass const & tclass = buf.params().getTextClass(); + 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; if (type.empty()) - full_label_ = buf.B_("Senseless!!! "); + full_label_ = master.B_("Senseless!!! "); else { // FIXME: life would be _much_ simpler if listings was // listed in Floating. docstring name; if (type == "listing") - name = buf.B_("Listing"); + name = master.B_("Listing"); else - name = buf.B_(tclass.floats().getType(type).name()); - if (cnts.hasCounter(from_utf8(type))) { - cnts.step(from_utf8(type)); + name = master.B_(tclass.floats().getType(type).name()); + docstring counter = from_utf8(type); + if (cnts.isSubfloat()) { + counter = "sub-" + from_utf8(type); + name = bformat(_("Sub-%1$s"), + master.B_(tclass.floats().getType(type).name())); + } + if (cnts.hasCounter(counter)) { + cnts.step(counter, utype); full_label_ = bformat(from_ascii("%1$s %2$s:"), - name, - cnts.theCounter(from_utf8(type))); + name, + cnts.theCounter(counter, lang)); } else full_label_ = bformat(from_ascii("%1$s #:"), name); } // Do the real work now. - InsetText::updateLabels(buf, it); -} - - -Inset * InsetCaption::clone() const -{ - return new InsetCaption(*this); + InsetText::updateBuffer(it, utype); + if (utype == OutputUpdate) + cnts.restoreLastCounter(); }