X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsetcollapsable.C;h=ce43acc582135c7dfc603ace9d0a760c7e93a5fe;hb=9f3dd22dd39c419522914846b21dd2b45720ad0a;hp=1889b8a1694c4417886d2f85e36f4dbf4021818e;hpb=90c533ae7dfcb39dd9b0190b4993817d24e0102b;p=lyx.git diff --git a/src/insets/insetcollapsable.C b/src/insets/insetcollapsable.C index 1889b8a169..ce43acc582 100644 --- a/src/insets/insetcollapsable.C +++ b/src/insets/insetcollapsable.C @@ -3,7 +3,7 @@ * * LyX, The Document Processor * - * Copyright (C) 1998 The LyX Team. + * Copyright 1998-2001 The LyX Team. * * ====================================================== */ @@ -19,262 +19,628 @@ #include "lyxfont.h" #include "BufferView.h" #include "Painter.h" +#include "insets/insettext.h" #include "support/LOstream.h" #include "support/lstrings.h" +#include "debug.h" +#include "lyxtext.h" +#include "font.h" +#include "lyxlex.h" + +class LyXText; using std::ostream; +using std::endl; +using std::max; + -InsetCollapsable::InsetCollapsable() - : InsetText() +InsetCollapsable::InsetCollapsable(bool collapsed) + : UpdatableInset(), collapsed_(collapsed), + button_length(0), button_top_y(0), button_bottom_y(0), + need_update(NONE), label("Label"), +#if 0 + autocollapse(false), +#endif + oldWidth(0), in_update(false) { - collapsed = true; - label = "Label"; - autocollapse = true; - autoBreakRows = true; - framecolor = LColor::footnoteframe; - widthOffset = 2 * TEXT_TO_INSET_OFFSET + 2; // 1+1 (frame) - button_length = button_top_y = button_bottom_y = 0; - setInsetName("Collapsable"); + inset.setOwner(this); + inset.setAutoBreakRows(true); + inset.setDrawFrame(0, InsetText::ALWAYS); + inset.setFrameColor(0, LColor::collapsableframe); + setInsetName("Collapsable"); } -Inset * InsetCollapsable::Clone() const +InsetCollapsable::InsetCollapsable(InsetCollapsable const & in, bool same_id) + : UpdatableInset(in, same_id), collapsed_(in.collapsed_), + framecolor(in.framecolor), labelfont(in.labelfont), + button_length(0), button_top_y(0), button_bottom_y(0), + need_update(NONE), label(in.label), +#if 0 + autocollapse(in.autocollapse), +#endif + oldWidth(0), in_update(false) { - InsetCollapsable * result = new InsetCollapsable(); - result->init(this); + inset.init(&(in.inset), same_id); + inset.setOwner(this); +} + - result->collapsed = collapsed; - return result; +bool InsetCollapsable::insertInset(BufferView * bv, Inset * in) +{ + if (!insetAllowed(in->lyxCode())) { + lyxerr << "InsetCollapsable::InsertInset: " + "Unable to insert inset." << endl; + return false; + } + return inset.insertInset(bv, in); } -void InsetCollapsable::Write(Buffer const * buf, ostream & os) const +void InsetCollapsable::write(Buffer const * buf, ostream & os) const { - os << "collapsed " << tostr(!display()) << "\n"; - WriteParagraphData(buf, os); + os << "collapsed " << tostr(collapsed_) << "\n"; + inset.writeParagraphData(buf, os); } -void InsetCollapsable::Read(Buffer const * buf, LyXLex & lex) + +void InsetCollapsable::read(Buffer const * buf, LyXLex & lex) { - if (lex.IsOK()) { - lex.next(); - string token = lex.GetString(); - if (token == "collapsed") { - lex.next(); - collapsed = lex.GetBool(); + if (lex.isOK()) { + lex.next(); + string const token = lex.getString(); + if (token == "collapsed") { + lex.next(); + collapsed_ = lex.getBool(); + } else { + lyxerr << "InsetCollapsable::Read: Missing collapsed!" + << endl; + // Take countermeasures + lex.pushToken(token); + } } - } - InsetText::Read(buf, lex); + inset.read(buf, lex); } -int InsetCollapsable::ascent_collapsed(Painter & pain, LyXFont const &) const +int InsetCollapsable::ascent_collapsed() const { - int width = 0, ascent = 0, descent = 0; - pain.buttonText(0, 0, label.c_str(), labelfont, false, - width, ascent, descent); - return ascent; + int width = 0; + int ascent = 0; + int descent = 0; + lyxfont::buttonText(label, labelfont, width, ascent, descent); + return ascent; } -int InsetCollapsable::descent_collapsed(Painter & pain, LyXFont const &) const +int InsetCollapsable::descent_collapsed() const { - int width = 0, ascent = 0, descent = 0; - pain.buttonText(0, 0, label.c_str(), labelfont, false, - width, ascent, descent); - return descent; + int width = 0; + int ascent = 0; + int descent = 0; + lyxfont::buttonText(label, labelfont, width, ascent, descent); + return descent; } -int InsetCollapsable::width_collapsed(Painter & pain, LyXFont const &) const +//int InsetCollapsable::width_collapsed(Painter & pain) const +int InsetCollapsable::width_collapsed() const { - int width, ascent, descent; - pain.buttonText(TEXT_TO_INSET_OFFSET, 0, label.c_str(), labelfont, false, - width, ascent, descent); - return width + (2*TEXT_TO_INSET_OFFSET); + int width; + int ascent; + int descent; + lyxfont::buttonText(label, labelfont, width, ascent, descent); + return width + (2*TEXT_TO_INSET_OFFSET); } -int InsetCollapsable::ascent(Painter & pain, LyXFont const & font) const +int InsetCollapsable::ascent(BufferView * /*bv*/, LyXFont const &) const { - if (collapsed) - return ascent_collapsed(pain, font); - else - return InsetText::ascent(pain, font) + TEXT_TO_TOP_OFFSET; + return ascent_collapsed(); } -int InsetCollapsable::descent(Painter & pain, LyXFont const & font) const +int InsetCollapsable::descent(BufferView * bv, LyXFont const & font) const { - if (collapsed) - return descent_collapsed(pain, font); - else - return InsetText::descent(pain, font) + TEXT_TO_BOTTOM_OFFSET; + if (collapsed_) + return descent_collapsed(); + + return descent_collapsed() + + inset.descent(bv, font) + + inset.ascent(bv, font) + + TEXT_TO_BOTTOM_OFFSET; } -int InsetCollapsable::width(Painter & pain, LyXFont const & font) const +int InsetCollapsable::width(BufferView * bv, LyXFont const & font) const { - if (collapsed) - return width_collapsed(pain, font); + if (collapsed_) + return width_collapsed(); + + int widthCollapsed = width_collapsed(); - return InsetText::width(pain, font) + width_collapsed(pain,font) + - widthOffset; + return (inset.width(bv, font) > widthCollapsed) ? + inset.width(bv, font) : widthCollapsed; } -void InsetCollapsable::draw_collapsed(Painter & pain, LyXFont const & font, +void InsetCollapsable::draw_collapsed(Painter & pain, int baseline, float & x) const { - int width = 0; - pain.buttonText(int(x) + TEXT_TO_INSET_OFFSET, - baseline-ascent(pain, font)+ascent_collapsed(pain, font), - label.c_str(), labelfont, true, width); - x += width + (2 * TEXT_TO_INSET_OFFSET); + pain.buttonText(int(x) + TEXT_TO_INSET_OFFSET, + baseline, label, labelfont); + x += width_collapsed(); } void InsetCollapsable::draw(BufferView * bv, LyXFont const & f, - int baseline, float & x, bool cleared) const -{ - Painter & pain = bv->painter(); - - button_length = width_collapsed(pain, labelfont) + 2; - button_top_y = -ascent_collapsed(pain, f); - button_bottom_y = descent_collapsed(pain, f); - if (collapsed) { - draw_collapsed(pain, f, baseline, x); - return; - } - - if (!cleared && ((need_update==FULL) || (topx!=int(x)) || - (topbaseline!=baseline))) { - int w = width(pain, f); - int h = ascent(pain,f) + descent(pain, f); - int tx = display()? 0:topx; - int ty = baseline - ascent(pain,f); - - if (ty < 0) - ty = 0; - if ((ty + h) > pain.paperHeight()) - h = pain.paperHeight(); - if ((topx + w) > pain.paperWidth()) - w = pain.paperWidth(); - pain.fillRectangle(tx, ty-1, w, h+2); - cleared = true; - } + int baseline, float & x, bool cleared) const +{ + if (need_update != NONE) { + const_cast(&inset)->update(bv, f, true); + bv->text->status(bv, LyXText::CHANGED_IN_DRAW); + need_update = NONE; + return; + } + if (nodraw()) + return; + + Painter & pain = bv->painter(); + + button_length = width_collapsed(); + button_top_y = -ascent(bv, f); + button_bottom_y = -ascent(bv, f) + ascent_collapsed() + + descent_collapsed(); - // not needed if collapsed - topx = int(x); - topbaseline = baseline; + if (!isOpen()) { + draw_collapsed(pain, baseline, x); + x += TEXT_TO_INSET_OFFSET; + return; + } - int w = InsetText::width(pain, f) + (2 * TEXT_TO_INSET_OFFSET); - int h = ascent(pain,f) + descent(pain, f); + float old_x = x; + + if (!owner()) + x += static_cast(scroll()); + + if (!cleared && (inset.need_update == InsetText::FULL || + inset.need_update == InsetText::INIT || + top_x != int(x) || + top_baseline != baseline)) + { + // we don't need anymore to clear here we just have to tell + // the underlying LyXText that it should do the RowClear! + inset.setUpdateStatus(bv, InsetText::FULL); + bv->text->status(bv, LyXText::CHANGED_IN_DRAW); + return; + } - draw_collapsed(pain, f, baseline, x); - x -= TEXT_TO_INSET_OFFSET; + top_x = int(x); + topx_set = true; + top_baseline = baseline; - int save_x = static_cast(x); - x += TEXT_TO_INSET_OFFSET; - InsetText::draw(bv, f, baseline, x, cleared); - pain.rectangle(save_x, baseline - ascent(pain, f), w, h, framecolor); + int const bl = baseline - ascent(bv, f) + ascent_collapsed(); + + draw_collapsed(pain, bl, old_x); + inset.draw(bv, f, + bl + descent_collapsed() + inset.ascent(bv, f), + x, cleared); + if (x < (top_x + button_length + TEXT_TO_INSET_OFFSET)) + x = top_x + button_length + TEXT_TO_INSET_OFFSET; } -void InsetCollapsable::Edit(BufferView * bv, int x, int y, unsigned int button) +void InsetCollapsable::edit(BufferView * bv, int xp, int yp, + unsigned int button) { - if (collapsed && autocollapse) { - collapsed = false; - UpdateLocal(bv, FULL, false); - InsetText::Edit(bv, 0, 0, button); - } else if (!collapsed) { - InsetText::Edit(bv, x, y, button); - } + UpdatableInset::edit(bv, xp, yp, button); + + if (collapsed_) { + collapsed_ = false; + // set this only here as it should be recollapsed only if + // it was already collapsed! + first_after_edit = true; + if (!bv->lockInset(this)) + return; + bv->updateInset(this, true); + inset.edit(bv); + } else { + if (!bv->lockInset(this)) + return; + if (yp <= button_bottom_y) { + inset.edit(bv); + } else { + LyXFont font(LyXFont::ALL_SANE); + int yy = ascent(bv, font) + yp - + (ascent_collapsed() + + descent_collapsed() + + inset.ascent(bv, font)); + inset.edit(bv, xp, yy, button); + } + } } -Inset::EDITABLE InsetCollapsable::Editable() const +void InsetCollapsable::edit(BufferView * bv, bool front) { - if (collapsed) + UpdatableInset::edit(bv, front); + + if (collapsed_) { + collapsed_ = false; + if (!bv->lockInset(this)) + return; + inset.setUpdateStatus(bv, InsetText::FULL); + bv->updateInset(this, true); + inset.edit(bv, front); + } else { + if (!bv->lockInset(this)) + return; + inset.edit(bv, front); + } + first_after_edit = true; +} + + +Inset::EDITABLE InsetCollapsable::editable() const +{ + if (collapsed_) return IS_EDITABLE; return HIGHLY_EDITABLE; } -void InsetCollapsable::InsetUnlock(BufferView * bv) +void InsetCollapsable::insetUnlock(BufferView * bv) { - if (autocollapse) { - collapsed = true; - } - InsetText::InsetUnlock(bv); - UpdateLocal(bv, FULL, false); +#if 0 + if (autocollapse) { + if (change_label_with_text) { + draw_label = get_new_label(); + } else { + draw_label = label; + } + collapsed_ = true; + } +#endif + inset.insetUnlock(bv); + if (scroll()) + scroll(bv, 0.0F); + bv->updateInset(this, false); } -void InsetCollapsable::InsetButtonPress(BufferView * bv,int x,int y,int button) +void InsetCollapsable::insetButtonPress(BufferView * bv, + int x, int y, int button) { - if (!collapsed && (x >= button_length)) { - InsetText::InsetButtonPress(bv, x, y, button); - } + if (!collapsed_ && (y > button_bottom_y)) { + LyXFont font(LyXFont::ALL_SANE); + int yy = ascent(bv, font) + y - + (ascent_collapsed() + + descent_collapsed() + + inset.ascent(bv, font)); + inset.insetButtonPress(bv, x, yy, button); + } } -void InsetCollapsable::InsetButtonRelease(BufferView * bv, - int x, int y, int button) +void InsetCollapsable::insetButtonRelease(BufferView * bv, + int x, int y, int button) { - if ((x >= 0) && (x < button_length) && - (y >= button_top_y) && (y < button_bottom_y)) { - if (collapsed) { - collapsed = false; - InsetText::InsetButtonRelease(bv, 0, 0, button); - UpdateLocal(bv, FULL, false); - } else { - collapsed = true; - UpdateLocal(bv, FULL, false); - bv->unlockInset(this); + if ((x >= 0) && (x < button_length) && + (y >= button_top_y) && (y <= button_bottom_y)) + { + if (collapsed_) { + collapsed_ = false; +// should not be called on inset open! +// inset.insetButtonRelease(bv, 0, 0, button); + inset.setUpdateStatus(bv, InsetText::FULL); + bv->updateInset(this, true); + } else { + collapsed_ = true; + bv->unlockInset(this); + bv->updateInset(this, true); + } + } else if (!collapsed_ && (y > button_bottom_y)) { + LyXFont font(LyXFont::ALL_SANE); + int yy = ascent(bv, font) + y - + (ascent_collapsed() + + descent_collapsed() + + inset.ascent(bv, font)); + inset.insetButtonRelease(bv, x, yy, button); } - } else if (!collapsed && (x >= button_length) && (y >= button_top_y)) { - InsetText::InsetButtonRelease(bv, x, y, button); - } } -void InsetCollapsable::InsetMotionNotify(BufferView * bv, - int x, int y, int state) +void InsetCollapsable::insetMotionNotify(BufferView * bv, + int x, int y, int state) +{ + if (y > button_bottom_y) { + LyXFont font(LyXFont::ALL_SANE); + int yy = ascent(bv, font) + y - + (ascent_collapsed() + + descent_collapsed() + + inset.ascent(bv, font)); + inset.insetMotionNotify(bv, x, yy, state); + } +} + + +void InsetCollapsable::insetKeyPress(XKeyEvent * xke) +{ + inset.insetKeyPress(xke); +} + + +int InsetCollapsable::latex(Buffer const * buf, ostream & os, + bool fragile, bool free_spc) const +{ + return inset.latex(buf, os, fragile, free_spc); +} + + +int InsetCollapsable::getMaxWidth(BufferView * bv, + UpdatableInset const * in) const +{ +#if 0 + int const w = UpdatableInset::getMaxWidth(bv, in); + + if (w < 0) { + // What does a negative max width signify? (Lgb) + // Use the max width of the draw-area (Jug) + return w; + } + // should be at least 30 pixels !!! + return max(30, w - width_collapsed()); +#else + return UpdatableInset::getMaxWidth(bv, in); +#endif +} + + +void InsetCollapsable::update(BufferView * bv, LyXFont const & font, + bool reinit) +{ + if (in_update) { + if (reinit && owner()) { + owner()->update(bv, font, true); + } + return; + } + in_update = true; + inset.update(bv, font, reinit); + if (reinit && owner()) { + owner()->update(bv, font, true); + } + in_update = false; +} + + +UpdatableInset::RESULT +InsetCollapsable::localDispatch(BufferView * bv, kb_action action, + string const & arg) +{ + UpdatableInset::RESULT result = inset.localDispatch(bv, action, arg); + if (result == FINISHED) + bv->unlockInset(this); + first_after_edit = false; + return result; +} + + +bool InsetCollapsable::lockInsetInInset(BufferView * bv, UpdatableInset * in) +{ + if (&inset == in) + return true; + return inset.lockInsetInInset(bv, in); +} + + +bool InsetCollapsable::unlockInsetInInset(BufferView * bv, UpdatableInset * in, + bool lr) +{ + if (&inset == in) { + bv->unlockInset(this); + return true; + } + return inset.unlockInsetInInset(bv, in, lr); +} + + +bool InsetCollapsable::updateInsetInInset(BufferView * bv, Inset *in) +{ + if (&inset == in) + return true; + return inset.updateInsetInInset(bv, in); +} + + +unsigned int InsetCollapsable::insetInInsetY() +{ + return inset.insetInInsetY() - (top_baseline - inset.y()); +} + + +void InsetCollapsable::validate(LaTeXFeatures & features) const +{ + inset.validate(features); +} + + +void InsetCollapsable::getCursorPos(BufferView * bv, int & x, int & y) const { - if (x >= button_length) { - InsetText::InsetMotionNotify(bv, x, y, state); - } + inset.getCursorPos(bv, x , y); } -int InsetCollapsable::getMaxWidth(Painter & pain, - UpdatableInset const * inset) const +void InsetCollapsable::toggleInsetCursor(BufferView * bv) { - if ((this == inset) && !owner()) - return pain.paperWidth(); - if (this == inset) - return static_cast(owner())->getMaxWidth(pain,inset); - if (owner()) - return static_cast(owner())->getMaxWidth(pain,inset)- - width_collapsed(pain, labelfont) - widthOffset; + inset.toggleInsetCursor(bv); +} + - return pain.paperWidth()-width_collapsed(pain, labelfont) - widthOffset; +void InsetCollapsable::showInsetCursor(BufferView * bv, bool show) +{ + inset.showInsetCursor(bv, show); } -int InsetCollapsable::getMaxTextWidth(Painter & pain, - UpdatableInset const * inset) const +void InsetCollapsable::hideInsetCursor(BufferView * bv) +{ + inset.hideInsetCursor(bv); +} + + +UpdatableInset * InsetCollapsable::getLockingInset() const +{ + UpdatableInset * in = inset.getLockingInset(); + if (const_cast(&inset) == in) + return const_cast(this); + return in; +} + + +UpdatableInset * InsetCollapsable::getFirstLockingInsetOfType(Inset::Code c) +{ + if (c == lyxCode()) + return this; + return inset.getFirstLockingInsetOfType(c); +} + + +void InsetCollapsable::setFont(BufferView * bv, LyXFont const & font, + bool toggleall, bool selectall) +{ + inset.setFont(bv, font, toggleall, selectall); +} + + +bool InsetCollapsable::doClearArea() const +{ + return inset.doClearArea(); +} + + +LyXText * InsetCollapsable::getLyXText(BufferView const * bv, + bool const recursive) const +{ + return inset.getLyXText(bv, recursive); +} + + +void InsetCollapsable::deleteLyXText(BufferView * bv, bool recursive) const +{ + inset.deleteLyXText(bv, recursive); +} + + +void InsetCollapsable::resizeLyXText(BufferView * bv, bool force) const +{ + inset.resizeLyXText(bv, force); + LyXFont font(LyXFont::ALL_SANE); + oldWidth = width(bv, font); +} + + +std::vector const InsetCollapsable::getLabelList() const +{ + return inset.getLabelList(); +} + + +bool InsetCollapsable::nodraw() const +{ + return inset.nodraw(); +} + + +int InsetCollapsable::scroll(bool recursive) const +{ + int sx = UpdatableInset::scroll(false); + + if (recursive) + sx += inset.scroll(recursive); + + return sx; +} + + +Paragraph * InsetCollapsable::getParFromID(int id) const +{ + lyxerr[Debug::INFO] << "Looking for paragraph " << id << endl; + return inset.getParFromID(id); +} + + +Paragraph * InsetCollapsable::firstParagraph() const +{ + return inset.firstParagraph(); +} + + +LyXCursor const & InsetCollapsable::cursor(BufferView * bv) const +{ + return inset.cursor(bv); +} + + +Inset * InsetCollapsable::getInsetFromID(int id_arg) const +{ + if (id_arg == id()) + return const_cast(this); + return inset.getInsetFromID(id_arg); +} + + +void InsetCollapsable::open(BufferView * bv) +{ + if (!collapsed_) return; + + collapsed_ = false; + bv->updateInset(this, true); +} + + +void InsetCollapsable::close(BufferView * bv) const +{ + if (collapsed_) + return; + + collapsed_ = true; + bv->updateInset(const_cast(this), true); +} + + +void InsetCollapsable::setLabel(string const & l) const +{ + label = l; +} + + +bool InsetCollapsable::searchForward(BufferView * bv, string const & str, + bool const & cs, bool const & mw) +{ + bool found = inset.searchForward(bv, str, cs, mw); + if (first_after_edit && !found) + close(bv); + first_after_edit = false; + return found; +} +bool InsetCollapsable::searchBackward(BufferView * bv, string const & str, + bool const & cs, bool const & mw) { - return getMaxWidth(pain, inset) - - width_collapsed(pain, labelfont) - widthOffset; + bool found = inset.searchBackward(bv, str, cs, mw); + if (first_after_edit && !found) + close(bv); + first_after_edit = false; + return found; } -void InsetCollapsable::update(BufferView * bv, - LyXFont const & font, bool dodraw) +string const InsetCollapsable::selectNextWord(BufferView * bv, float & value) const { - drawTextXOffset = width_collapsed(bv->painter(), font); - InsetText::update(bv, font, dodraw); + string str = inset.selectNextWord(bv, value); + if (first_after_edit && str.empty()) + close(bv); + first_after_edit = false; + return str; }