src/insets/insetbibitem.C

   1 /**
   2  * \file insetbibitem.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Alejandro Aguilar Sierra
   7  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10
  11 #include <config.h>
  12
  13 #include "insetbibitem.h"
  14
  15 #include "buffer.h"
  16 #include "BufferView.h"
  17 #include "dispatchresult.h"
  18 #include "funcrequest.h"
  19 #include "lyxfont.h"
  20 #include "lyxlex.h"
  21 #include "paragraph.h"
  22 #include "ParagraphList.h"
  23
  24 #include "support/lstrings.h"
  25 #include "support/std_ostream.h"
  26 #include "support/convert.h"
  27
  28 using lyx::docstring;
  29 using lyx::support::prefixIs;
  30
  31 using std::max;
  32 using std::string;
  33 using std::auto_ptr;
  34 using std::ostream;
  35
  36 int InsetBibitem::key_counter = 0;
  37 string const key_prefix = "key-";
  38
  39 InsetBibitem::InsetBibitem(InsetCommandParams const & p)
  40         : InsetCommand(p, "bibitem"), counter(1)
  41 {
  42         if (getContents().empty())
  43                 setContents(key_prefix + convert<string>(++key_counter));
  44 }
  45
  46
  47 auto_ptr<InsetBase> InsetBibitem::doClone() const
  48 {
  49         auto_ptr<InsetBibitem> b(new InsetBibitem(params()));
  50         b->setCounter(counter);
  51         return auto_ptr<InsetBase>(b);
  52 }
  53
  54
  55 void InsetBibitem::doDispatch(LCursor & cur, FuncRequest & cmd)
  56 {
  57         switch (cmd.action) {
  58
  59         case LFUN_INSET_MODIFY: {
  60                 InsetCommandParams p("bibitem");
  61                 InsetCommandMailer::string2params("bibitem", lyx::to_utf8(cmd.argument()), p);
  62                 if (p.getCmdName().empty()) {
  63                         cur.noUpdate();
  64                         break;
  65                 }
  66                 if (p.getContents() != params().getContents())
  67                         cur.bv().buffer()->changeRefsIfUnique(params().getContents(),
  68                                                        p.getContents(), InsetBase::CITE_CODE);
  69                 setParams(p);
  70         }
  71
  72         default:
  73                 InsetCommand::doDispatch(cur, cmd);
  74                 break;
  75         }
  76 }
  77
  78
  79 void InsetBibitem::setCounter(int c)
  80 {
  81         counter = c;
  82 }
  83
  84
  85 void InsetBibitem::read(Buffer const & buf, LyXLex & lex)
  86 {
  87         InsetCommand::read(buf, lex);
  88
  89         if (prefixIs(getContents(), key_prefix)) {
  90                 int const key = convert<int>(getContents().substr(key_prefix.length()));
  91                 key_counter = max(key_counter, key);
  92         }
  93 }
  94
  95
  96 docstring const InsetBibitem::getBibLabel() const
  97 {
  98         // FIXME UNICODE
  99         return getOptions().empty() ?
 100                 convert<docstring>(counter) :
 101                 lyx::from_utf8(getOptions());
 102 }
 103
 104
 105 docstring const InsetBibitem::getScreenLabel(Buffer const &) const
 106 {
 107         // FIXME UNICODE
 108         return lyx::from_utf8(getContents()) + " [" + getBibLabel() + ']';
 109 }
 110
 111
 112 int InsetBibitem::plaintext(Buffer const &, lyx::odocstream & os,
 113                             OutputParams const &) const
 114 {
 115         os << '[' << getCounter() << "] ";
 116         return 0;
 117 }
 118
 119
 120 // ale070405
 121 docstring const bibitemWidest(Buffer const & buffer)
 122 {
 123         int w = 0;
 124
 125         InsetBibitem const * bitem = 0;
 126
 127         // FIXME: this font is used unitialized for now but should  be set to
 128         // a proportional font. Here is what Georg Baum has to say about it:
 129         /*
 130         bibitemWidest() is supposed to find the bibitem with the widest label in the
 131         output, because that is needed as an argument of the bibliography
 132         environment to dtermine the correct indentation. To be 100% correct we
 133         would need the metrics of the font that is used in the output, but usually
 134         we don't have access to these.
 135         In practice, any proportional font is probably good enough, since we don't
 136         need to know the final with, we only need to know the which label is the
 137         widest.
 138         Unless there is an easy way to get the metrics of the output font I suggest
 139         to use a hardcoded font like "Times" or so.
 140
 141         It is very important that the result of this function is the same both with
 142         and without GUI. After thinking about this it is clear that no LyXFont
 143         metrics should be used here, since these come from the gui. If we can't
 144         easily get the LaTeX font metrics we should make our own poor mans front
 145         metrics replacement, e.g. by hardcoding the metrics of the standard TeX
 146         font.
 147         */
 148         LyXFont font;
 149
 150         ParagraphList::const_iterator it = buffer.paragraphs().begin();
 151         ParagraphList::const_iterator end = buffer.paragraphs().end();
 152
 153         for (; it != end; ++it) {
 154                 if (it->bibitem()) {
 155                         docstring const label = it->bibitem()->getBibLabel();
 156
 157                         // FIXME: we can't be sure using the following that the GUI
 158                         // version and the command-line version will give the same
 159                         // result.
 160                         //
 161                         //int const wx = lyx::use_gui?
 162                         //      theFontMetrics(font).width(label): label.size();
 163                         //
 164                         // So for now we just use the label size in order to be sure
 165                         // that GUI and no-GUI gives the same bibitem (even if that is
 166                         // potentially the wrong one.
 167                         int const wx = label.size();
 168
 169                         if (wx > w) {
 170                                 w = wx;
 171                                 bitem = it->bibitem();
 172                         }
 173                 }
 174         }
 175
 176         if (bitem && !bitem->getBibLabel().empty())
 177                 return bitem->getBibLabel();
 178
 179         return lyx::from_ascii("99");
 180 }