X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsetcollapsable.C;h=00b3e869ec6c3ce989ecb5b63d41ecf05bcfa110;hb=1e394731004491d04abe436112b5a89521bbd19a;hp=a999b83d47ae137ffb0e4c4fe6c10a03e327f97a;hpb=63d5070bc3fc82f12e4bae453191e8f153b8524b;p=lyx.git diff --git a/src/insets/insetcollapsable.C b/src/insets/insetcollapsable.C index a999b83d47..00b3e869ec 100644 --- a/src/insets/insetcollapsable.C +++ b/src/insets/insetcollapsable.C @@ -1,8 +1,8 @@ /* This file is part of * ====================================================== - * + * * LyX, The Document Processor - * + * * Copyright 1998-2001 The LyX Team. * * ====================================================== @@ -18,289 +18,391 @@ #include "gettext.h" #include "lyxfont.h" #include "BufferView.h" -#include "Painter.h" -#include "insets/insettext.h" -#include "support/LOstream.h" -#include "support/lstrings.h" +#include "frontends/Painter.h" #include "debug.h" #include "lyxtext.h" +#include "frontends/font_metrics.h" +#include "lyxlex.h" -class LyXText; +#include "insets/insettext.h" +#include "support/LOstream.h" +#include "support/lstrings.h" + +using std::vector; using std::ostream; using std::endl; using std::max; -InsetCollapsable::InsetCollapsable() - : UpdatableInset() + +class LyXText; + + +InsetCollapsable::InsetCollapsable(BufferParams const & bp, bool collapsed) + : UpdatableInset(), collapsed_(collapsed), inset(bp), + 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), first_after_edit(false) { inset.setOwner(this); - collapsed = false; - label = "Label"; - autocollapse = true; - inset.SetAutoBreakRows(true); - inset.SetDrawFrame(0, InsetText::ALWAYS); - inset.SetFrameColor(0, LColor::footnoteframe); - button_length = button_top_y = button_bottom_y = 0; + inset.setAutoBreakRows(true); + inset.setDrawFrame(0, InsetText::ALWAYS); + inset.setFrameColor(0, LColor::collapsableframe); setInsetName("Collapsable"); - widthCollapsed = oldWidth = 0; - need_update = FULL; } -Inset * InsetCollapsable::Clone(Buffer const &) const +InsetCollapsable::InsetCollapsable(InsetCollapsable const & in, bool same_id) + : UpdatableInset(in, same_id), collapsed_(in.collapsed_), + framecolor(in.framecolor), labelfont(in.labelfont), inset(in.inset), + 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), first_after_edit(false) { - InsetCollapsable * result = new InsetCollapsable(); - result->inset.init(&inset); - result->inset.setOwner(result); - - result->collapsed = collapsed; - return result; + inset.init(&(in.inset), same_id); + inset.setOwner(this); } -bool InsetCollapsable::InsertInset(BufferView * bv, Inset * in) +bool InsetCollapsable::insertInset(BufferView * bv, Inset * in) { - if (!InsertInsetAllowed(in)) { + if (!insetAllowed(in->lyxCode())) { lyxerr << "InsetCollapsable::InsertInset: " "Unable to insert inset." << endl; return false; } - return inset.InsertInset(bv, in); + 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(collapsed) << "\n"; - inset.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()) { + if (lex.isOK()) { lex.next(); - string const token = lex.GetString(); + string const token = lex.getString(); if (token == "collapsed") { lex.next(); - collapsed = lex.GetBool(); + collapsed_ = lex.getBool(); } else { lyxerr << "InsetCollapsable::Read: Missing collapsed!" - << endl; + << endl; + // Take countermeasures + lex.pushToken(token); } } - inset.Read(buf, lex); + inset.read(buf, lex); } -int InsetCollapsable::ascent_collapsed(Painter & pain, LyXFont const &) const +int InsetCollapsable::ascent_collapsed() const { int width = 0; int ascent = 0; int descent = 0; - pain.buttonText(0, 0, label, labelfont, false, - width, ascent, descent); + font_metrics::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; int ascent = 0; int descent = 0; - pain.buttonText(0, 0, label, labelfont, false, - width, ascent, descent); + font_metrics::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; int ascent; int descent; - pain.buttonText(TEXT_TO_INSET_OFFSET, 0, label, labelfont, false, - width, ascent, descent); + font_metrics::buttonText(label, labelfont, width, ascent, descent); return width + (2*TEXT_TO_INSET_OFFSET); } -int InsetCollapsable::ascent(BufferView * bv, LyXFont const & font) const +int InsetCollapsable::ascent(BufferView * /*bv*/, LyXFont const &) const { - return ascent_collapsed(bv->painter(), font); + return ascent_collapsed(); } int InsetCollapsable::descent(BufferView * bv, LyXFont const & font) const { - if (collapsed) - return descent_collapsed(bv->painter(), font); + if (collapsed_) + return descent_collapsed(); - return descent_collapsed(bv->painter(), font) + inset.descent(bv, font) + - inset.ascent(bv, font) + TEXT_TO_BOTTOM_OFFSET; + return descent_collapsed() + + inset.descent(bv, font) + + inset.ascent(bv, font) + + TEXT_TO_BOTTOM_OFFSET; } int InsetCollapsable::width(BufferView * bv, LyXFont const & font) const { - if (collapsed) - return widthCollapsed; + if (collapsed_) + return width_collapsed(); + + int widthCollapsed = width_collapsed(); return (inset.width(bv, font) > widthCollapsed) ? inset.width(bv, font) : widthCollapsed; } -void InsetCollapsable::draw_collapsed(Painter & pain, LyXFont const &, - int baseline, float & x) const +void InsetCollapsable::draw_collapsed(Painter & pain, + int baseline, float & x) const { - int width = 0; pain.buttonText(int(x) + TEXT_TO_INSET_OFFSET, - baseline, label, labelfont, true, width); - x += width + 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 +void InsetCollapsable::draw(BufferView * bv, LyXFont const & f, + 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 = widthCollapsed; + button_length = width_collapsed(); button_top_y = -ascent(bv, f); - button_bottom_y = -ascent(bv, f) + ascent_collapsed(pain,f) + - descent_collapsed(pain, f); - if (collapsed) { - draw_collapsed(pain, f, baseline, x); - x += TEXT_TO_INSET_OFFSET; + button_bottom_y = -ascent(bv, f) + ascent_collapsed() + + descent_collapsed(); + + if (!isOpen()) { + draw_collapsed(pain, baseline, x); return; } - if (!cleared && ((inset.need_update == InsetText::FULL) || - (inset.need_update == InsetText::INIT) || - (top_x != int(x)) || (top_baseline != baseline))) { - int w = owner() ? width(bv, f) : pain.paperWidth(); - int h = ascent(bv, f) + descent(bv, f); - int tx = (needFullRow() && !owner()) ? 0 : int(x); - int ty = max(0, baseline - ascent(bv, f)); - - if ((ty + h) > pain.paperHeight()) - h = pain.paperHeight(); - if ((top_x + w) > pain.paperWidth()) - w = pain.paperWidth(); - if (baseline < 0) - h += (baseline - ascent(bv, f)); - pain.fillRectangle(tx, ty - 1, w, h + 2); - cleared = true; + 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; } top_x = int(x); + topx_set = true; top_baseline = baseline; - float dummy = x; - int bl = baseline - ascent(bv, f) + ascent_collapsed(pain, f); + int const bl = baseline - ascent(bv, f) + ascent_collapsed(); - draw_collapsed(pain, f, bl, dummy); - inset.draw(bv, f, - bl + descent_collapsed(pain, f) + inset.ascent(bv, f), + draw_collapsed(pain, bl, old_x); + inset.draw(bv, f, + bl + descent_collapsed() + inset.ascent(bv, f), x, cleared); - need_update = NONE; + 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 xp, int yp, unsigned int button) +void InsetCollapsable::edit(BufferView * bv, int xp, int yp, + mouse_button::state button) { - UpdatableInset::Edit(bv, xp, yp, button); + UpdatableInset::edit(bv, xp, yp, button); - if (collapsed && autocollapse) { - collapsed = false; + 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, false); - inset.Edit(bv, 0, 0, button); - } else if (!collapsed) { + inset.edit(bv); + } else { if (!bv->lockInset(this)) return; - inset.Edit(bv, xp, yp+(top_baseline - inset.y()), button); + if (yp <= button_bottom_y) { + inset.edit(bv, xp, 0, button); + } 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, false); + inset.edit(bv, front); + first_after_edit = true; + } else { + if (!bv->lockInset(this)) + return; + inset.edit(bv, front); + } +} + + +Inset::EDITABLE InsetCollapsable::editable() const +{ + if (collapsed_) return IS_EDITABLE; return HIGHLY_EDITABLE; } -void InsetCollapsable::InsetUnlock(BufferView * bv) +void InsetCollapsable::insetUnlock(BufferView * bv) { +#if 0 if (autocollapse) { - collapsed = true; + if (change_label_with_text) { + draw_label = get_new_label(); + } else { + draw_label = label; + } + collapsed_ = true; } - inset.InsetUnlock(bv); +#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, mouse_button::state button) { - if (!collapsed && (y > button_bottom_y)) { - inset.InsetButtonPress(bv, x, y+(top_baseline - inset.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) +bool InsetCollapsable::insetButtonRelease(BufferView * bv, + int x, int y, mouse_button::state button) { - if ((x >= 0) && (x < button_length) && - (y >= button_top_y) && (y <= button_bottom_y)) { - if (collapsed) { - collapsed = false; - inset.InsetButtonRelease(bv, 0, 0, button); + bool ret = false; + if ((button != mouse_button::button3) && (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, false); } else { - collapsed = true; + collapsed_ = true; bv->unlockInset(this); bv->updateInset(this, false); } - } else if (!collapsed && (y > button_top_y)) { - inset.InsetButtonRelease(bv, x, y+(top_baseline-inset.y()), button); + } 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)); + ret = inset.insetButtonRelease(bv, x, yy, button); } + if ((button == mouse_button::button3) && !ret) { + return showInsetDialog(bv); + } + return ret; } -void InsetCollapsable::InsetMotionNotify(BufferView * bv, - int x, int y, int state) +void InsetCollapsable::insetMotionNotify(BufferView * bv, + int x, int y, mouse_button::state state) { - if (x > button_bottom_y) { - inset.InsetMotionNotify(bv, x, y+(top_baseline - inset.y()), 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) +int InsetCollapsable::latex(Buffer const * buf, ostream & os, + bool fragile, bool free_spc) const +{ + return inset.latex(buf, os, fragile, free_spc); +} + + +int InsetCollapsable::ascii(Buffer const * buf, ostream & os, int ll) const { - inset.InsetKeyPress(xke); + return inset.ascii(buf, os, ll); } -int InsetCollapsable::Latex(Buffer const * buf, ostream & os, - bool fragile, bool free_spc) const +int InsetCollapsable::linuxdoc(Buffer const * buf, ostream & os) const { - return inset.Latex(buf, os, fragile, free_spc); + return inset.linuxdoc(buf, os); } +int InsetCollapsable::docbook(Buffer const * buf, ostream & os) const +{ + return inset.docbook(buf, os); +} + +#if 0 int InsetCollapsable::getMaxWidth(BufferView * bv, - UpdatableInset const * inset) const + UpdatableInset const * in) const { - int const w = UpdatableInset::getMaxWidth(bv, inset); +#if 0 + int const w = UpdatableInset::getMaxWidth(bv, in); if (w < 0) { // What does a negative max width signify? (Lgb) @@ -308,124 +410,128 @@ int InsetCollapsable::getMaxWidth(BufferView * bv, return w; } // should be at least 30 pixels !!! - return max(30, w - widthCollapsed); + return max(30, w - width_collapsed()); +#else + return UpdatableInset::getMaxWidth(bv, in); +#endif } +#endif void InsetCollapsable::update(BufferView * bv, LyXFont const & font, - bool reinit) + bool reinit) { - if (reinit) { - need_update = FULL; - if (owner()) + if (in_update) { + if (reinit && owner()) { owner()->update(bv, font, true); - return; - } - if (!widthCollapsed) { - widthCollapsed = width_collapsed(bv->painter(), font); - inset.resizeLyXText(bv); - need_update = FULL; - if (owner()) { - owner()->update(bv, font); - return; } + return; } - if (oldWidth != width(bv, font)) { - oldWidth = width(bv, font); - inset.resizeLyXText(bv); - need_update = FULL; - if (owner()) { - owner()->update(bv, font); - return; - } + in_update = true; + inset.update(bv, font, reinit); + if (reinit && owner()) { + owner()->update(bv, font, true); } - inset.update(bv, font); + in_update = false; } UpdatableInset::RESULT -InsetCollapsable::LocalDispatch(BufferView * bv, kb_action action, +InsetCollapsable::localDispatch(BufferView * bv, kb_action action, string const & arg) { - UpdatableInset::RESULT result = inset.LocalDispatch(bv, action, arg); - if (result == FINISHED) + 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) +bool InsetCollapsable::lockInsetInInset(BufferView * bv, UpdatableInset * in) { if (&inset == in) return true; - return inset.LockInsetInInset(bv, in); + return inset.lockInsetInInset(bv, in); } -bool InsetCollapsable::UnlockInsetInInset(BufferView * bv, UpdatableInset * in, +bool InsetCollapsable::unlockInsetInInset(BufferView * bv, UpdatableInset * in, bool lr) { if (&inset == in) { bv->unlockInset(this); return true; } - return inset.UnlockInsetInInset(bv, in, lr); + return inset.unlockInsetInInset(bv, in, lr); } -bool InsetCollapsable::UpdateInsetInInset(BufferView * bv, Inset *in) +bool InsetCollapsable::updateInsetInInset(BufferView * bv, Inset *in) { - if (&inset == in) + if (in == this) return true; - return inset.UpdateInsetInInset(bv, in); + return inset.updateInsetInInset(bv, in); } -unsigned int InsetCollapsable::InsetInInsetY() +int InsetCollapsable::insetInInsetY() const { - return inset.InsetInInsetY() - (top_baseline - inset.y()); + return inset.insetInInsetY() - (top_baseline - inset.y()); } -void InsetCollapsable::Validate(LaTeXFeatures & features) const +void InsetCollapsable::validate(LaTeXFeatures & features) const { - inset.Validate(features); + inset.validate(features); } -void InsetCollapsable::GetCursorPos(BufferView * bv, int & x, int & y) const +void InsetCollapsable::getCursorPos(BufferView * bv, int & x, int & y) const { - inset.GetCursorPos(bv, x , y); + inset.getCursorPos(bv, x , y); } -void InsetCollapsable::ToggleInsetCursor(BufferView * bv) +void InsetCollapsable::toggleInsetCursor(BufferView * bv) { - inset.ToggleInsetCursor(bv); + inset.toggleInsetCursor(bv); } -UpdatableInset * InsetCollapsable::GetLockingInset() +void InsetCollapsable::showInsetCursor(BufferView * bv, bool show) { - UpdatableInset * in = inset.GetLockingInset(); - if (&inset == in) - return this; + inset.showInsetCursor(bv, show); +} + + +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) +UpdatableInset * InsetCollapsable::getFirstLockingInsetOfType(Inset::Code c) { - if (c == LyxCode()) + if (c == lyxCode()) return this; - return inset.GetFirstLockingInsetOfType(c); + return inset.getFirstLockingInsetOfType(c); } -void InsetCollapsable::SetFont(BufferView * bv, - LyXFont const & font, bool toggleall) +void InsetCollapsable::setFont(BufferView * bv, LyXFont const & font, + bool toggleall, bool selectall) { - inset.SetFont(bv, font, toggleall); + inset.setFont(bv, font, toggleall, selectall); } @@ -436,7 +542,7 @@ bool InsetCollapsable::doClearArea() const LyXText * InsetCollapsable::getLyXText(BufferView const * bv, - bool const recursive) const + bool const recursive) const { return inset.getLyXText(bv, recursive); } @@ -448,9 +554,123 @@ void InsetCollapsable::deleteLyXText(BufferView * bv, bool recursive) const } -void InsetCollapsable::resizeLyXText(BufferView * bv) const +void InsetCollapsable::resizeLyXText(BufferView * bv, bool force) const { - inset.resizeLyXText(bv); + inset.resizeLyXText(bv, force); LyXFont font(LyXFont::ALL_SANE); oldWidth = width(bv, font); } + + +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(); +} + + +Paragraph * InsetCollapsable::getFirstParagraph(int i) const +{ + return inset.getFirstParagraph(i); +} + + +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, false); +} + + +void InsetCollapsable::close(BufferView * bv) const +{ + if (collapsed_) + return; + + collapsed_ = true; + bv->updateInset(const_cast(this), false); +} + + +void InsetCollapsable::setLabel(string const & l) const +{ + label = l; +} + + +bool InsetCollapsable::searchForward(BufferView * bv, string const & str, + bool cs, bool 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 cs, bool mw) +{ + bool found = inset.searchBackward(bv, str, cs, mw); + if (first_after_edit && !found) + close(bv); + first_after_edit = false; + return found; +} + + +string const InsetCollapsable::selectNextWordToSpellcheck(BufferView * bv, + float & value) const +{ + string const str = inset.selectNextWordToSpellcheck(bv, value); + if (first_after_edit && str.empty()) + close(bv); + first_after_edit = false; + return str; +}