]> git.lyx.org Git - lyx.git/blob - src/insets/insetcaption.C
c91d771b05f6520acc05d1b30f88f92ebabf5a6c
[lyx.git] / src / insets / insetcaption.C
1 /**
2  * \file insetcaption.C
3  * This file is part of LyX, the document processor.
4  * Licence details can be found in the file COPYING.
5  *
6  * \author Lars Gullik Bjønnes
7  *
8  * Full author contact details are available in file CREDITS.
9  */
10
11 #include <config.h>
12
13 #include "insetcaption.h"
14 #include "insetfloat.h"
15 #include "insetwrap.h"
16
17 #include "buffer.h"
18 #include "bufferparams.h"
19 #include "counters.h"
20 #include "cursor.h"
21 #include "BufferView.h"
22 #include "Floating.h"
23 #include "FloatList.h"
24 #include "gettext.h"
25 #include "LColor.h"
26 #include "metricsinfo.h"
27 #include "paragraph.h"
28
29 #include "frontends/font_metrics.h"
30 #include "frontends/Painter.h"
31
32 #include "support/lstrings.h"
33 #include "support/convert.h"
34
35 #include <sstream>
36
37
38 using lyx::support::bformat;
39
40 using std::auto_ptr;
41 using std::endl;
42 using std::string;
43 using std::ostream;
44 using std::ostringstream;
45
46
47 InsetCaption::InsetCaption(BufferParams const & bp)
48         : InsetText(bp), textclass_(bp.getLyXTextClass())
49 {
50         setAutoBreakRows(true);
51         setDrawFrame(true);
52         setFrameColor(LColor::captionframe);
53 }
54
55
56 void InsetCaption::write(Buffer const & buf, ostream & os) const
57 {
58         os << "Caption\n";
59         text_.write(buf, os);
60 }
61
62
63 void InsetCaption::read(Buffer const & buf, LyXLex & lex)
64 {
65 #if 0
66         // We will enably this check again when the compability
67         // code is removed from Buffer::Read (Lgb)
68         string const token = lex.GetString();
69         if (token != "Caption") {
70                 lyxerr << "InsetCaption::Read: consistency check failed."
71                        << endl;
72         }
73 #endif
74         InsetText::read(buf, lex);
75 }
76
77
78 string const InsetCaption::editMessage() const
79 {
80         return _("Opened Caption Inset");
81 }
82
83
84 void InsetCaption::cursorPos
85         (CursorSlice const & sl, bool boundary, int & x, int & y) const
86 {
87         InsetText::cursorPos(sl, boundary, x, y);
88         x += labelwidth_;
89 }
90
91
92 void InsetCaption::setLabel(LCursor & cur) const
93 {
94         // Set caption label _only_ if the cursor is in _this_ float:
95         if (cur.top().text() == &text_) {
96                 string s; 
97                 size_t i = cur.depth();
98                         while (i > 0) {
99                                 --i;
100                                 InsetBase * const in = &cur[i].inset();
101                                 if (in->lyxCode() == InsetBase::FLOAT_CODE
102                                     || in->lyxCode() == InsetBase::WRAP_CODE) {
103                                         s = in->getInsetName();
104                                         break;
105                                 }
106                         }
107                 Floating const & fl = textclass_.floats().getType(s);
108                 s = fl.name();
109                 string num;
110                 if (s.empty())
111                         s = "Senseless";
112                 else 
113                         num = convert<string>(counter_);
114
115                 // Generate the label
116                 label = bformat("%1$s %2$s:", _(s), num);
117         }
118 }
119
120
121 void InsetCaption::metrics(MetricsInfo & mi, Dimension & dim) const
122 {
123         mi.base.textwidth -= 2 * TEXT_TO_INSET_OFFSET;
124         LCursor cur = mi.base.bv->cursor();
125         setLabel(cur);
126         labelwidth_ = font_metrics::width(label, mi.base.font);
127         dim.wid = labelwidth_;
128         Dimension textdim;
129         InsetText::metrics(mi, textdim);
130         dim.des = std::max(dim.des - textdim.asc + dim.asc, textdim.des);
131         dim.asc = textdim.asc;
132         dim.wid += textdim.wid;
133         dim.asc += TEXT_TO_INSET_OFFSET;
134         dim.des += TEXT_TO_INSET_OFFSET;
135         dim.wid += 2 * TEXT_TO_INSET_OFFSET;
136         mi.base.textwidth += 2 * TEXT_TO_INSET_OFFSET;
137         dim_ = dim;
138 }
139
140
141 void InsetCaption::draw(PainterInfo & pi, int x, int y) const
142 {
143         // We must draw the label, we should get the label string
144         // from the enclosing float inset.
145         // The question is: Who should draw the label, the caption inset,
146         // the text inset or the paragraph?
147         // We should also draw the float number (Lgb)
148
149         // See if we can find the name of the float this caption
150         // belongs to.
151         LCursor cur = pi.base.bv->cursor();
152         setLabel(cur);
153
154         labelwidth_ = font_metrics::width(label, pi.base.font);
155         pi.pain.text(x, y, label, pi.base.font);
156         InsetText::draw(pi, x + labelwidth_, y);
157         setPosCache(pi, x, y);
158 }
159
160
161 void InsetCaption::edit(LCursor & cur, bool left)
162 {
163         cur.push(*this);
164         InsetText::edit(cur, left);
165 }
166
167
168 InsetBase * InsetCaption::editXY(LCursor & cur, int x, int y)
169 {
170         cur.push(*this);
171         return InsetText::editXY(cur, x, y);
172 }
173
174
175 int InsetCaption::latex(Buffer const & buf, ostream & os,
176                         OutputParams const & runparams) const
177 {
178         // This is a bit too simplistic to take advantage of
179         // caption options we must add more later. (Lgb)
180         // This code is currently only able to handle the simple
181         // \caption{...}, later we will make it take advantage
182         // of the one of the caption packages. (Lgb)
183         ostringstream ost;
184         int const l = InsetText::latex(buf, ost, runparams);
185         os << "\\caption{" << ost.str() << "}\n";
186         return l + 1;
187 }
188
189
190 int InsetCaption::plaintext(Buffer const & /*buf*/,ostream & /*os*/,
191                         OutputParams const & /*runparams*/) const
192 {
193         // FIXME: Implement me!
194         return 0;
195 }
196
197
198 int InsetCaption::docbook(Buffer const & buf, ostream & os,
199                           OutputParams const & runparams) const
200 {
201         int ret;
202         os << "<title>";
203         ret = InsetText::docbook(buf, os, runparams);
204         os << "</title>\n";
205         return ret;
206 }
207
208
209 auto_ptr<InsetBase> InsetCaption::doClone() const
210 {
211         return auto_ptr<InsetBase>(new InsetCaption(*this));
212 }