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::ostream;
  39
  40
  41 InsetCollapsable::InsetCollapsable(BufferParams const & bp, bool collapsed)
  42         : UpdatableInset(), inset(bp), collapsed_(collapsed), label("Label")
  43 #if 0
  44         ,autocollapse(false)
  45 #endif
  46 {
  47         inset.setOwner(this);
  48         inset.setAutoBreakRows(true);
  49         inset.setDrawFrame(InsetText::ALWAYS);
  50         inset.setFrameColor(LColor::collapsableframe);
  51         setInsetName("Collapsable");
  52 }
  53
  54
  55 InsetCollapsable::InsetCollapsable(InsetCollapsable const & in)
  56         : UpdatableInset(in), inset(in.inset), collapsed_(in.collapsed_),
  57           labelfont_(in.labelfont_), label(in.label)
  58 #if 0
  59           ,autocollapse(in.autocollapse)
  60 #endif
  61 {
  62         inset.setOwner(this);
  63 }
  64
  65
  66 bool InsetCollapsable::insertInset(BufferView * bv, InsetOld * in)
  67 {
  68         if (!insetAllowed(in->lyxCode())) {
  69                 lyxerr << "InsetCollapsable::InsertInset: "
  70                         "Unable to insert inset." << endl;
  71                 return false;
  72         }
  73         return inset.insertInset(bv, in);
  74 }
  75
  76
  77 void InsetCollapsable::write(Buffer const & buf, ostream & os) const
  78 {
  79         os << "collapsed " << (collapsed_ ? "true" : "false") << "\n";
  80         inset.writeParagraphData(buf, os);
  81 }
  82
  83
  84 void InsetCollapsable::read(Buffer const & buf, LyXLex & lex)
  85 {
  86         if (lex.isOK()) {
  87                 lex.next();
  88                 string const token = lex.getString();
  89                 if (token == "collapsed") {
  90                         lex.next();
  91                         collapsed_ = lex.getBool();
  92                 } else {
  93                         lyxerr << "InsetCollapsable::Read: Missing collapsed!"
  94                                << endl;
  95                         // Take countermeasures
  96                         lex.pushToken(token);
  97                 }
  98         }
  99         inset.read(buf, lex);
 100 }
 101
 102
 103 void InsetCollapsable::dimension_collapsed(Dimension & dim) const
 104 {
 105         font_metrics::buttonText(label, labelfont_, dim.wid, dim.asc, dim.des);
 106 }
 107
 108
 109 int InsetCollapsable::height_collapsed() const
 110 {
 111         Dimension dim;
 112         font_metrics::buttonText(label, labelfont_, dim.wid, dim.asc, dim.des);
 113         return dim.asc + dim.des;
 114 }
 115
 116
 117 void InsetCollapsable::metrics(MetricsInfo & mi, Dimension & dim) const
 118 {
 119         //lyxerr << "InsetCollapsable::metrics:  width: " << mi.base.textwidth << endl;
 120         dimension_collapsed(dim);
 121         if (!collapsed_) {
 122                 Dimension insetdim;
 123                 inset.metrics(mi, insetdim);
 124                 dim.des += insetdim.height() + TEXT_TO_BOTTOM_OFFSET;
 125                 dim.wid = max(dim.wid, insetdim.wid);
 126         }
 127         dim_ = dim;
 128         //lyxerr << "InsetCollapsable::metrics:  dim.wid: " << dim.wid << endl;
 129 }
 130
 131
 132 void InsetCollapsable::draw_collapsed(PainterInfo & pi, int x, int y) const
 133 {
 134         pi.pain.buttonText(x, y, label, labelfont_);
 135 }
 136
 137
 138 void InsetCollapsable::draw(PainterInfo & pi, int x, int y, bool inlined) const
 139 {
 140         Dimension dim_collapsed;
 141         dimension_collapsed(dim_collapsed);
 142
 143         int const aa  = ascent();
 144         button_dim.x1 = 0;
 145         button_dim.x2 = dim_collapsed.width();
 146         button_dim.y1 = -aa;
 147         button_dim.y2 = -aa + dim_collapsed.height();
 148
 149         top_x = x;
 150         top_baseline = y;
 151
 152         if (!isOpen()) {
 153                 draw_collapsed(pi, x, y);
 154                 return;
 155         }
 156
 157         int old_x = x;
 158
 159         if (!owner())
 160                 x += scroll();
 161
 162         if (inlined) {
 163                 inset.draw(pi, x, y);
 164         } else {
 165                 int const bl = y - aa + dim_collapsed.ascent();
 166                 draw_collapsed(pi, old_x, bl);
 167                 inset.draw(pi, x, bl + dim_collapsed.descent() + inset.ascent());
 168         }
 169 }
 170
 171
 172 void InsetCollapsable::draw(PainterInfo & pi, int x, int y) const
 173 {
 174         // by default, we are not inlined-drawing
 175         draw(pi, x, y, false);
 176 }
 177
 178
 179 InsetOld::EDITABLE InsetCollapsable::editable() const
 180 {
 181         return collapsed_ ? IS_EDITABLE : HIGHLY_EDITABLE;
 182 }
 183
 184
 185 FuncRequest InsetCollapsable::adjustCommand(FuncRequest const & cmd)
 186 {
 187         FuncRequest cmd1 = cmd;
 188         cmd1.y = ascent() + cmd.y - height_collapsed() - inset.ascent();
 189         return cmd1;
 190 }
 191
 192
 193 DispatchResult InsetCollapsable::lfunMouseRelease(FuncRequest const & cmd)
 194 {
 195         DispatchResult result(true, true);
 196         BufferView * bv = cmd.view();
 197
 198         if (cmd.button() == mouse_button::button3) {
 199                 lyxerr << "InsetCollapsable::lfunMouseRelease 0" << endl;
 200                 if (hitButton(cmd))
 201                         showInsetDialog(bv);
 202         } else {
 203                 if (collapsed_) {
 204                         lyxerr << "InsetCollapsable::lfunMouseRelease 1" << endl;
 205                         collapsed_ = false;
 206                         edit(bv, true);
 207                         bv->buffer()->markDirty();
 208                         bv->updateInset(this);
 209                         bv->update();
 210                         return result;
 211                 }
 212
 213                 if (hitButton(cmd)) {
 214                         if (collapsed_) {
 215                                 lyxerr << "InsetCollapsable::lfunMouseRelease 2" << endl;
 216                                 collapsed_ = false;
 217                         } else {
 218                                 collapsed_ = true;
 219                                 result.update(true);
 220                                 result.val(FINISHED_RIGHT);
 221                                 return result;
 222                         }
 223                         result.update(true);
 224                         bv->updateInset(this);
 225                         bv->buffer()->markDirty();
 226                 } else if (!collapsed_ && cmd.y > button_dim.y2) {
 227                         lyxerr << "InsetCollapsable::lfunMouseRelease 3" << endl;
 228                         result = inset.dispatch(adjustCommand(cmd));
 229                 }
 230         }
 231         lyxerr << "InsetCollapsable::lfunMouseRelease 4" << endl;
 232         return result;
 233 }
 234
 235
 236 int InsetCollapsable::latex(Buffer const & buf, ostream & os,
 237                             OutputParams const & runparams) const
 238 {
 239         return inset.latex(buf, os, runparams);
 240 }
 241
 242
 243 int InsetCollapsable::plaintext(Buffer const & buf, ostream & os,
 244                             OutputParams const & runparams) const
 245 {
 246         return inset.plaintext(buf, os, runparams);
 247 }
 248
 249
 250 int InsetCollapsable::linuxdoc(Buffer const & buf, ostream & os,
 251                                OutputParams const & runparams) const
 252 {
 253         return inset.linuxdoc(buf, os, runparams);
 254 }
 255
 256
 257 int InsetCollapsable::docbook(Buffer const & buf, ostream & os,
 258                               OutputParams const & runparams) const
 259 {
 260         return inset.docbook(buf, os, runparams);
 261 }
 262
 263
 264 bool InsetCollapsable::hitButton(FuncRequest const & cmd) const
 265 {
 266         return button_dim.contains(cmd.x, cmd.y);
 267 }
 268
 269
 270 void InsetCollapsable::edit(BufferView * bv, bool left)
 271 {
 272         lyxerr << "InsetCollapsable: edit left/right" << endl;
 273         bv->cursor().push(this);
 274         inset.edit(bv, left);
 275         open(bv);
 276 }
 277
 278
 279 void InsetCollapsable::edit(BufferView * bv, int x, int y)
 280 {
 281         lyxerr << "InsetCollapsable: edit xy" << endl;
 282         if (collapsed_) {
 283                 collapsed_ = false;
 284                 // set this only here as it should be recollapsed only if
 285                 // it was already collapsed!
 286                 bv->updateInset(this);
 287                 bv->buffer()->markDirty();
 288                 inset.edit(bv, x, y);
 289         } else {
 290                 if (y <= button_dim.y2)
 291                         inset.edit(bv, x, 0);
 292                 else
 293                         inset.edit(bv, x,
 294                                 ascent() + y - height_collapsed() + inset.ascent());
 295         }
 296         bv->cursor().push(this);
 297 }
 298
 299
 300 DispatchResult
 301 InsetCollapsable::priv_dispatch(FuncRequest const & cmd, idx_type &, pos_type &)
 302 {
 303         lyxerr << "\nInsetCollapsable::priv_dispatch (begin): cmd: " << cmd
 304                 << "  button y: " << button_dim.y2 << endl;
 305         switch (cmd.action) {
 306                 case LFUN_MOUSE_PRESS:
 307                         if (!collapsed_ && cmd.y > button_dim.y2)
 308                                 inset.dispatch(adjustCommand(cmd));
 309                         return DispatchResult(true, true);
 310
 311                 case LFUN_MOUSE_MOTION:
 312                         if (!collapsed_ && cmd.y > button_dim.y2)
 313                                 inset.dispatch(adjustCommand(cmd));
 314                         return DispatchResult(true, true);
 315
 316                 case LFUN_MOUSE_RELEASE:
 317                         if (!collapsed_ && cmd.y > button_dim.y2)
 318                                 inset.dispatch(adjustCommand(cmd));
 319                         else
 320                                 return lfunMouseRelease(cmd);
 321                         return DispatchResult(true, true);
 322
 323                 default:
 324                         return inset.dispatch(cmd);
 325         }
 326         lyxerr << "InsetCollapsable::priv_dispatch (end)" << endl;
 327 }
 328
 329
 330 int InsetCollapsable::insetInInsetY() const
 331 {
 332         return inset.y() - top_baseline + inset.insetInInsetY();
 333 }
 334
 335
 336 void InsetCollapsable::validate(LaTeXFeatures & features) const
 337 {
 338         inset.validate(features);
 339 }
 340
 341
 342 void InsetCollapsable::getCursorPos(BufferView * bv, int & x, int & y) const
 343 {
 344         inset.getCursorPos(bv, x , y);
 345         y += - ascent() + height_collapsed() + inset.ascent();
 346 }
 347
 348
 349 void InsetCollapsable::setFont(BufferView * bv, LyXFont const & font,
 350                                bool toggleall, bool selectall)
 351 {
 352         inset.setFont(bv, font, toggleall, selectall);
 353 }
 354
 355
 356 void InsetCollapsable::deleteLyXText(BufferView * bv, bool recursive) const
 357 {
 358         inset.deleteLyXText(bv, recursive);
 359 }
 360
 361
 362 void InsetCollapsable::getLabelList(Buffer const & buffer,
 363                                     std::vector<string> & list) const
 364 {
 365         inset.getLabelList(buffer, list);
 366 }
 367
 368
 369 int InsetCollapsable::scroll(bool recursive) const
 370 {
 371         int sx = UpdatableInset::scroll(false);
 372
 373         if (recursive)
 374                 sx += inset.scroll(recursive);
 375
 376         return sx;
 377 }
 378
 379
 380 ParagraphList * InsetCollapsable::getParagraphs(int i) const
 381 {
 382         return inset.getParagraphs(i);
 383 }
 384
 385
 386 int InsetCollapsable::numParagraphs() const
 387 {
 388         return inset.numParagraphs();
 389 }
 390
 391
 392 LyXText * InsetCollapsable::getText(int i) const
 393 {
 394         return inset.getText(i);
 395 }
 396
 397
 398 void InsetCollapsable::open(BufferView * bv)
 399 {
 400         if (!collapsed_)
 401                 return;
 402
 403         collapsed_ = false;
 404         bv->updateInset(this);
 405 }
 406
 407
 408 void InsetCollapsable::close(BufferView * bv) const
 409 {
 410         if (collapsed_)
 411                 return;
 412
 413         collapsed_ = true;
 414         bv->updateInset(this);
 415 }
 416
 417
 418 void InsetCollapsable::setLabel(string const & l) const
 419 {
 420         label = l;
 421 }
 422
 423
 424 void InsetCollapsable::setCollapsed(bool c) const
 425 {
 426         collapsed_ = c;
 427 }
 428
 429
 430 void InsetCollapsable::markErased()
 431 {
 432         inset.markErased();
 433 }
 434
 435
 436 void InsetCollapsable::addPreview(PreviewLoader & loader) const
 437 {
 438         inset.addPreview(loader);
 439 }
 440
 441
 442 bool InsetCollapsable::insetAllowed(InsetOld::Code code) const
 443 {
 444         return inset.insetAllowed(code);
 445 }
 446
 447
 448 void InsetCollapsable::fitInsetCursor(BufferView * bv) const
 449 {
 450         inset.fitInsetCursor(bv);
 451 }
 452
 453
 454 void InsetCollapsable::setLabelFont(LyXFont & f)
 455 {
 456         labelfont_ = f;
 457 }
 458
 459 #if 0
 460 void InsetCollapsable::setAutoCollapse(bool f)
 461 {
 462         autocollapse = f;
 463 }
 464 #endif
 465
 466 void InsetCollapsable::scroll(BufferView *bv, float sx) const
 467 {
 468         UpdatableInset::scroll(bv, sx);
 469 }
 470
 471
 472 void InsetCollapsable::scroll(BufferView *bv, int offset) const
 473 {
 474         UpdatableInset::scroll(bv, offset);
 475 }
 476
 477
 478 bool InsetCollapsable::isOpen() const
 479 {
 480         return !collapsed_;
 481 }
 482
 483
 484 Box const & InsetCollapsable::buttonDim() const
 485 {
 486         return button_dim;
 487 }
 488