X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsetbase.C;h=29d5448f96ffbc88e8ea3e83aa342e2528f643d4;hb=e28331ed63062dea10d0a21b9ec12034b4b17b9a;hp=9e52e8639e157244aab00bc8d0424005f18c172d;hpb=1eaa3eb913b16f4e6f5991b9c53b0b9ab3f84948;p=lyx.git diff --git a/src/insets/insetbase.C b/src/insets/insetbase.C index 9e52e8639e..29d5448f96 100644 --- a/src/insets/insetbase.C +++ b/src/insets/insetbase.C @@ -11,88 +11,216 @@ #include #include "insetbase.h" + +#include "buffer.h" +#include "coordcache.h" +#include "BufferView.h" +#include "LColor.h" +#include "cursor.h" #include "debug.h" +#include "dimension.h" #include "dispatchresult.h" +#include "funcrequest.h" +#include "FuncStatus.h" #include "gettext.h" #include "lyxtext.h" +#include "metricsinfo.h" + +#include "frontends/Painter.h" + +#include + +#include +#include + +namespace lyx { -DispatchResult InsetBase::dispatch(LCursor & cur, FuncRequest const & cmd) +class InsetName { +public: + InsetName(std::string const & n, InsetBase::Code c) + : name(n), code(c) {} + std::string name; + InsetBase::Code code; +}; + + +typedef std::map TranslatorMap; + + +static TranslatorMap const build_translator() { - return priv_dispatch(cur, cmd); + InsetName const insetnames[] = { + InsetName("toc", InsetBase::TOC_CODE), + InsetName("quote", InsetBase::QUOTE_CODE), + InsetName("ref", InsetBase::REF_CODE), + InsetName("url", InsetBase::URL_CODE), + InsetName("htmlurl", InsetBase::HTMLURL_CODE), + InsetName("separator", InsetBase::SEPARATOR_CODE), + InsetName("ending", InsetBase::ENDING_CODE), + InsetName("label", InsetBase::LABEL_CODE), + InsetName("note", InsetBase::NOTE_CODE), + InsetName("accent", InsetBase::ACCENT_CODE), + InsetName("math", InsetBase::MATH_CODE), + InsetName("index", InsetBase::INDEX_CODE), + InsetName("nomenclature", InsetBase::NOMENCL_CODE), + InsetName("include", InsetBase::INCLUDE_CODE), + InsetName("graphics", InsetBase::GRAPHICS_CODE), + InsetName("bibitem", InsetBase::BIBITEM_CODE), + InsetName("bibtex", InsetBase::BIBTEX_CODE), + InsetName("text", InsetBase::TEXT_CODE), + InsetName("ert", InsetBase::ERT_CODE), + InsetName("foot", InsetBase::FOOT_CODE), + InsetName("margin", InsetBase::MARGIN_CODE), + InsetName("float", InsetBase::FLOAT_CODE), + InsetName("wrap", InsetBase::WRAP_CODE), + InsetName("specialchar", InsetBase::SPECIALCHAR_CODE), + InsetName("tabular", InsetBase::TABULAR_CODE), + InsetName("external", InsetBase::EXTERNAL_CODE), + InsetName("caption", InsetBase::CAPTION_CODE), + InsetName("mathmacro", InsetBase::MATHMACRO_CODE), + InsetName("cite", InsetBase::CITE_CODE), + InsetName("float_list", InsetBase::FLOAT_LIST_CODE), + InsetName("index_print", InsetBase::INDEX_PRINT_CODE), + InsetName("nomencl_print", InsetBase::NOMENCL_PRINT_CODE), + InsetName("optarg", InsetBase::OPTARG_CODE), + InsetName("environment", InsetBase::ENVIRONMENT_CODE), + InsetName("hfill", InsetBase::HFILL_CODE), + InsetName("newline", InsetBase::NEWLINE_CODE), + InsetName("line", InsetBase::LINE_CODE), + InsetName("branch", InsetBase::BRANCH_CODE), + InsetName("box", InsetBase::BOX_CODE), + InsetName("charstyle", InsetBase::CHARSTYLE_CODE), + InsetName("vspace", InsetBase::VSPACE_CODE), + InsetName("mathmacroarg", InsetBase::MATHMACROARG_CODE), + }; + + std::size_t const insetnames_size = + sizeof(insetnames) / sizeof(insetnames[0]); + + std::map data; + for (std::size_t i = 0; i != insetnames_size; ++i) { + InsetName const & var = insetnames[i]; + data[var.name] = var.code; + } + + return data; } -DispatchResult InsetBase::priv_dispatch(LCursor &, FuncRequest const &) +std::auto_ptr InsetBase::clone() const { - return DispatchResult(false); + std::auto_ptr b = doClone(); + BOOST_ASSERT(typeid(*b) == typeid(*this)); + return b; } -void InsetBase::edit(LCursor &, bool) +InsetBase::Code InsetBase::translate(std::string const & name) { - lyxerr << "InsetBase: edit left/right" << std::endl; + static TranslatorMap const translator = build_translator(); + + TranslatorMap::const_iterator it = translator.find(name); + return it == translator.end() ? NO_CODE : it->second; } -void InsetBase::edit(LCursor & cur, int, int) +void InsetBase::dispatch(LCursor & cur, FuncRequest & cmd) { - lyxerr << "InsetBase: edit xy" << std::endl; - edit(cur, true); + cur.updateFlags(Update::Force | Update::FitCursor); + cur.dispatched(); + doDispatch(cur, cmd); } -InsetBase::idx_type InsetBase::index(row_type row, col_type col) const +void InsetBase::doDispatch(LCursor & cur, FuncRequest &) { - if (row != 0) - lyxerr << "illegal row: " << row << std::endl; - if (col != 0) - lyxerr << "illegal col: " << col << std::endl; - return 0; + cur.noUpdate(); + cur.undispatched(); } -bool InsetBase::idxBetween(idx_type idx, idx_type from, idx_type to) const +bool InsetBase::getStatus(LCursor &, FuncRequest const & cmd, + FuncStatus & flag) const { - return from <= idx && idx <= to; + // LFUN_INSET_APPLY is sent from the dialogs when the data should + // be applied. This is either changed to LFUN_INSET_MODIFY (if the + // dialog belongs to us) or LFUN_INSET_INSERT (if the dialog does + // not belong to us, i. e. the dialog was open, and the user moved + // the cursor in our inset) in LyXFunc::getStatus(). + // Dialogs::checkStatus() ensures that the dialog is deactivated if + // LFUN_INSET_APPLY is disabled. + + switch (cmd.action) { + case LFUN_INSET_MODIFY: + // Allow modification of our data. + // This needs to be handled in the doDispatch method of our + // instantiatable children. + flag.enabled(true); + return true; + + case LFUN_INSET_INSERT: + // Don't allow insertion of new insets. + // Every inset that wants to allow new insets from open + // dialogs needs to override this. + flag.enabled(false); + return true; + + default: + return false; + } } -bool InsetBase::idxUpDown(LCursor &, bool) const +void InsetBase::edit(LCursor &, bool) { - return false; + lyxerr[Debug::INSETS] << BOOST_CURRENT_FUNCTION + << ": edit left/right" << std::endl; } -bool InsetBase::idxUpDown2(LCursor &, bool) const +InsetBase * InsetBase::editXY(LCursor &, int x, int y) { - return false; + lyxerr[Debug::INSETS] << BOOST_CURRENT_FUNCTION + << ": x=" << x << " y= " << y + << std::endl; + return this; +} + + +InsetBase::idx_type InsetBase::index(row_type row, col_type col) const +{ + if (row != 0) + lyxerr << BOOST_CURRENT_FUNCTION + << ": illegal row: " << row << std::endl; + if (col != 0) + lyxerr << BOOST_CURRENT_FUNCTION + << ": illegal col: " << col << std::endl; + return 0; } -void InsetBase::getScreenPos(idx_type, pos_type, int & x, int & y) const +bool InsetBase::idxBetween(idx_type idx, idx_type from, idx_type to) const { - lyxerr << "InsetBase::getScreenPos() called directly!" << std::endl; - x = y = 0; + return from <= idx && idx <= to; } -int InsetBase::plaintext(Buffer const &, - std::ostream &, OutputParams const &) const +bool InsetBase::idxUpDown(LCursor &, bool) const { - return 0; + return false; } -int InsetBase::linuxdoc(Buffer const &, - std::ostream &, OutputParams const &) const +int InsetBase::plaintext(Buffer const &, + odocstream &, OutputParams const &) const { return 0; } int InsetBase::docbook(Buffer const &, - std::ostream &, OutputParams const &) const + odocstream &, OutputParams const &) const { return 0; } @@ -116,62 +244,126 @@ bool InsetBase::autoDelete() const } -std::string const InsetBase::editMessage() const +docstring const InsetBase::editMessage() const { return _("Opened inset"); } -bool InsetBase::insetAllowed(InsetBase * inset) const +docstring const & InsetBase::getInsetName() const { - return insetAllowed(inset->lyxCode()); + static docstring const name = from_ascii("unknown"); + return name; } -std::string const & InsetBase::getInsetName() const +void InsetBase::cursorPos(BufferView const & /*bv*/, CursorSlice const &, + bool, int & x, int & y) const { - static std::string const name = "unknown"; - return name; + lyxerr << "InsetBase::cursorPos called directly" << std::endl; + x = 100; + y = 100; } -int InsetBase::getCell(int x, int y) const -{ - for (int i = 0, n = numParagraphs(); i < n; ++i) { - LyXText * text = getText(i); - //lyxerr << "### text: " << text << " i: " << i - // << " xo: " << text->xo_ << "..." << text->xo_ + text->width - // << " yo: " << text->yo_ - // << " yo: " << text->yo_ - text->ascent() << "..." - // << text->yo_ + text->descent() - // << std::endl; - if (x >= text->xo_ - && x <= text->xo_ + text->width - && y >= text->yo_ - && y <= text->yo_ + text->height) - { - lyxerr << "### found text # " << i << std::endl; - return i; - } - } - return -1; +void InsetBase::metricsMarkers(Dimension & dim, int framesize) const +{ + dim.wid += 2 * framesize; + dim.asc += framesize; +} + + +void InsetBase::metricsMarkers2(Dimension & dim, int framesize) const +{ + dim.wid += 2 * framesize; + dim.asc += framesize; + dim.des += framesize; } -void InsetBase::markErased() -{} +void InsetBase::drawMarkers(PainterInfo & pi, int x, int y) const +{ + LColor::color pen_color = editing(pi.base.bv)? + LColor::mathframe : LColor::background; + + int const t = x + width() - 1; + int const d = y + descent(); + pi.pain.line(x, d - 3, x, d, pen_color); + pi.pain.line(t, d - 3, t, d, pen_color); + pi.pain.line(x, d, x + 3, d, pen_color); + pi.pain.line(t - 3, d, t, d, pen_color); + setPosCache(pi, x, y); +} + + +void InsetBase::drawMarkers2(PainterInfo & pi, int x, int y) const +{ + LColor::color pen_color = editing(pi.base.bv)? + LColor::mathframe : LColor::background; + + drawMarkers(pi, x, y); + int const t = x + width() - 1; + int const a = y - ascent(); + pi.pain.line(x, a + 3, x, a, pen_color); + pi.pain.line(t, a + 3, t, a, pen_color); + pi.pain.line(x, a, x + 3, a, pen_color); + pi.pain.line(t - 3, a, t, a, pen_color); + setPosCache(pi, x, y); +} + + +bool InsetBase::editing(BufferView * bv) const +{ + return bv->cursor().isInside(this); +} + + +int InsetBase::xo(BufferView const & bv) const +{ + return bv.coordCache().getInsets().x(this); +} + + +int InsetBase::yo(BufferView const & bv) const +{ + return bv.coordCache().getInsets().y(this); +} + + +bool InsetBase::covers(BufferView const & bv, int x, int y) const +{ + //lyxerr << "InsetBase::covers, x: " << x << " y: " << y + // << " xo: " << xo(bv) << " yo: " << yo() + // << " x1: " << xo(bv) << " x2: " << xo() + width() + // << " y1: " << yo(bv) - ascent() << " y2: " << yo() + descent() + // << std::endl; + return bv.coordCache().getInsets().has(this) + && x >= xo(bv) + && x <= xo(bv) + width() + && y >= yo(bv) - ascent() + && y <= yo(bv) + descent(); +} + + +void InsetBase::dump() const +{ + Buffer buf("foo", 1); + write(buf, lyxerr); +} + ///////////////////////////////////////// -bool isEditableInset(InsetBase const * i) +bool isEditableInset(InsetBase const * inset) { - return i && i->editable(); + return inset && inset->editable(); } -bool isHighlyEditableInset(InsetBase const * i) +bool isHighlyEditableInset(InsetBase const * inset) { - return i && i->editable() == InsetBase::HIGHLY_EDITABLE; + return inset && inset->editable() == InsetBase::HIGHLY_EDITABLE; } +} // namespace lyx