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 "debug.h"
  20 #include "LColor.h"
  21 #include "lyxlex.h"
  22 #include "funcrequest.h"
  23 #include "metricsinfo.h"
  24 #include "paragraph.h"
  25 #include "WordLangTuple.h"
  26
  27 #include "frontends/font_metrics.h"
  28 #include "frontends/Painter.h"
  29 #include "frontends/LyXView.h"
  30
  31
  32 using lyx::graphics::PreviewLoader;
  33
  34 using std::endl;
  35 using std::string;
  36 using std::max;
  37 using std::ostream;
  38
  39
  40 InsetCollapsable::InsetCollapsable(BufferParams const & bp, bool collapsed)
  41         : UpdatableInset(), inset(bp), collapsed_(collapsed),
  42           button_dim(0, 0, 0, 0), label("Label"),
  43 #if 0
  44         autocollapse(false),
  45 #endif
  46           in_update(false), first_after_edit(false)
  47 {
  48         inset.setOwner(this);
  49         inset.setAutoBreakRows(true);
  50         inset.setDrawFrame(InsetText::ALWAYS);
  51         inset.setFrameColor(LColor::collapsableframe);
  52         setInsetName("Collapsable");
  53 }
  54
  55
  56 InsetCollapsable::InsetCollapsable(InsetCollapsable const & in)
  57         : UpdatableInset(in), inset(in.inset), collapsed_(in.collapsed_),
  58           labelfont_(in.labelfont_), button_dim(0, 0, 0, 0), label(in.label),
  59 #if 0
  60           autocollapse(in.autocollapse),
  61 #endif
  62           in_update(false), first_after_edit(false)
  63 {
  64         inset.setOwner(this);
  65 }
  66
  67
  68 bool InsetCollapsable::insertInset(BufferView * bv, InsetOld * in)
  69 {
  70         if (!insetAllowed(in->lyxCode())) {
  71                 lyxerr << "InsetCollapsable::InsertInset: "
  72                         "Unable to insert inset." << endl;
  73                 return false;
  74         }
  75         return inset.insertInset(bv, in);
  76 }
  77
  78
  79 void InsetCollapsable::write(Buffer const & buf, ostream & os) const
  80 {
  81         os << "collapsed " << (collapsed_ ? "true" : "false") << "\n";
  82         inset.writeParagraphData(buf, os);
  83 }
  84
  85
  86 void InsetCollapsable::read(Buffer const & buf, LyXLex & lex)
  87 {
  88         if (lex.isOK()) {
  89                 lex.next();
  90                 string const token = lex.getString();
  91                 if (token == "collapsed") {
  92                         lex.next();
  93                         collapsed_ = lex.getBool();
  94                 } else {
  95                         lyxerr << "InsetCollapsable::Read: Missing collapsed!"
  96                                << endl;
  97                         // Take countermeasures
  98                         lex.pushToken(token);
  99                 }
 100         }
 101         inset.read(buf, lex);
 102 }
 103
 104
 105 void InsetCollapsable::dimension_collapsed(Dimension & dim) const
 106 {
 107         font_metrics::buttonText(label, labelfont_, dim.wid, dim.asc, dim.des);
 108 }
 109
 110
 111 int InsetCollapsable::height_collapsed() const
 112 {
 113         Dimension dim;
 114         font_metrics::buttonText(label, labelfont_, dim.wid, dim.asc, dim.des);
 115         return dim.asc + dim.des;
 116 }
 117
 118
 119 void InsetCollapsable::metrics(MetricsInfo & mi, Dimension & dim) const
 120 {
 121         //lyxerr << "InsetCollapsable::metrics:  width: " << mi.base.textwidth << endl;
 122         dimension_collapsed(dim);
 123         if (!collapsed_) {
 124                 Dimension insetdim;
 125                 inset.metrics(mi, insetdim);
 126                 dim.des += insetdim.height() + TEXT_TO_BOTTOM_OFFSET;
 127                 dim.wid = max(dim.wid, insetdim.wid);
 128         }
 129         dim_ = dim;
 130 }
 131
 132
 133 void InsetCollapsable::draw_collapsed(PainterInfo & pi, int x, int y) const
 134 {
 135         pi.pain.buttonText(x, y, label, labelfont_);
 136 }
 137
 138
 139 void InsetCollapsable::draw(PainterInfo & pi, int x, int y, bool inlined) const
 140 {
 141         Dimension dim_collapsed;
 142         dimension_collapsed(dim_collapsed);
 143
 144         int const aa  = ascent();
 145         button_dim.x1 = 0;
 146         button_dim.x2 = dim_collapsed.width();
 147         button_dim.y1 = -aa;
 148         button_dim.y2 = -aa + dim_collapsed.height();
 149
 150         if (!isOpen()) {
 151                 draw_collapsed(pi, x, y);
 152                 return;
 153         }
 154
 155         int old_x = x;
 156
 157         if (!owner())
 158                 x += scroll();
 159
 160         top_x = x;
 161         top_baseline = y;
 162
 163         int const bl = y - aa + dim_collapsed.ascent();
 164
 165         if (inlined) {
 166                 inset.draw(pi, x, y);
 167         } else {
 168                 draw_collapsed(pi, old_x, bl);
 169                 inset.draw(pi, x, bl + dim_collapsed.descent() + inset.ascent());
 170         }
 171 }
 172
 173
 174 void InsetCollapsable::draw(PainterInfo & pi, int x, int y) const
 175 {
 176         // by default, we are not inlined-drawing
 177         draw(pi, x, y, false);
 178 }
 179
 180
 181 InsetOld::EDITABLE InsetCollapsable::editable() const
 182 {
 183         return collapsed_ ? IS_EDITABLE : HIGHLY_EDITABLE;
 184 }
 185
 186
 187 void InsetCollapsable::insetUnlock(BufferView * bv)
 188 {
 189 #if 0
 190         if (autocollapse) {
 191                 if (change_label_with_text) {
 192                         draw_label = get_new_label();
 193                 } else {
 194                         draw_label = label;
 195                 }
 196                 collapsed_ = true;
 197         }
 198 #endif
 199         inset.insetUnlock(bv);
 200         if (scroll())
 201                 scroll(bv, 0.0F);
 202         bv->updateInset(this);
 203 }
 204
 205
 206 FuncRequest InsetCollapsable::adjustCommand(FuncRequest const & cmd)
 207 {
 208         FuncRequest cmd1 = cmd;
 209         cmd1.y = ascent() + cmd.y - (height_collapsed() + inset.ascent());
 210         return cmd1;
 211 }
 212
 213
 214 void InsetCollapsable::lfunMouseRelease(FuncRequest const & cmd)
 215 {
 216         bool ret = false;
 217         BufferView * bv = cmd.view();
 218
 219         if (collapsed_ && cmd.button() != mouse_button::button3) {
 220                 collapsed_ = false;
 221                 bv->updateInset(this);
 222                 bv->buffer()->markDirty();
 223                 return;
 224         }
 225
 226         if (cmd.button() != mouse_button::button3 && hitButton(cmd)) {
 227                 if (collapsed_) {
 228                         collapsed_ = false;
 229                 } else {
 230                         collapsed_ = true;
 231                         bv->unlockInset(this);
 232                 }
 233                 bv->updateInset(this);
 234                 bv->buffer()->markDirty();
 235         } else if (!collapsed_ && cmd.y > button_dim.y2) {
 236                 ret = inset.localDispatch(adjustCommand(cmd)) == DISPATCHED;
 237         }
 238         if (cmd.button() == mouse_button::button3 && !ret)
 239                 showInsetDialog(bv);
 240 }
 241
 242
 243 int InsetCollapsable::latex(Buffer const & buf, ostream & os,
 244                             LatexRunParams const & runparams) const
 245 {
 246         return inset.latex(buf, os, runparams);
 247 }
 248
 249
 250 int InsetCollapsable::ascii(Buffer const & buf, ostream & os, int ll) const
 251 {
 252         return inset.ascii(buf, os, ll);
 253 }
 254
 255
 256 int InsetCollapsable::linuxdoc(Buffer const & buf, ostream & os) const
 257 {
 258         return inset.linuxdoc(buf, os);
 259 }
 260
 261
 262 int InsetCollapsable::docbook(Buffer const & buf, ostream & os, bool mixcont) const
 263 {
 264         return inset.docbook(buf, os, mixcont);
 265 }
 266
 267
 268 bool InsetCollapsable::hitButton(FuncRequest const & cmd) const
 269 {
 270         return button_dim.contains(cmd.x, cmd.y);
 271 }
 272
 273
 274 void InsetCollapsable::edit(BufferView * bv, int index)
 275 {
 276         lyxerr << "InsetCollapsable: edit" << endl;
 277         if (!bv->lockInset(this))
 278                 lyxerr << "InsetCollapsable: can't lock index " << index << endl;
 279         inset.localDispatch(FuncRequest(bv, LFUN_INSET_EDIT, "left"));
 280         first_after_edit = true;
 281 }
 282
 283
 284 dispatch_result InsetCollapsable::localDispatch(FuncRequest const & cmd)
 285 {
 286         //lyxerr << "InsetCollapsable::localDispatch: "
 287         //      << cmd.action << " '" << cmd.argument << "'\n";
 288         BufferView * bv = cmd.view();
 289         switch (cmd.action) {
 290                 case LFUN_INSET_EDIT: {
 291                         if (!cmd.argument.empty()) {
 292                                 UpdatableInset::localDispatch(cmd);
 293                                 if (collapsed_) {
 294                                         lyxerr << "branch collapsed_" << endl;
 295                                         collapsed_ = false;
 296                                         if (bv->lockInset(this)) {
 297                                                 bv->updateInset(this);
 298                                                 bv->buffer()->markDirty();
 299                                                 inset.localDispatch(cmd);
 300                                                 first_after_edit = true;
 301                                         }
 302                                 } else {
 303                                         lyxerr << "branch not collapsed_" << endl;
 304                                         if (bv->lockInset(this))
 305                                                 inset.localDispatch(cmd);
 306                                 }
 307                                 return DISPATCHED;
 308                         }
 309
 310 #ifdef WITH_WARNINGS
 311 #warning Fix this properly in BufferView_pimpl::workAreaButtonRelease
 312 #endif
 313                         if (cmd.button() == mouse_button::button3)
 314                                 return DISPATCHED;
 315
 316                         UpdatableInset::localDispatch(cmd);
 317
 318                         if (collapsed_) {
 319                                 collapsed_ = false;
 320                                 // set this only here as it should be recollapsed only if
 321                                 // it was already collapsed!
 322                                 first_after_edit = true;
 323                                 if (!bv->lockInset(this))
 324                                         return DISPATCHED;
 325                                 bv->updateInset(this);
 326                                 bv->buffer()->markDirty();
 327                                 inset.localDispatch(cmd);
 328                         } else {
 329                                 if (!bv->lockInset(this))
 330                                         return DISPATCHED;
 331                                 if (cmd.y <= button_dim.y2) {
 332                                         FuncRequest cmd1 = cmd;
 333                                         cmd1.y = 0;
 334                                         inset.localDispatch(cmd1);
 335                                 } else
 336                                         inset.localDispatch(adjustCommand(cmd));
 337                         }
 338                         return DISPATCHED;
 339                 }
 340
 341                 case LFUN_MOUSE_PRESS:
 342                         if (!collapsed_ && cmd.y > button_dim.y2)
 343                                 inset.localDispatch(adjustCommand(cmd));
 344                         return DISPATCHED;
 345
 346                 case LFUN_MOUSE_MOTION:
 347                         if (!collapsed_ && cmd.y > button_dim.y2)
 348                                 inset.localDispatch(adjustCommand(cmd));
 349                         return DISPATCHED;
 350
 351                 case LFUN_MOUSE_RELEASE:
 352                         lfunMouseRelease(cmd);
 353                         return DISPATCHED;
 354
 355                 default:
 356                         dispatch_result result = inset.localDispatch(cmd);
 357                         if (result >= FINISHED)
 358                                 bv->unlockInset(this);
 359                         first_after_edit = false;
 360                         return result;
 361         }
 362 }
 363
 364
 365 bool InsetCollapsable::lockInsetInInset(BufferView * bv, UpdatableInset * in)
 366 {
 367         if (&inset == in)
 368                 return true;
 369         return inset.lockInsetInInset(bv, in);
 370 }
 371
 372
 373 bool InsetCollapsable::unlockInsetInInset(BufferView * bv, UpdatableInset * in,
 374                                           bool lr)
 375 {
 376         if (&inset == in) {
 377                 bv->unlockInset(this);
 378                 return true;
 379         }
 380         return inset.unlockInsetInInset(bv, in, lr);
 381 }
 382
 383
 384 int InsetCollapsable::insetInInsetY() const
 385 {
 386         return inset.insetInInsetY() - (top_baseline - inset.y());
 387 }
 388
 389
 390 void InsetCollapsable::validate(LaTeXFeatures & features) const
 391 {
 392         inset.validate(features);
 393 }
 394
 395
 396 void InsetCollapsable::getCursor(BufferView & bv, int & x, int & y) const
 397 {
 398         inset.getCursor(bv, x, y);
 399 }
 400
 401
 402 void InsetCollapsable::getCursorPos(BufferView * bv, int & x, int & y) const
 403 {
 404         inset.getCursorPos(bv, x , y);
 405 }
 406
 407
 408 UpdatableInset * InsetCollapsable::getLockingInset() const
 409 {
 410         UpdatableInset * in = inset.getLockingInset();
 411         if (&inset == in)
 412                 return const_cast<InsetCollapsable *>(this);
 413         return in;
 414 }
 415
 416
 417 UpdatableInset * InsetCollapsable::getFirstLockingInsetOfType(InsetOld::Code c)
 418 {
 419         if (c == lyxCode())
 420                 return this;
 421         return inset.getFirstLockingInsetOfType(c);
 422 }
 423
 424
 425 void InsetCollapsable::setFont(BufferView * bv, LyXFont const & font,
 426                                bool toggleall, bool selectall)
 427 {
 428         inset.setFont(bv, font, toggleall, selectall);
 429 }
 430
 431
 432 LyXText * InsetCollapsable::getLyXText(BufferView const * bv,
 433                                        bool const recursive) const
 434 {
 435         return inset.getLyXText(bv, recursive);
 436 }
 437
 438
 439 void InsetCollapsable::deleteLyXText(BufferView * bv, bool recursive) const
 440 {
 441         inset.deleteLyXText(bv, recursive);
 442 }
 443
 444
 445 void InsetCollapsable::getLabelList(Buffer const & buffer,
 446                                     std::vector<string> & list) const
 447 {
 448         inset.getLabelList(buffer, list);
 449 }
 450
 451
 452 int InsetCollapsable::scroll(bool recursive) const
 453 {
 454         int sx = UpdatableInset::scroll(false);
 455
 456         if (recursive)
 457                 sx += inset.scroll(recursive);
 458
 459         return sx;
 460 }
 461
 462
 463 ParagraphList * InsetCollapsable::getParagraphs(int i) const
 464 {
 465         return inset.getParagraphs(i);
 466 }
 467
 468
 469 LyXText * InsetCollapsable::getText(int i) const
 470 {
 471         return inset.getText(i);
 472 }
 473
 474
 475 LyXCursor const & InsetCollapsable::cursor(BufferView * bv) const
 476 {
 477         return inset.cursor(bv);
 478 }
 479
 480
 481 InsetOld * InsetCollapsable::getInsetFromID(int id_arg) const
 482 {
 483         if (id_arg == id())
 484                 return const_cast<InsetCollapsable *>(this);
 485         return inset.getInsetFromID(id_arg);
 486 }
 487
 488
 489 void InsetCollapsable::open(BufferView * bv)
 490 {
 491         if (!collapsed_)
 492                 return;
 493
 494         collapsed_ = false;
 495         bv->updateInset(this);
 496 }
 497
 498
 499 void InsetCollapsable::close(BufferView * bv) const
 500 {
 501         if (collapsed_)
 502                 return;
 503
 504         collapsed_ = true;
 505         bv->updateInset(this);
 506 }
 507
 508
 509 void InsetCollapsable::setLabel(string const & l) const
 510 {
 511         label = l;
 512 }
 513
 514
 515 void InsetCollapsable::setCollapsed(bool c) const
 516 {
 517         collapsed_ = c;
 518 }
 519
 520
 521 void InsetCollapsable::markErased()
 522 {
 523         inset.markErased();
 524 }
 525
 526
 527 bool InsetCollapsable::nextChange(BufferView * bv, lyx::pos_type & length)
 528 {
 529         bool found = inset.nextChange(bv, length);
 530
 531         if (first_after_edit && !found)
 532                 close(bv);
 533         else if (!found)
 534                 first_after_edit = false;
 535         return found;
 536 }
 537
 538
 539 bool InsetCollapsable::searchForward(BufferView * bv, string const & str,
 540                                      bool cs, bool mw)
 541 {
 542         bool found = inset.searchForward(bv, str, cs, mw);
 543         if (first_after_edit && !found)
 544                 close(bv);
 545         else if (!found)
 546                 first_after_edit = false;
 547         return found;
 548 }
 549
 550
 551 bool InsetCollapsable::searchBackward(BufferView * bv, string const & str,
 552                                       bool cs, bool mw)
 553 {
 554         bool found = inset.searchBackward(bv, str, cs, mw);
 555         if (first_after_edit && !found)
 556                 close(bv);
 557         else if (!found)
 558                 first_after_edit = false;
 559         return found;
 560 }
 561
 562
 563 WordLangTuple const
 564 InsetCollapsable::selectNextWordToSpellcheck(BufferView * bv, float & value) const
 565 {
 566         WordLangTuple word = inset.selectNextWordToSpellcheck(bv, value);
 567         if (first_after_edit && word.word().empty())
 568                 close(bv);
 569         first_after_edit = false;
 570         return word;
 571 }
 572
 573
 574 void InsetCollapsable::addPreview(PreviewLoader & loader) const
 575 {
 576         inset.addPreview(loader);
 577 }