src/insets/insetcollapsable.C

   1 /* This file is part of
   2  * ======================================================
   3  *
   4  *           LyX, The Document Processor
   5  *
   6  *          Copyright 1998-2001 The LyX Team.
   7  *
   8  * ======================================================
   9  */
  10
  11 #include <config.h>
  12
  13 #ifdef __GNUG__
  14 #pragma implementation
  15 #endif
  16
  17 #include "insetcollapsable.h"
  18 #include "gettext.h"
  19 #include "lyxfont.h"
  20 #include "BufferView.h"
  21 #include "Painter.h"
  22 #include "insets/insettext.h"
  23 #include "support/LOstream.h"
  24 #include "support/lstrings.h"
  25 #include "debug.h"
  26 #include "lyxtext.h"
  27
  28 class LyXText;
  29
  30 using std::ostream;
  31 using std::endl;
  32 using std::max;
  33
  34
  35 InsetCollapsable::InsetCollapsable()
  36         : UpdatableInset()
  37 {
  38         inset.setOwner(this);
  39         collapsed = false;
  40         label = "Label";
  41         autocollapse = true;
  42         inset.SetAutoBreakRows(true);
  43         inset.SetDrawFrame(0, InsetText::ALWAYS);
  44         inset.SetFrameColor(0, LColor::footnoteframe);
  45         button_length = button_top_y = button_bottom_y = 0;
  46         setInsetName("Collapsable");
  47         widthCollapsed = oldWidth = 0;
  48         need_update = FULL;
  49 }
  50
  51
  52 #if 0
  53 Inset * InsetCollapsable::Clone(Buffer const &) const
  54 {
  55         InsetCollapsable * result = new InsetCollapsable;
  56         result->inset.init(&inset);
  57         result->inset.setOwner(result);
  58
  59         result->collapsed = collapsed;
  60         return result;
  61 }
  62 #endif
  63
  64
  65 bool InsetCollapsable::InsertInset(BufferView * bv, Inset * in)
  66 {
  67         if (!InsertInsetAllowed(in)) {
  68                 lyxerr << "InsetCollapsable::InsertInset: "
  69                         "Unable to insert inset." << endl;
  70                 return false;
  71         }
  72         return inset.InsertInset(bv, in);
  73 }
  74
  75
  76 void InsetCollapsable::Write(Buffer const * buf, ostream & os) const
  77 {
  78         os << "collapsed " << tostr(collapsed) << "\n";
  79         inset.WriteParagraphData(buf, os);
  80 }
  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                 }
  96         }
  97         inset.Read(buf, lex);
  98 }
  99
 100
 101 int InsetCollapsable::ascent_collapsed(Painter & pain, LyXFont const &) const
 102 {
 103         int width = 0;
 104         int ascent = 0;
 105         int descent = 0;
 106         pain.buttonText(0, 0, label, labelfont, false,
 107                         width, ascent, descent);
 108         return ascent;
 109 }
 110
 111
 112 int InsetCollapsable::descent_collapsed(Painter & pain, LyXFont const &) const
 113 {
 114         int width = 0;
 115         int ascent = 0;
 116         int descent = 0;
 117         pain.buttonText(0, 0, label, labelfont, false,
 118                         width, ascent, descent);
 119         return descent;
 120 }
 121
 122
 123 int InsetCollapsable::width_collapsed(Painter & pain, LyXFont const &) const
 124 {
 125         int width;
 126         int ascent;
 127         int descent;
 128         pain.buttonText(TEXT_TO_INSET_OFFSET, 0, label, labelfont, false,
 129                         width, ascent, descent);
 130         return width + (2*TEXT_TO_INSET_OFFSET);
 131 }
 132
 133
 134 int InsetCollapsable::ascent(BufferView * bv, LyXFont const & font) const
 135 {
 136         return ascent_collapsed(bv->painter(), font);
 137 }
 138
 139
 140 int InsetCollapsable::descent(BufferView * bv, LyXFont const & font) const
 141 {
 142         if (collapsed)
 143                 return descent_collapsed(bv->painter(), font);
 144
 145         return descent_collapsed(bv->painter(), font)
 146                 + inset.descent(bv, font)
 147                 + inset.ascent(bv, font)
 148                 + TEXT_TO_BOTTOM_OFFSET;
 149 }
 150
 151
 152 int InsetCollapsable::width(BufferView * bv, LyXFont const & font) const
 153 {
 154         if (collapsed)
 155                 return widthCollapsed;
 156
 157         return (inset.width(bv, font) > widthCollapsed) ?
 158                 inset.width(bv, font) : widthCollapsed;
 159 }
 160
 161
 162 void InsetCollapsable::draw_collapsed(Painter & pain, LyXFont const &,
 163                                       int baseline, float & x) const
 164 {
 165         int width = 0;
 166         pain.buttonText(int(x) + TEXT_TO_INSET_OFFSET,
 167                         baseline, label, labelfont, true, width);
 168         x += width + TEXT_TO_INSET_OFFSET;
 169 }
 170
 171
 172 void InsetCollapsable::draw(BufferView * bv, LyXFont const & f,
 173                             int baseline, float & x, bool cleared) const
 174 {
 175         if (nodraw())
 176                 return;
 177
 178         Painter & pain = bv->painter();
 179
 180         button_length = widthCollapsed;
 181         button_top_y = -ascent(bv, f);
 182         button_bottom_y = -ascent(bv, f) + ascent_collapsed(pain,f) +
 183                 descent_collapsed(pain, f);
 184
 185         if (collapsed) {
 186                 draw_collapsed(pain, f, baseline, x);
 187                 x += TEXT_TO_INSET_OFFSET;
 188                 return;
 189         }
 190
 191         float old_x = x;
 192
 193 #if 0
 194         UpdatableInset::draw(bv, f, baseline, x, cleared);
 195 #else
 196         if (!owner())
 197                 x += static_cast<float>(scroll());
 198 #endif
 199         if (!cleared && (inset.need_update == InsetText::FULL ||
 200                          inset.need_update == InsetText::INIT ||
 201                          top_x != int(x) ||
 202                          top_baseline != baseline))
 203         {
 204 #if 1
 205                 // we don't need anymore to clear here we just have to tell
 206                 // the underlying LyXText that it should do the RowClear!
 207                 inset.SetUpdateStatus(bv, InsetText::FULL);
 208                 bv->text->status = LyXText::CHANGED_IN_DRAW;
 209                 return;
 210 #else
 211                 int w =  owner() ? width(bv, f) : pain.paperWidth();
 212                 int h = ascent(bv, f) + descent(bv, f);
 213                 int const tx = (needFullRow() && !owner()) ? 0 : int(x);
 214                 int const ty = max(0, baseline - ascent(bv, f));
 215
 216                 if ((ty + h) > pain.paperHeight())
 217                         h = pain.paperHeight();
 218                 if ((top_x + w) > pain.paperWidth())
 219                         w = pain.paperWidth();
 220                 if (baseline < 0)
 221                         h += (baseline - ascent(bv, f));
 222                 pain.fillRectangle(tx, ty - 1, w, h + 2);
 223                 cleared = true;
 224 #endif
 225         }
 226
 227         top_x = int(x);
 228         top_baseline = baseline;
 229
 230         int const bl = baseline - ascent(bv, f) + ascent_collapsed(pain, f);
 231
 232         draw_collapsed(pain, f, bl, old_x);
 233         inset.draw(bv, f,
 234                    bl + descent_collapsed(pain, f) + inset.ascent(bv, f),
 235                    x, cleared);
 236         need_update = NONE;
 237 }
 238
 239
 240 void InsetCollapsable::Edit(BufferView * bv, int xp, int yp,
 241                             unsigned int button)
 242 {
 243         UpdatableInset::Edit(bv, xp, yp, button);
 244
 245         if (collapsed && autocollapse) {
 246                 collapsed = false;
 247                 if (!bv->lockInset(this))
 248                         return;
 249                 bv->updateInset(this, false);
 250                 inset.Edit(bv, 0, 0, button);
 251         } else if (!collapsed) {
 252                 if (!bv->lockInset(this))
 253                         return;
 254                 inset.Edit(bv, xp, yp+(top_baseline - inset.y()), button);
 255         }
 256 }
 257
 258
 259 Inset::EDITABLE InsetCollapsable::Editable() const
 260 {
 261         if (collapsed)
 262                 return IS_EDITABLE;
 263         return HIGHLY_EDITABLE;
 264 }
 265
 266
 267 void InsetCollapsable::InsetUnlock(BufferView * bv)
 268 {
 269         if (autocollapse) {
 270                 collapsed = true;
 271         }
 272         inset.InsetUnlock(bv);
 273         if (scroll())
 274                 scroll(bv, 0.0F);
 275         bv->updateInset(this, false);
 276 }
 277
 278
 279 void InsetCollapsable::InsetButtonPress(BufferView * bv, int x, int y,
 280                                         int button)
 281 {
 282         if (!collapsed && (y > button_bottom_y)) {
 283                 inset.InsetButtonPress(bv, x, y + (top_baseline - inset.y()),
 284                                        button);
 285         }
 286 }
 287
 288
 289 void InsetCollapsable::InsetButtonRelease(BufferView * bv,
 290                                           int x, int y, int button)
 291 {
 292         if ((x >= 0)  && (x < button_length) &&
 293             (y >= button_top_y) &&  (y <= button_bottom_y)) {
 294                 if (collapsed) {
 295                         collapsed = false;
 296                         inset.InsetButtonRelease(bv, 0, 0, button);
 297                         bv->updateInset(this, false);
 298                 } else {
 299                         collapsed = true;
 300                         bv->unlockInset(this);
 301                         bv->updateInset(this, false);
 302                 }
 303         } else if (!collapsed && (y > button_top_y)) {
 304                 inset.InsetButtonRelease(bv, x, y + (top_baseline-inset.y()),
 305                                          button);
 306         }
 307 }
 308
 309
 310 void InsetCollapsable::InsetMotionNotify(BufferView * bv,
 311                                          int x, int y, int state)
 312 {
 313         if (x > button_bottom_y) {
 314                 inset.InsetMotionNotify(bv, x, y + (top_baseline - inset.y()),
 315                                         state);
 316         }
 317 }
 318
 319
 320 void InsetCollapsable::InsetKeyPress(XKeyEvent * xke)
 321 {
 322         inset.InsetKeyPress(xke);
 323 }
 324
 325
 326 int InsetCollapsable::Latex(Buffer const * buf, ostream & os,
 327                             bool fragile, bool free_spc) const
 328 {
 329         return inset.Latex(buf, os, fragile, free_spc);
 330 }
 331
 332
 333 int InsetCollapsable::getMaxWidth(BufferView * bv,
 334                                   UpdatableInset const * inset) const
 335 {
 336         int const w = UpdatableInset::getMaxWidth(bv, inset);
 337
 338         if (w < 0) {
 339                 // What does a negative max width signify? (Lgb)
 340                 // Use the max width of the draw-area (Jug)
 341                 return w;
 342         }
 343         // should be at least 30 pixels !!!
 344         return max(30, w - widthCollapsed);
 345 }
 346
 347
 348 void InsetCollapsable::update(BufferView * bv, LyXFont const & font,
 349                               bool reinit)
 350 {
 351         if (reinit) {
 352                 need_update = FULL;
 353                 if (owner())
 354                         owner()->update(bv, font, true);
 355                 return;
 356         }
 357         if (!widthCollapsed) {
 358                 widthCollapsed = width_collapsed(bv->painter(), font);
 359                 inset.resizeLyXText(bv);
 360                 need_update = FULL;
 361                 if (owner()) {
 362                         owner()->update(bv, font);
 363                         return;
 364                 }
 365         }
 366         if (oldWidth != width(bv, font)) {
 367                 oldWidth = width(bv, font);
 368                 inset.resizeLyXText(bv);
 369                 need_update = FULL;
 370                 if (owner()) {
 371                         owner()->update(bv, font);
 372                         return;
 373                 }
 374         }
 375         inset.update(bv, font);
 376 }
 377
 378
 379 UpdatableInset::RESULT
 380 InsetCollapsable::LocalDispatch(BufferView * bv, kb_action action,
 381                                 string const & arg)
 382 {
 383         UpdatableInset::RESULT result = inset.LocalDispatch(bv, action, arg);
 384         if (result == FINISHED)
 385                 bv->unlockInset(this);
 386         return result;
 387 }
 388
 389
 390 bool InsetCollapsable::LockInsetInInset(BufferView * bv, UpdatableInset * in)
 391 {
 392         if (&inset == in)
 393                 return true;
 394         return inset.LockInsetInInset(bv, in);
 395 }
 396
 397
 398 bool InsetCollapsable::UnlockInsetInInset(BufferView * bv, UpdatableInset * in,
 399                                           bool lr)
 400 {
 401         if (&inset == in) {
 402                 bv->unlockInset(this);
 403                 return true;
 404         }
 405         bool ret = inset.UnlockInsetInInset(bv, in, lr);
 406         return ret;
 407 }
 408
 409
 410 bool InsetCollapsable::UpdateInsetInInset(BufferView * bv, Inset *in)
 411 {
 412         if (&inset == in)
 413                 return true;
 414         return inset.UpdateInsetInInset(bv, in);
 415 }
 416
 417
 418 unsigned int InsetCollapsable::InsetInInsetY()
 419 {
 420         return inset.InsetInInsetY() - (top_baseline - inset.y());
 421 }
 422
 423
 424 void InsetCollapsable::Validate(LaTeXFeatures & features) const
 425 {
 426         inset.Validate(features);
 427 }
 428
 429
 430 void InsetCollapsable::GetCursorPos(BufferView * bv, int & x, int & y) const
 431 {
 432         inset.GetCursorPos(bv, x , y);
 433 }
 434
 435
 436 void InsetCollapsable::ToggleInsetCursor(BufferView * bv)
 437 {
 438         inset.ToggleInsetCursor(bv);
 439 }
 440
 441
 442 UpdatableInset * InsetCollapsable::GetLockingInset()
 443 {
 444         UpdatableInset * in = inset.GetLockingInset();
 445         if (&inset == in)
 446                 return this;
 447         return in;
 448 }
 449
 450
 451 UpdatableInset * InsetCollapsable::GetFirstLockingInsetOfType(Inset::Code c)
 452 {
 453         if (c == LyxCode())
 454                 return this;
 455         return inset.GetFirstLockingInsetOfType(c);
 456 }
 457
 458
 459 void InsetCollapsable::SetFont(BufferView * bv,
 460                                LyXFont const & font, bool toggleall)
 461 {
 462         inset.SetFont(bv, font, toggleall);
 463 }
 464
 465
 466 bool InsetCollapsable::doClearArea() const
 467 {
 468         return inset.doClearArea();
 469 }
 470
 471
 472 LyXText * InsetCollapsable::getLyXText(BufferView const * bv,
 473                                        bool const recursive) const
 474 {
 475         return inset.getLyXText(bv, recursive);
 476 }
 477
 478
 479 void InsetCollapsable::deleteLyXText(BufferView * bv, bool recursive) const
 480 {
 481         inset.deleteLyXText(bv, recursive);
 482 }
 483
 484
 485 void InsetCollapsable::resizeLyXText(BufferView * bv) const
 486 {
 487         inset.resizeLyXText(bv);
 488         LyXFont font(LyXFont::ALL_SANE);
 489         oldWidth = width(bv, font);
 490 }
 491
 492
 493 std::vector<string> const InsetCollapsable::getLabelList() const
 494 {
 495         return inset.getLabelList();
 496 }
 497
 498 bool InsetCollapsable::nodraw() const
 499 {
 500         return inset.nodraw();
 501 }
 502
 503 int InsetCollapsable::scroll(bool recursive) const
 504 {
 505         int sx = UpdatableInset::scroll(false);
 506
 507         if (recursive)
 508                 sx += inset.scroll(recursive);
 509
 510         return sx;
 511 }