X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fbufferview_funcs.C;h=41f94771b80c9072ec752e69865799a1b6276b64;hb=b9963e1a57135c3e2ab128a9ec4300f0e4886992;hp=17b68935572b6290cb6387d2215755f5fb542bd2;hpb=2b2c661f84feaf3d84eca173353fc4245af361cd;p=lyx.git diff --git a/src/bufferview_funcs.C b/src/bufferview_funcs.C index 17b6893557..41f94771b8 100644 --- a/src/bufferview_funcs.C +++ b/src/bufferview_funcs.C @@ -1,246 +1,316 @@ -/* This file is part of - * ====================================================== +/** + * \file bufferview_funcs.C + * This file is part of LyX, the document processor. + * Licence details can be found in the file COPYING. * - * LyX, The Document Processor + * \author Lars Gullik Bjønnes + * \author Jean-Marc Lasgouttes + * \author John Levon + * \author Angus Leeming + * \author Juergen Vigna * - * Copyright 1995 Matthias Ettrich - * Copyright 1995-2001 The LyX Team. - * - * ====================================================== */ + * Full author contact details are available in file CREDITS. + */ #include -#ifdef __GNUG__ -#pragma implementation -#endif - #include "bufferview_funcs.h" -#include "frontends/LyXView.h" -#include "BufferView.h" -#include "paragraph.h" -#include "lyxfont.h" -#include "lyxtext.h" + +#include "author.h" #include "buffer.h" -#include "lyx_cb.h" -#include "language.h" +#include "bufferparams.h" +#include "BufferView.h" +#include "cursor.h" +#include "coordcache.h" #include "gettext.h" +#include "language.h" +#include "LColor.h" +#include "lyxlex.h" +#include "lyxrow.h" +#include "paragraph.h" #include "ParagraphParameters.h" +#include "pariterator.h" #include "frontends/Alert.h" +#include "frontends/LyXView.h" -#include "support/lstrings.h" +#include "insets/insetcommand.h" +#include "insets/insettext.h" -#include "BoostFormat.h" +#include "support/convert.h" -void emph(BufferView * bv) -{ - LyXFont font(LyXFont::ALL_IGNORE); - font.setEmph(LyXFont::TOGGLE); - toggleAndShow(bv, font); -} +#include +using lyx::support::bformat; + +using std::istringstream; +using std::ostringstream; +using std::string; +using std::vector; -void bold(BufferView * bv) -{ - LyXFont font(LyXFont::ALL_IGNORE); - font.setSeries(LyXFont::BOLD_SERIES); - toggleAndShow(bv, font); -} +namespace bv_funcs { -void noun(BufferView * bv) +// Set data using font and toggle +// If successful, returns true +bool font2string(LyXFont const & font, bool const toggle, string & data) { - LyXFont font(LyXFont::ALL_IGNORE); - font.setNoun(LyXFont::TOGGLE); - toggleAndShow(bv, font); + string lang = "ignore"; + if (font.language()) + lang = font.language()->lang(); + + ostringstream os; + os << "family " << font.family() << '\n' + << "series " << font.series() << '\n' + << "shape " << font.shape() << '\n' + << "size " << font.size() << '\n' + << "emph " << font.emph() << '\n' + << "underbar " << font.underbar() << '\n' + << "noun " << font.noun() << '\n' + << "number " << font.number() << '\n' + << "color " << font.color() << '\n' + << "language " << lang << '\n' + << "toggleall " << convert(toggle); + data = os.str(); + return true; } -void number(BufferView * bv) +// Set font and toggle using data +// If successful, returns true +bool string2font(string const & data, LyXFont & font, bool & toggle) { - LyXFont font(LyXFont::ALL_IGNORE); - font.setNumber(LyXFont::TOGGLE); - toggleAndShow(bv, font); -} + istringstream is(data); + LyXLex lex(0,0); + lex.setStream(is); -void lang(BufferView * bv, string const & l) -{ - LyXFont font(LyXFont::ALL_IGNORE); - Language const * lang = languages.getLanguage(l); - if (lang) { - font.setLanguage(lang); - toggleAndShow(bv, font); - } else - Alert::alert(_("Error! unknown language"),l); -} + int nset = 0; + while (lex.isOK()) { + string token; + if (lex.next()) + token = lex.getString(); + if (token.empty() || !lex.next()) + break; -// Change environment depth. -// if decInc >= 0, increment depth -// if decInc < 0, decrement depth -void changeDepth(BufferView * bv, LyXText * text, int decInc) -{ - if (!bv->available() || !text) - return; + if (token == "family") { + int const next = lex.getInteger(); + font.setFamily(LyXFont::FONT_FAMILY(next)); + + } else if (token == "series") { + int const next = lex.getInteger(); + font.setSeries(LyXFont::FONT_SERIES(next)); + + } else if (token == "shape") { + int const next = lex.getInteger(); + font.setShape(LyXFont::FONT_SHAPE(next)); + + } else if (token == "size") { + int const next = lex.getInteger(); + font.setSize(LyXFont::FONT_SIZE(next)); + + } else if (token == "emph" || token == "underbar" || + token == "noun" || token == "number") { + + int const next = lex.getInteger(); + LyXFont::FONT_MISC_STATE const misc = + LyXFont::FONT_MISC_STATE(next); + + if (token == "emph") + font.setEmph(misc); + else if (token == "underbar") + font.setUnderbar(misc); + else if (token == "noun") + font.setNoun(misc); + else if (token == "number") + font.setNumber(misc); + + } else if (token == "color") { + int const next = lex.getInteger(); + font.setColor(LColor::color(next)); + + } else if (token == "language") { + string const next = lex.getString(); + if (next == "ignore") + font.setLanguage(ignore_language); + else + font.setLanguage(languages.getLanguage(next)); + + } else if (token == "toggleall") { + toggle = lex.getBool(); + + } else { + // Unrecognised token + break; + } - bv->hideCursor(); - bv->update(bv->text, BufferView::SELECT|BufferView::FITCUR); - if (decInc >= 0) - text->incDepth(bv); - else - text->decDepth(bv); - if (text->inset_owner) - bv->updateInset((Inset *)text->inset_owner, true); - bv->update(bv->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + ++nset; + } + return (nset > 0); } -void code(BufferView * bv) +// the next two should probably go elsewhere +// this give the position relative to (0, baseline) of outermost +// paragraph +Point coordOffset(DocIterator const & dit, bool boundary) { - LyXFont font(LyXFont::ALL_IGNORE); - font.setFamily(LyXFont::TYPEWRITER_FAMILY); // no good - toggleAndShow(bv, font); + int x = 0; + int y = 0; + + // Contribution of nested insets + for (size_t i = 1; i != dit.depth(); ++i) { + CursorSlice const & sl = dit[i]; + int xx = 0; + int yy = 0; + //FIXME: the check for asMathInset() shouldn't be necessary + // but math insets do not return a sensible editable() state yet. + if (sl.inset().asMathInset() + || sl.inset().editable() == InsetBase::HIGHLY_EDITABLE) + sl.inset().cursorPos(sl, boundary && ((i+1) == dit.depth()), xx, yy); + x += xx; + y += yy; + //lyxerr << "LCursor::getPos, i: " + // << i << " x: " << xx << " y: " << y << endl; + } + + // Add contribution of initial rows of outermost paragraph + CursorSlice const & sl = dit[0]; + Paragraph const & par = sl.text()->getPar(sl.pit()); + y -= par.rows()[0].ascent(); +#if 1 + size_t rend; + if (sl.pos() > 0 && dit.depth() == 1) { + int pos = sl.pos(); + if (pos && boundary) + --pos; +// lyxerr << "coordOffset: boundary:" << boundary << " depth:" << dit.depth() << " pos:" << pos << " sl.pos:" << sl.pos() << std::endl; + rend = par.pos2row(pos); + } else + rend = par.pos2row(sl.pos()); +#else + size_t rend = par.pos2row(sl.pos()); +#endif + for (size_t rit = 0; rit != rend; ++rit) + y += par.rows()[rit].height(); + y += par.rows()[rend].ascent(); + x += dit.bottom().text()->cursorX(dit.bottom(), boundary && dit.depth() == 1); + // The following correction should not be there at all. + // The cursor looks much better with the -1, though. + --x; + return Point(x, y); } -void sans(BufferView * bv) +Point getPos(DocIterator const & dit, bool boundary) { - LyXFont font(LyXFont::ALL_IGNORE); - font.setFamily(LyXFont::SANS_FAMILY); - toggleAndShow(bv, font); + CursorSlice const & bot = dit.bottom(); + CoordCache::InnerParPosCache const & cache = + theCoords.getParPos().find(bot.text())->second; + CoordCache::InnerParPosCache::const_iterator it = cache.find(bot.pit()); + if (it == cache.end()) { + //lyxerr << "cursor out of view" << std::endl; + return Point(-1, -1); + } + Point p = coordOffset(dit, boundary); // offset from outer paragraph + p.y_ += it->second.y_; + return p; } -void roman(BufferView * bv) +// this could be used elsewhere as well? +CurStatus status(BufferView const * bv, DocIterator const & dit) { - LyXFont font(LyXFont::ALL_IGNORE); - font.setFamily(LyXFont::ROMAN_FAMILY); - toggleAndShow(bv, font); + CoordCache::InnerParPosCache const & cache = theCoords.getParPos().find(dit.bottom().text())->second; + + if (cache.find(dit.bottom().pit()) != cache.end()) + return CUR_INSIDE; + else if (dit.bottom().pit() < bv->anchor_ref()) + return CUR_ABOVE; + else + return CUR_BELOW; } +namespace { -void styleReset(BufferView * bv) +bool findNextInset(DocIterator & dit, + vector const & codes, + string const & contents) { - LyXFont font(LyXFont::ALL_INHERIT, ignore_language); - toggleAndShow(bv, font); + DocIterator tmpdit = dit; + + while (tmpdit) { + InsetBase const * inset = tmpdit.nextInset(); + if (inset + && find(codes.begin(), codes.end(), inset->lyxCode()) != codes.end() + && (contents.empty() || + static_cast(inset)->getContents() == contents)) { + dit = tmpdit; + return true; + } + tmpdit.forwardInset(); + } + + return false; } +} // namespace anon + -void underline(BufferView * bv) +bool findInset(DocIterator & dit, vector const & codes, + bool same_content) { - LyXFont font(LyXFont::ALL_IGNORE); - font.setUnderbar(LyXFont::TOGGLE); - toggleAndShow(bv, font); + string contents; + DocIterator tmpdit = dit; + tmpdit.forwardInset(); + + if (same_content) { + InsetBase const * inset = tmpdit.nextInset(); + if (inset + && find(codes.begin(), codes.end(), inset->lyxCode()) != codes.end()) { + contents = static_cast(inset)->getContents(); + } + } + + if (!findNextInset(tmpdit, codes, contents)) { + if (dit.depth() != 1 || dit.pit() != 0 || dit.pos() != 0) { + tmpdit = doc_iterator_begin(tmpdit.bottom().inset()); + if (!findNextInset(tmpdit, codes, contents)) { + return false; + } + } else + return false; + } + + dit = tmpdit; + return true; } -void fontSize(BufferView * bv, string const & size) +void findInset(DocIterator & dit, InsetBase_code code, bool same_content) { - LyXFont font(LyXFont::ALL_IGNORE); - font.setLyXSize(size); - toggleAndShow(bv, font); + findInset(dit, vector(1, code), same_content); } -// Returns the current font and depth as a message. -string const currentState(BufferView * bv) +void gotoInset(BufferView * bv, vector const & codes, + bool same_content) { - ostringstream state; - - if (!bv->available()) - return ""; - - // I think we should only show changes from the default - // font. (Asger) - LyXText * text = bv->getLyXText(); - Buffer * buffer = bv->buffer(); - LyXFont font = text->real_current_font; - LyXFont const & defaultfont = - buffer->params.getLyXTextClass().defaultfont(); - font.reduce(defaultfont); - -#if USE_BOOST_FORMAT - state << boost::format(_("Font: %1$s")) % font.stateText(&buffer->params); -#else - state << _("Font: ") << font.stateText(&buffer->params); -#endif - - // The paragraph depth - int depth = text->getDepth(); - if (depth > 0) { -#if USE_BOOST_FORMAT - state << boost::format(_(", Depth: %1$d")) % depth; -#else - state << _(", Depth: ") << depth; -#endif + LCursor tmpcur = bv->cursor(); + if (!findInset(tmpcur, codes, same_content)) { + bv->cursor().message(_("No more insets")); + return; } - - // The paragraph spacing, but only if different from - // buffer spacing. - if (!text->cursor.par()->params().spacing().isDefault()) { - Spacing::Space cur_space = - text->cursor.par()->params().spacing().getSpace(); - state << _(", Spacing: "); - - switch (cur_space) { - case Spacing::Single: - state << _("Single"); - break; - case Spacing::Onehalf: - state << _("OneHalf"); - break; - case Spacing::Double: - state << _("Double"); - break; - case Spacing::Other: - state << _("Other (") - << text->cursor.par()->params().spacing().getValue() - << ')'; - break; - case Spacing::Default: - // should never happen, do nothing - break; - } - } -#ifdef DEVEL_VERSION - state << _(", Paragraph: ") << text->cursor.par()->id(); -#endif - return STRCONV(state.str()); + tmpcur.clearSelection(); + bv->setCursor(tmpcur); } -/* Does the actual toggle job of the calls above. - * Also shows the current font state. - */ -void toggleAndShow(BufferView * bv, LyXFont const & font, bool toggleall) +void gotoInset(BufferView * bv, InsetBase_code code, bool same_content) { - if (!bv->available()) - return; - - if (bv->theLockingInset()) { - bv->theLockingInset()->setFont(bv, font, toggleall); - return; - } + gotoInset(bv, vector(1, code), same_content); +} - LyXText * text = bv->getLyXText(); - // FIXME: can this happen ?? - if (!text) - return; - bv->hideCursor(); - bv->update(text, BufferView::SELECT | BufferView::FITCUR); - text->toggleFree(bv, font, toggleall); - bv->update(text, BufferView::SELECT | BufferView::FITCUR | BufferView::CHANGE); - - if (font.language() != ignore_language || - font.number() != LyXFont::IGNORE) { - LyXCursor & cursor = text->cursor; - text->computeBidiTables(bv->buffer(), cursor.row()); - if (cursor.boundary() != - text->isBoundary(bv->buffer(), cursor.par(), cursor.pos(), - text->real_current_font)) - text->setCursor(bv, cursor.par(), cursor.pos(), - false, !cursor.boundary()); - } -} +} // namespace bv_funcs