src/insets/InsetFoot.cpp

   1 /**
   2  * \file InsetFoot.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Jürgen Vigna
   7  * \author Lars Gullik Bjønnes
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #include <config.h>
  13
  14 #include "InsetFoot.h"
  15 #include "InsetBox.h"
  16
  17 #include "Buffer.h"
  18 #include "BufferParams.h"
  19 #include "Counters.h"
  20 #include "Language.h"
  21 #include "LaTeXFeatures.h"
  22 #include "Layout.h"
  23 #include "output_docbook.h"
  24 #include "ParIterator.h"
  25 #include "TextClass.h"
  26 #include "TocBackend.h"
  27
  28 #include "support/debug.h"
  29 #include "support/docstream.h"
  30 #include "support/gettext.h"
  31 #include "support/lstrings.h"
  32
  33 using namespace std;
  34
  35 namespace lyx {
  36
  37 InsetFoot::InsetFoot(Buffer * buf)
  38         : InsetFootlike(buf), intitle_(false), infloattable_(false)
  39 {}
  40
  41
  42 docstring InsetFoot::layoutName() const
  43 {
  44         if (intitle_)
  45                 return from_ascii("Foot:InTitle");
  46         else if (infloattable_)
  47                 return from_ascii("Foot:InFloatTable");
  48         return from_ascii("Foot");
  49 }
  50
  51
  52 void InsetFoot::updateBuffer(ParIterator const & it, UpdateType utype, bool const deleted)
  53 {
  54         BufferParams const & bp = buffer().masterBuffer()->params();
  55         Counters & cnts = bp.documentClass().counters();
  56         if (utype == OutputUpdate) {
  57                 // the footnote counter is local to this inset
  58                 cnts.saveLastCounter();
  59         }
  60
  61         intitle_ = false;
  62         infloattable_ = false;
  63         bool intable = false;
  64         if (it.innerInsetOfType(TABULAR_CODE) != 0)
  65                 intable = true;
  66         if (it.innerInsetOfType(FLOAT_CODE) != 0)
  67                 infloattable_ = intable;
  68         // If we are in a table in a float, but the table is also in a minipage,
  69         // we do not use tablefootnote, since minipages provide their own footnotes.
  70         if (intable && infloattable_ && it.innerInsetOfType(BOX_CODE) != 0) {
  71                 InsetBoxParams const & boxp =
  72                                 static_cast<InsetBox*>(it.innerInsetOfType(BOX_CODE))->params();
  73                 if (boxp.inner_box && !boxp.use_parbox && !boxp.use_makebox)
  74                         infloattable_ = false;
  75         }
  76         for (size_type sl = 0 ; sl < it.depth() ; ++sl) {
  77                 if (it[sl].text() && it[sl].paragraph().layout().intitle) {
  78                         intitle_ = true;
  79                         break;
  80                 }
  81         }
  82
  83         Language const * lang = it.paragraph().getParLanguage(bp);
  84         InsetLayout const & il = getLayout();
  85         docstring const & count = il.counter();
  86         custom_label_ = translateIfPossible(il.labelstring());
  87
  88         int val = cnts.value(count);
  89         if (cnts.hasCounter(count)) {
  90                 cnts.step(count, utype);
  91                 custom_label_ += ' ' + cnts.theCounter(count, lang->code());
  92                 if (deleted)
  93                         // un-step after deleted counter
  94                         cnts.set(count, val);
  95         } else
  96                 custom_label_ += ' ' + from_ascii("#");
  97         setLabel(custom_label_);
  98
  99         InsetCollapsible::updateBuffer(it, utype, deleted);
 100         if (utype == OutputUpdate)
 101                 cnts.restoreLastCounter();
 102 }
 103
 104
 105 docstring InsetFoot::toolTip(BufferView const & bv, int x, int y) const
 106 {
 107         if (isOpen(bv))
 108                 // this will give us something useful if there is no button
 109                 return InsetCollapsible::toolTip(bv, x, y);
 110         return toolTipText(custom_label_+ ": ");
 111 }
 112
 113
 114 int InsetFoot::plaintext(odocstringstream & os,
 115         OutputParams const & runparams, size_t max_length) const
 116 {
 117         os << '[' << buffer().B_("footnote") << ":\n";
 118         InsetText::plaintext(os, runparams, max_length);
 119         os << "\n]";
 120
 121         return PLAINTEXT_NEWLINE + 1; // one char on a separate line
 122 }
 123
 124
 125 void InsetFoot::docbook(XMLStream & xs, OutputParams const & runparams) const
 126 {
 127         OutputParams rp = runparams;
 128         rp.docbook_force_pars = true;
 129         rp.docbook_in_par = false;
 130         rp.docbook_consider_allow_multi_par = false;
 131         rp.docbook_make_pars = true;
 132         InsetText::docbook(xs, rp);
 133 }
 134
 135
 136 void InsetFoot::validate(LaTeXFeatures & features) const
 137 {
 138         // Use footnote package to provide footnotes in tables
 139         // unless an alternative approach is built in the class.
 140         if (!features.saveNoteEnv().empty()
 141             && !features.isProvided("footnote-alternative")) {
 142                 features.require("footnote");
 143                 features.addPreambleSnippet(
 144                         from_ascii("\\makesavenoteenv{"
 145                                    + features.saveNoteEnv()
 146                                    + "}\n"));
 147         }
 148
 149         InsetText::validate(features);
 150 }
 151
 152 } // namespace lyx