X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fbuffer_funcs.C;h=d1b0e76b56fe8f37e86083d04e1939e0f91197cb;hb=e7f4618bcce770369cf46335c2c7f0164b4b8857;hp=aea3e0b20c61ef8450849d52cdcf030d791524f5;hpb=de6418f37765fe452f135f96dee6d49897bff215;p=lyx.git diff --git a/src/buffer_funcs.C b/src/buffer_funcs.C index aea3e0b20c..d1b0e76b56 100644 --- a/src/buffer_funcs.C +++ b/src/buffer_funcs.C @@ -32,19 +32,20 @@ #include "pariterator.h" #include "lyxvc.h" #include "texrow.h" +#include "TocBackend.h" #include "vc-backend.h" -#include "toc.h" #include "frontends/Alert.h" #include "insets/insetbibitem.h" +#include "insets/insetcaption.h" +#include "insets/insetinclude.h" +#include "insets/insettabular.h" #include "support/filetools.h" #include "support/fs_extras.h" #include "support/lyxlib.h" -#include - #include #include @@ -54,7 +55,9 @@ namespace lyx { using namespace std; using support::bformat; +using support::FileName; using support::libFileSearch; +using support::makeAbsPath; using support::makeDisplayPath; using support::onlyFilename; using support::onlyPath; @@ -68,13 +71,13 @@ namespace fs = boost::filesystem; namespace { -bool readFile(Buffer * const b, string const & s) +bool readFile(Buffer * const b, FileName const & s) { BOOST_ASSERT(b); // File information about normal file - if (!fs::exists(s)) { - docstring const file = makeDisplayPath(s, 50); + if (!fs::exists(s.toFilesystemEncoding())) { + docstring const file = makeDisplayPath(s.absFilename(), 50); docstring text = bformat(_("The specified document\n%1$s" "\ncould not be read."), file); Alert::error(_("Could not read document"), text); @@ -82,12 +85,13 @@ bool readFile(Buffer * const b, string const & s) } // Check if emergency save file exists and is newer. - string const e = onlyPath(s) + onlyFilename(s) + ".emergency"; + FileName const e(s.absFilename() + ".emergency"); - if (fs::exists(e) && fs::exists(s) - && fs::last_write_time(e) > fs::last_write_time(s)) + if (fs::exists(e.toFilesystemEncoding()) && + fs::exists(s.toFilesystemEncoding()) && + fs::last_write_time(e.toFilesystemEncoding()) > fs::last_write_time(s.toFilesystemEncoding())) { - docstring const file = makeDisplayPath(s, 20); + docstring const file = makeDisplayPath(s.absFilename(), 20); docstring const text = bformat(_("An emergency save of the document " "%1$s exists.\n\n" @@ -108,12 +112,13 @@ bool readFile(Buffer * const b, string const & s) } // Now check if autosave file is newer. - string const a = onlyPath(s) + '#' + onlyFilename(s) + '#'; + FileName const a(onlyPath(s.absFilename()) + '#' + onlyFilename(s.absFilename()) + '#'); - if (fs::exists(a) && fs::exists(s) - && fs::last_write_time(a) > fs::last_write_time(s)) + if (fs::exists(a.toFilesystemEncoding()) && + fs::exists(s.toFilesystemEncoding()) && + fs::last_write_time(a.toFilesystemEncoding()) > fs::last_write_time(s.toFilesystemEncoding())) { - docstring const file = makeDisplayPath(s, 20); + docstring const file = makeDisplayPath(s.absFilename(), 20); docstring const text = bformat(_("The backup of the document " "%1$s is newer.\n\nLoad the " @@ -142,19 +147,19 @@ bool readFile(Buffer * const b, string const & s) -bool loadLyXFile(Buffer * b, string const & s) +bool loadLyXFile(Buffer * b, FileName const & s) { BOOST_ASSERT(b); - if (fs::is_readable(s)) { + if (fs::is_readable(s.toFilesystemEncoding())) { if (readFile(b, s)) { b->lyxvc().file_found_hook(s); - if (!fs::is_writable(s)) + if (!fs::is_writable(s.toFilesystemEncoding())) b->setReadonly(true); return true; } } else { - docstring const file = makeDisplayPath(s, 20); + docstring const file = makeDisplayPath(s.absFilename(), 20); // Here we probably should run if (LyXVC::file_not_found_hook(s)) { docstring const text = @@ -183,16 +188,16 @@ Buffer * newFile(string const & filename, string const & templatename, Buffer * b = theBufferList().newBuffer(filename); BOOST_ASSERT(b); - string tname; + FileName tname; // use defaults.lyx as a default template if it exists. if (templatename.empty()) tname = libFileSearch("templates", "defaults.lyx"); else - tname = templatename; + tname = makeAbsPath(templatename); if (!tname.empty()) { if (!b->readFile(tname)) { - docstring const file = makeDisplayPath(tname, 50); + docstring const file = makeDisplayPath(tname.absFilename(), 50); docstring const text = bformat( _("The specified document template\n%1$s\ncould not be read."), file); @@ -235,8 +240,8 @@ void bufferErrors(Buffer const & buf, TeXErrors const & terr, pos_end); } while (found && id_start == id_end && pos_start == pos_end); - errorList.push_back(ErrorItem(from_utf8(cit->error_desc), - from_utf8(cit->error_text), id_start, pos_start, pos_end)); + errorList.push_back(ErrorItem(cit->error_desc, + cit->error_text, id_start, pos_start, pos_end)); } } @@ -348,12 +353,78 @@ bool needEnumCounterReset(ParIterator const & it) } +void setCaptionLabels(InsetBase & inset, string const & type, + docstring const label, Counters & counters) +{ + LyXText * text = inset.getText(0); + if (!text) + return; + + ParagraphList & pars = text->paragraphs(); + if (pars.empty()) + return; + + docstring const counter = from_ascii(type); + + ParagraphList::iterator p = pars.begin(); + for (; p != pars.end(); ++p) { + InsetList::iterator it2 = p->insetlist.begin(); + InsetList::iterator end2 = p->insetlist.end(); + // Any caption within this float should have the same + // label prefix but different numbers. + for (; it2 != end2; ++it2) { + InsetBase & icap = *it2->inset; + // Look deeper just in case. + setCaptionLabels(icap, type, label, counters); + if (icap.lyxCode() == InsetBase::CAPTION_CODE) { + // We found a caption! + counters.step(counter); + int number = counters.value(counter); + InsetCaption & ic = static_cast(icap); + ic.setType(type); + ic.setCount(number); + ic.setCustomLabel(label); + } + } + } +} + + +void setCaptions(Paragraph & par, LyXTextClass const & textclass) +{ + if (par.insetlist.empty()) + return; + + Counters & counters = textclass.counters(); + + InsetList::iterator it = par.insetlist.begin(); + InsetList::iterator end = par.insetlist.end(); + for (; it != end; ++it) { + InsetBase & inset = *it->inset; + if (inset.lyxCode() == InsetBase::FLOAT_CODE + || inset.lyxCode() == InsetBase::WRAP_CODE) { + docstring const & name = inset.getInsetName(); + if (name.empty()) + continue; + + Floating const & fl = textclass.floats().getType(to_ascii(name)); + // FIXME UNICODE + string const & type = fl.type(); + docstring const label = from_utf8(fl.name()); + setCaptionLabels(inset, type, label, counters); + } + else if (inset.lyxCode() == InsetBase::TABULAR_CODE + && static_cast(inset).tabular.isLongTabular()) { + // FIXME: are "table" and "Table" the correct type and label? + setCaptionLabels(inset, "table", from_ascii("Table"), counters); + } + } +} + // set the label of a paragraph. This includes the counters. -void setLabel(Buffer const & buf, ParIterator & it) +void setLabel(Buffer const & buf, ParIterator & it, LyXTextClass const & textclass) { Paragraph & par = *it; - BufferParams const & bufparams = buf.params(); - LyXTextClass const & textclass = bufparams.getLyXTextClass(); LyXLayout_ptr const & layout = par.layout(); Counters & counters = textclass.counters(); @@ -371,33 +442,35 @@ void setLabel(Buffer const & buf, ParIterator & it) // Compute the item depth of the paragraph par.itemdepth = getItemDepth(it); - // erase what was there before - par.params().labelString(docstring()); - if (layout->margintype == MARGIN_MANUAL) { if (par.params().labelWidthString().empty()) - par.setLabelWidthString(layout->labelstring()); + par.params().labelWidthString(par.translateIfPossible(layout->labelstring(), buf.params())); } else { - par.setLabelWidthString(docstring()); + par.params().labelWidthString(docstring()); } + // Optimisation: setLabel() can be called for each for each + // paragraph of the document. So we make the string static to + // avoid the repeated instanciation. + static docstring itemlabel; + // is it a layout that has an automatic label? if (layout->labeltype == LABEL_COUNTER) { if (layout->toclevel <= buf.params().secnumdepth && (layout->latextype != LATEX_ENVIRONMENT || isFirstInSequence(it.pit(), it.plist()))) { counters.step(layout->counter); - docstring label = expandLabel(buf, layout, - par.params().appendix()); - par.params().labelString(label); - } + par.params().labelString( + par.expandLabel(layout, buf.params())); + } else + par.params().labelString(docstring()); + } else if (layout->labeltype == LABEL_ITEMIZE) { // At some point of time we should do something more // clever here, like: // par.params().labelString( - // bufparams.user_defined_bullet(par.itemdepth).getText()); + // buf.params().user_defined_bullet(par.itemdepth).getText()); // for now, use a simple hardcoded label - docstring itemlabel; switch (par.itemdepth) { case 0: itemlabel = char_type(0x2022); @@ -409,11 +482,11 @@ void setLabel(Buffer const & buf, ParIterator & it) itemlabel = char_type(0x2217); break; case 3: - itemlabel += char_type(0x2219); // or 0x00b7 + itemlabel = char_type(0x2219); // or 0x00b7 break; } - par.params().labelString(itemlabel); + } else if (layout->labeltype == LABEL_ENUMERATE) { // FIXME // Yes I know this is a really, really! bad solution @@ -462,49 +535,51 @@ void setLabel(Buffer const & buf, ParIterator & it) break; } - par.params().labelString(counters.counterLabel(buf.B_(format))); + par.params().labelString(counters.counterLabel( + par.translateIfPossible(from_ascii(format), buf.params()))); + } else if (layout->labeltype == LABEL_BIBLIO) {// ale970302 counters.step(from_ascii("bibitem")); int number = counters.value(from_ascii("bibitem")); if (par.bibitem()) par.bibitem()->setCounter(number); - // FIXME UNICODE - par.params().labelString(buf.B_(to_ascii(layout->labelstring()))); - // In biblio should't be following counters but... + + par.params().labelString( + par.translateIfPossible(layout->labelstring(), buf.params())); + // In biblio shouldn't be following counters but... } else if (layout->labeltype == LABEL_SENSITIVE) { // Search for the first float or wrap inset in the iterator - docstring type; size_t i = it.depth(); + InsetBase * in; while (i > 0) { --i; - InsetBase * const in = &it[i].inset(); + in = &it[i].inset(); if (in->lyxCode() == InsetBase::FLOAT_CODE - || in->lyxCode() == InsetBase::WRAP_CODE) { - type = in->getInsetName(); + || in->lyxCode() == InsetBase::WRAP_CODE) break; - } } + docstring const & type = in->getInsetName(); - docstring s; if (!type.empty()) { Floating const & fl = textclass.floats().getType(to_ascii(type)); // FIXME UNICODE counters.step(from_ascii(fl.type())); // Doesn't work... yet. - s = bformat(_("%1$s #:"), buf.B_(fl.name())); + par.params().labelString(par.translateIfPossible( + bformat(from_ascii("%1$s #:"), from_utf8(fl.name())), + buf.params())); } else { // par->SetLayout(0); - // FIXME UNICODE - s = buf.B_(to_ascii(layout->labelstring())); + par.params().labelString(par.translateIfPossible( + layout->labelstring(), buf.params())); } - par.params().labelString(s); } else if (layout->labeltype == LABEL_NO_LABEL) par.params().labelString(docstring()); else - // FIXME UNICODE - par.params().labelString(buf.B_(to_ascii(layout->labelstring()))); + par.params().labelString( + par.translateIfPossible(layout->labelstring(), buf.params())); } } // anon namespace @@ -516,7 +591,7 @@ bool updateCurrentLabel(Buffer const & buf, if (it == par_iterator_end(buf.inset())) return false; -// if (it.lastpit == 0 && LyXText::isMainText()) +// if (it.lastpit == 0 && LyXText::isMainText(buf)) // return false; switch (it->layout()->labeltype) { @@ -528,7 +603,7 @@ bool updateCurrentLabel(Buffer const & buf, case LABEL_CENTERED_TOP_ENVIRONMENT: case LABEL_STATIC: case LABEL_ITEMIZE: - setLabel(buf, it); + setLabel(buf, it, buf.params().getLyXTextClass()); return true; case LABEL_SENSITIVE: @@ -544,33 +619,44 @@ bool updateCurrentLabel(Buffer const & buf, void updateLabels(Buffer const & buf, - ParIterator & from, ParIterator & to) + ParIterator & from, ParIterator & to, bool childonly) { for (ParIterator it = from; it != to; ++it) { if (it.pit() > it.lastpit()) return; if (!updateCurrentLabel (buf, it)) { - updateLabels(buf); + updateLabels(buf, childonly); return; } } } -void updateLabels(Buffer const & buf, - ParIterator & iter) +void updateLabels(Buffer const & buf, ParIterator & iter, bool childonly) { if (updateCurrentLabel(buf, iter)) return; - updateLabels(buf); + updateLabels(buf, childonly); } -void updateLabels(Buffer const & buf) +void updateLabels(Buffer const & buf, bool childonly) { - // start over the counters - buf.params().getLyXTextClass().counters().reset(); + // Use the master text class also for child documents + LyXTextClass const & textclass = buf.params().getLyXTextClass(); + + if (!childonly) { + // If this is a child document start with the master + Buffer const * const master = buf.getMasterBuffer(); + if (master != &buf) { + updateLabels(*master); + return; + } + + // start over the counters + textclass.counters().reset(); + } ParIterator const end = par_iterator_end(buf.inset()); @@ -584,36 +670,24 @@ void updateLabels(Buffer const & buf) it->params().depth(0); // set the counter for this paragraph - setLabel(buf, it); - } - - toc::updateToc(buf); -} - - -docstring expandLabel(Buffer const & buf, - LyXLayout_ptr const & layout, bool appendix) -{ - LyXTextClass const & tclass = buf.params().getLyXTextClass(); - - // FIXME UNICODE - docstring fmt = buf.B_(to_ascii(appendix ? layout->labelstring_appendix() - : layout->labelstring())); - - // handle 'inherited level parts' in 'fmt', - // i.e. the stuff between '@' in '@Section@.\arabic{subsection}' - size_t const i = fmt.find('@', 0); - if (i != docstring::npos) { - size_t const j = fmt.find('@', i + 1); - if (j != docstring::npos) { - docstring parent(fmt, i + 1, j - i - 1); - // FIXME UNICODE - docstring label = expandLabel(buf, tclass[to_utf8(parent)], appendix); - fmt = docstring(fmt, 0, i) + label + docstring(fmt, j + 1, docstring::npos); + setLabel(buf, it, textclass); + + // It is better to set the captions after setLabel because + // the caption number might need the section number in the + // future. + setCaptions(*it, textclass); + + // Now included docs + InsetList::const_iterator iit = it->insetlist.begin(); + InsetList::const_iterator end = it->insetlist.end(); + for (; iit != end; ++iit) { + if (iit->inset->lyxCode() == InsetBase::INCLUDE_CODE) + static_cast(iit->inset) + ->updateLabels(buf); } } - return tclass.counters().counterLabel(fmt); + const_cast(buf).tocBackend().update(); }