src/insets/insetcollapsable.C

   1 /**
   2  * \file insetcollapsable.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  * \author Jürgen Vigna
   8  * \author Lars Gullik Bjønnes
   9  *
  10  * Full author contact details are available in file CREDITS.
  11  */
  12
  13 #include <config.h>
  14
  15 #include "insetcollapsable.h"
  16
  17 #include "buffer.h"
  18 #include "BufferView.h"
  19 #include "cursor.h"
  20 #include "debug.h"
  21 #include "dispatchresult.h"
  22 #include "LColor.h"
  23 #include "lyxlex.h"
  24 #include "funcrequest.h"
  25 #include "metricsinfo.h"
  26 #include "paragraph.h"
  27
  28 #include "frontends/font_metrics.h"
  29 #include "frontends/Painter.h"
  30 #include "frontends/LyXView.h"
  31
  32
  33 using lyx::graphics::PreviewLoader;
  34
  35 using std::endl;
  36 using std::string;
  37 using std::max;
  38 using std::min;
  39 using std::ostream;
  40
  41
  42 InsetCollapsable::InsetCollapsable(BufferParams const & bp, bool collapsed)
  43         : UpdatableInset(), inset(bp), status_(collapsed ? Collapsed : Open),
  44           label("Label")
  45 #if 0
  46         ,autocollapse(false)
  47 #endif
  48 {
  49         inset.setOwner(this);
  50         inset.setAutoBreakRows(true);
  51         inset.setDrawFrame(InsetText::ALWAYS);
  52         inset.setFrameColor(LColor::collapsableframe);
  53         setInsetName("Collapsable");
  54 }
  55
  56
  57 InsetCollapsable::InsetCollapsable(InsetCollapsable const & in)
  58         : UpdatableInset(in), inset(in.inset), status_(in.status_),
  59           labelfont_(in.labelfont_), label(in.label)
  60 #if 0
  61           ,autocollapse(in.autocollapse)
  62 #endif
  63 {
  64         inset.setOwner(this);
  65 }
  66
  67
  68 void InsetCollapsable::write(Buffer const & buf, ostream & os) const
  69 {
  70         os << "collapsed " << (status_ == Collapsed ? "true" : "false") << "\n";
  71         inset.text_.write(buf, os);
  72 }
  73
  74
  75 void InsetCollapsable::read(Buffer const & buf, LyXLex & lex)
  76 {
  77         if (lex.isOK()) {
  78                 lex.next();
  79                 string const token = lex.getString();
  80                 if (token == "collapsed") {
  81                         lex.next();
  82                         status_ = lex.getBool() ? Collapsed : Open;
  83                 } else {
  84                         lyxerr << "InsetCollapsable::Read: Missing collapsed!"
  85                                << endl;
  86                         // Take countermeasures
  87                         lex.pushToken(token);
  88                 }
  89         }
  90         inset.read(buf, lex);
  91 }
  92
  93
  94 void InsetCollapsable::dimension_collapsed(Dimension & dim) const
  95 {
  96         font_metrics::buttonText(label, labelfont_, dim.wid, dim.asc, dim.des);
  97 }
  98
  99
 100 int InsetCollapsable::height_collapsed() const
 101 {
 102         Dimension dim;
 103         font_metrics::buttonText(label, labelfont_, dim.wid, dim.asc, dim.des);
 104         return dim.asc + dim.des;
 105 }
 106
 107
 108 void InsetCollapsable::metrics(MetricsInfo & mi, Dimension & dim) const
 109 {
 110         //lyxerr << "InsetCollapsable::metrics:  width: " << mi.base.textwidth << endl;
 111         if (status_ == Inlined) {
 112                 inset.metrics(mi, dim);
 113         } else {
 114                 dimension_collapsed(dim);
 115                 if (status_ == Open) {
 116                         Dimension insetdim;
 117                         inset.metrics(mi, insetdim);
 118                         dim.des += insetdim.height() + TEXT_TO_BOTTOM_OFFSET;
 119                         dim.wid = max(dim.wid, insetdim.wid);
 120                 }
 121         }
 122         dim_ = dim;
 123         //lyxerr << "InsetCollapsable::metrics:  dim.wid: " << dim.wid << endl;
 124 }
 125
 126
 127 void InsetCollapsable::draw_collapsed(PainterInfo & pi, int x, int y) const
 128 {
 129         pi.pain.buttonText(x, y, label, labelfont_);
 130 }
 131
 132
 133 void InsetCollapsable::draw(PainterInfo & pi, int x, int y) const
 134 {
 135         xo_ = x;
 136         yo_ = y;
 137
 138         if (status_ == Inlined) {
 139                 inset.draw(pi, x, y);
 140         } else {
 141                 Dimension dimc;
 142                 dimension_collapsed(dimc);
 143
 144                 int const aa  = ascent();
 145                 button_dim.x1 = 0;
 146                 button_dim.x2 = dimc.width();
 147                 button_dim.y1 = -aa;
 148                 button_dim.y2 = -aa + dimc.height();
 149
 150                 draw_collapsed(pi, x, y);
 151                 if (status_ == Open) {
 152                         if (!owner())
 153                                 x += scroll();
 154                         inset.draw(pi, x, y - aa + dimc.height() + inset.ascent());
 155                 }
 156         }
 157 }
 158
 159
 160 InsetOld::EDITABLE InsetCollapsable::editable() const
 161 {
 162         return status_ != Collapsed ? HIGHLY_EDITABLE : IS_EDITABLE;
 163 }
 164
 165
 166 bool InsetCollapsable::descendable() const
 167 {
 168         return status_ != Collapsed;
 169 }
 170
 171
 172 FuncRequest InsetCollapsable::adjustCommand(FuncRequest const & cmd)
 173 {
 174         FuncRequest cmd1 = cmd;
 175         cmd1.y += ascent() - height_collapsed();
 176         return cmd1;
 177 }
 178
 179
 180 DispatchResult InsetCollapsable::lfunMouseRelease(FuncRequest const & cmd)
 181 {
 182         BufferView * bv = cmd.view();
 183
 184         if (cmd.button() == mouse_button::button3) {
 185                 lyxerr << "InsetCollapsable::lfunMouseRelease 0" << endl;
 186                 if (hitButton(cmd))
 187                         showInsetDialog(bv);
 188                 return DispatchResult(true, true);
 189         }
 190
 191         if (status_ == Collapsed) {
 192                 lyxerr << "InsetCollapsable::lfunMouseRelease 1" << endl;
 193                 setStatus(Open);
 194                 edit(bv, true);
 195                 return DispatchResult(true, true);
 196         }
 197
 198         if (hitButton(cmd)) {
 199                 if (status_ == Open) {
 200                         setStatus(Collapsed);
 201                         lyxerr << "InsetCollapsable::lfunMouseRelease 2" << endl;
 202                         return DispatchResult(false, FINISHED_RIGHT);
 203                 }
 204                 setStatus(Open);
 205                 lyxerr << "InsetCollapsable::lfunMouseRelease 3" << endl;
 206         } else if (status_ == Open && cmd.y > button_dim.y2) {
 207                 lyxerr << "InsetCollapsable::lfunMouseRelease 4" << endl;
 208                 return inset.dispatch(adjustCommand(cmd));
 209         }
 210
 211         lyxerr << "InsetCollapsable::lfunMouseRelease 5" << endl;
 212         return DispatchResult(true, true);
 213 }
 214
 215
 216 int InsetCollapsable::latex(Buffer const & buf, ostream & os,
 217                             OutputParams const & runparams) const
 218 {
 219         return inset.latex(buf, os, runparams);
 220 }
 221
 222
 223 int InsetCollapsable::plaintext(Buffer const & buf, ostream & os,
 224                             OutputParams const & runparams) const
 225 {
 226         return inset.plaintext(buf, os, runparams);
 227 }
 228
 229
 230 int InsetCollapsable::linuxdoc(Buffer const & buf, ostream & os,
 231                                OutputParams const & runparams) const
 232 {
 233         return inset.linuxdoc(buf, os, runparams);
 234 }
 235
 236
 237 int InsetCollapsable::docbook(Buffer const & buf, ostream & os,
 238                               OutputParams const & runparams) const
 239 {
 240         return inset.docbook(buf, os, runparams);
 241 }
 242
 243
 244 bool InsetCollapsable::hitButton(FuncRequest const & cmd) const
 245 {
 246         return button_dim.contains(cmd.x, cmd.y);
 247 }
 248
 249
 250 string const InsetCollapsable::getNewLabel(string const & l) const
 251 {
 252         string la;
 253         pos_type const max_length = 15;
 254         pos_type const p_siz = inset.paragraphs().begin()->size();
 255         pos_type const n = min(max_length, p_siz);
 256         pos_type i = 0;
 257         pos_type j = 0;
 258         for( ; i < n && j < p_siz; ++j) {
 259                 if (inset.paragraphs().begin()->isInset(j))
 260                         continue;
 261                 la += inset.paragraphs().begin()->getChar(j);
 262                 ++i;
 263         }
 264         if (inset.paragraphs().size() > 1 || (i > 0 && j < p_siz)) {
 265                 la += "...";
 266         }
 267         if (la.empty()) {
 268                 la = l;
 269         }
 270         return la;
 271 }
 272
 273
 274 void InsetCollapsable::edit(BufferView * bv, bool left)
 275 {
 276         lyxerr << "InsetCollapsable: edit left/right" << endl;
 277         inset.edit(bv, left);
 278         setStatus(Open);
 279         bv->cursor().push(this);
 280 }
 281
 282
 283 void InsetCollapsable::edit(BufferView * bv, int x, int y)
 284 {
 285         lyxerr << "InsetCollapsable: edit xy" << endl;
 286         if (status_ == Collapsed) {
 287                 setStatus(Open);
 288         } else {
 289                 if (y <= button_dim.y2)
 290                         y = 0;
 291                 else
 292                         y += inset.ascent() - height_collapsed();
 293         }
 294         inset.edit(bv, x, y);
 295         bv->cursor().push(this);
 296 }
 297
 298
 299 DispatchResult
 300 InsetCollapsable::priv_dispatch(FuncRequest const & cmd, idx_type &, pos_type &)
 301 {
 302         //lyxerr << "\nInsetCollapsable::priv_dispatch (begin): cmd: " << cmd
 303         //      << "  button y: " << button_dim.y2 << endl;
 304         switch (cmd.action) {
 305                 case LFUN_MOUSE_PRESS:
 306                         if (!status_ && cmd.y > button_dim.y2)
 307                                 inset.dispatch(adjustCommand(cmd));
 308                         return DispatchResult(true, true);
 309
 310                 case LFUN_MOUSE_MOTION:
 311                         if (!status_)
 312                                 inset.dispatch(adjustCommand(cmd));
 313                         return DispatchResult(true, true);
 314
 315                 case LFUN_MOUSE_RELEASE:
 316                         if (!status_ && cmd.y > button_dim.y2)
 317                                 inset.dispatch(adjustCommand(cmd));
 318                         else
 319                                 return lfunMouseRelease(cmd);
 320                         return DispatchResult(true, true);
 321
 322                 case LFUN_INSET_TOGGLE:
 323                         if (inset.text_.toggleInset())
 324                                 return DispatchResult(true, true);
 325                         close();
 326                         return DispatchResult(false, FINISHED_RIGHT);
 327
 328                 default:
 329                         return inset.dispatch(adjustCommand(cmd));
 330         }
 331         //lyxerr << "InsetCollapsable::priv_dispatch (end)" << endl;
 332 }
 333
 334
 335 void InsetCollapsable::validate(LaTeXFeatures & features) const
 336 {
 337         inset.validate(features);
 338 }
 339
 340
 341 void InsetCollapsable::getCursorPos(int & x, int & y) const
 342 {
 343         inset.getCursorPos(x, y);
 344         if (status_ != Inlined)
 345                 y += - ascent() + height_collapsed() + inset.ascent();
 346 }
 347
 348
 349 void InsetCollapsable::getLabelList(Buffer const & buffer,
 350                                     std::vector<string> & list) const
 351 {
 352         inset.getLabelList(buffer, list);
 353 }
 354
 355
 356 int InsetCollapsable::scroll(bool recursive) const
 357 {
 358         int sx = UpdatableInset::scroll(false);
 359
 360         if (recursive)
 361                 sx += inset.scroll(false);
 362
 363         return sx;
 364 }
 365
 366
 367 int InsetCollapsable::numParagraphs() const
 368 {
 369         return inset.numParagraphs();
 370 }
 371
 372
 373 LyXText * InsetCollapsable::getText(int i) const
 374 {
 375         return inset.getText(i);
 376 }
 377
 378
 379 void InsetCollapsable::open()
 380 {
 381         setStatus(Open);
 382 }
 383
 384
 385 void InsetCollapsable::close()
 386 {
 387         setStatus(Collapsed);
 388 }
 389
 390
 391 void InsetCollapsable::setLabel(string const & l) const
 392 {
 393         label = l;
 394 }
 395
 396
 397 void InsetCollapsable::setStatus(CollapseStatus s)
 398 {
 399         status_ = s;
 400 }
 401
 402
 403 void InsetCollapsable::markErased()
 404 {
 405         inset.markErased();
 406 }
 407
 408
 409 void InsetCollapsable::addPreview(PreviewLoader & loader) const
 410 {
 411         inset.addPreview(loader);
 412 }
 413
 414
 415 bool InsetCollapsable::insetAllowed(InsetOld::Code code) const
 416 {
 417         return inset.insetAllowed(code);
 418 }
 419
 420
 421 void InsetCollapsable::setLabelFont(LyXFont & f)
 422 {
 423         labelfont_ = f;
 424 }
 425
 426
 427 #if 0
 428 void InsetCollapsable::setAutoCollapse(bool f)
 429 {
 430         autocollapse = f;
 431 }
 432 #endif
 433
 434
 435 void InsetCollapsable::scroll(BufferView * bv, float sx) const
 436 {
 437         UpdatableInset::scroll(bv, sx);
 438 }
 439
 440
 441 void InsetCollapsable::scroll(BufferView * bv, int offset) const
 442 {
 443         UpdatableInset::scroll(bv, offset);
 444 }
 445
 446
 447 Box const & InsetCollapsable::buttonDim() const
 448 {
 449         return button_dim;
 450 }
 451
 452
 453 void InsetCollapsable::setBackgroundColor(LColor_color color)
 454 {
 455         InsetOld::setBackgroundColor(color);
 456         inset.setBackgroundColor(color);
 457 }