X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fbufferview_funcs.C;h=feec11d5e8e02cae6c9f11b1e73aca4eed7044c0;hb=0de182f2571c1ab327843cc281bc1f5302058e26;hp=c65b91173560184c7e5d362bffce3c08d7625e62;hpb=54e7ddb5d9a348ae9cfc60f399e9c0c2658ab4c5;p=lyx.git diff --git a/src/bufferview_funcs.C b/src/bufferview_funcs.C index c65b911735..feec11d5e8 100644 --- a/src/bufferview_funcs.C +++ b/src/bufferview_funcs.C @@ -1,32 +1,185 @@ -/* This file is part of - * ====================================================== - * - * LyX, The Document Processor - * - * Copyright 1995 Matthias Ettrich - * Copyright 1995-2001 The LyX Team. +/** + * \file bufferview_funcs.C + * This file is part of LyX, the document processor. + * Licence details can be found in the file COPYING. * - * ====================================================== */ + * \author Lars Gullik Bjønnes + * \author Jean-Marc Lasgouttes + * \author John Levon + * \author Angus Leeming + * + * Full author contact details are available in file CREDITS + */ #include -#ifdef __GNUG__ -#pragma implementation -#endif - #include "bufferview_funcs.h" -#include "LyXView.h" #include "BufferView.h" #include "paragraph.h" #include "lyxfont.h" -#include "lyx_gui_misc.h" +#include "lyxlex.h" #include "lyxtext.h" #include "buffer.h" -#include "support/lstrings.h" #include "lyx_cb.h" #include "language.h" #include "gettext.h" #include "ParagraphParameters.h" +#include "author.h" +#include "changes.h" + +#include "frontends/LyXView.h" +#include "frontends/Alert.h" + +#include "support/lstrings.h" +#include "Lsstream.h" + +#include "insets/updatableinset.h" + +#include "BoostFormat.h" + +namespace { +LyXFont freefont(LyXFont::ALL_IGNORE); +bool toggleall(false); +} + + +// Set data using font and toggle +// If successful, returns true +bool font2string(LyXFont const & font, bool toggle, string & data) +{ + 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 " << tostr(toggle); + data = os.str(); + return true; +} + + +// Set font and toggle using data +// If successful, returns true +bool string2font(string const & data, LyXFont & font, bool & toggle) +{ + istringstream is(data); + LyXLex lex(0,0); + lex.setStream(is); + + int Int = 0; + bool Bool = false; + string String; + + int nset = 0; + while (lex.isOK()) { + lex.next(); + string const token = lex.getString(); + + if (token == "family" || + token == "series" || + token == "shape" || + token == "size" || + token == "emph" || + token == "underbar" || + token == "noun" || + token == "number" || + token == "color") { + lex.next(); + Int = lex.getInteger(); + } else if (token == "language") { + lex.next(); + String = lex.getString(); + } else if (token == "toggleall") { + lex.next(); + Bool = lex.getBool(); + } else { + // Unrecognised token + break; + } + + if (!lex.isOK()) + break; + ++nset; + + if (token == "family") { + font.setFamily(static_cast(Int)); + + } else if (token == "series") { + font.setSeries(static_cast(Int)); + + } else if (token == "shape") { + font.setShape(static_cast(Int)); + + } else if (token == "size") { + font.setSize(static_cast(Int)); + + } else if (token == "emph") { + font.setEmph(static_cast(Int)); + + } else if (token == "underbar") { + font.setUnderbar(static_cast(Int)); + + } else if (token == "noun") { + font.setNoun(static_cast(Int)); + + } else if (token == "number") { + font.setNumber(static_cast(Int)); + + } else if (token == "color") { + font.setColor(static_cast(Int)); + + } else if (token == "language") { + if (String == "ignore") + font.setLanguage(ignore_language); + else + font.setLanguage(languages.getLanguage(String)); + + } else if (token == "toggleall") { + toggle = Bool; + } + } + return (nset > 0); +} + + +string const freefont2string() +{ + string data; + if (font2string(freefont, toggleall, data)) + return data; + return string(); +} + + +void update_and_apply_freefont(BufferView * bv, string const & data) +{ + LyXFont font; + bool toggle; + if (string2font(data, font, toggle)) { + freefont = font; + toggleall = toggle; + apply_freefont(bv); + } +} + + +void apply_freefont(BufferView * bv) +{ + toggleAndShow(bv, freefont, toggleall); + bv->owner()->view_state_changed(); + bv->buffer()->markDirty(); + bv->owner()->message(_("Character set")); +} void emph(BufferView * bv) @@ -68,18 +221,18 @@ void lang(BufferView * bv, string const & l) font.setLanguage(lang); toggleAndShow(bv, font); } else - WriteAlert(_("Error! unknown language"),l); + Alert::alert(_("Error! unknown language"),l); } // Change environment depth. // if decInc >= 0, increment depth -// if decInc < 0, decrement depth +// if decInc < 0, decrement depth void changeDepth(BufferView * bv, LyXText * text, int decInc) { if (!bv->available() || !text) return; - + bv->hideCursor(); bv->update(bv->text, BufferView::SELECT|BufferView::FITCUR); if (decInc >= 0) @@ -87,10 +240,8 @@ void changeDepth(BufferView * bv, LyXText * text, int decInc) else text->decDepth(bv); if (text->inset_owner) - bv->updateInset((Inset *)text->inset_owner, true); + bv->updateInset((Inset *)text->inset_owner, true); bv->update(bv->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - bv->owner()->message(_("Changed environment depth " - "(in possible range, maybe not)")); } @@ -120,7 +271,7 @@ void roman(BufferView * bv) void styleReset(BufferView * bv) { - LyXFont font(LyXFont::ALL_INHERIT); + LyXFont font(LyXFont::ALL_INHERIT, ignore_language); toggleAndShow(bv, font); } @@ -141,93 +292,123 @@ void fontSize(BufferView * bv, string const & size) } -// Returns the current font and depth as a message. +// Returns the current font and depth as a message. string const currentState(BufferView * bv) { + if (!bv->available()) + return string(); + ostringstream state; - if (bv->available()) { - // 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 = - textclasslist - .TextClass(buffer->params.textclass) - .defaultfont(); - font.reduce(defaultfont); - - state << _("Font:") << ' ' - << font.stateText(&buffer->params); - - // The paragraph depth - int depth = text->getDepth(); - if (depth > 0) - state << _(", Depth: ") << depth; - - // 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; - } + LyXText * text = bv->getLyXText(); + Buffer * buffer = bv->buffer(); + LyXCursor const & c(text->cursor); + + bool const show_change = buffer->params.tracking_changes + && c.pos() != c.par()->size() + && c.par()->lookupChange(c.pos()) != Change::UNCHANGED; + + if (show_change) { + Change change(c.par()->lookupChangeFull(c.pos())); + Author const & a(bv->buffer()->authors().get(change.author)); + state << _("Change: ") << a.name(); + if (!a.email().empty()) { + state << " (" << a.email() << ")"; } + if (change.changetime) + state << _(" at ") << ctime(&change.changetime); + state << " : "; } - return state.str().c_str(); + + // I think we should only show changes from the default + // font. (Asger) + 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 + } + + + // 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()); } -/* -------> Does the actual toggle job of the XxxCB() calls above. +/* Does the actual toggle job of the calls above. * Also shows the current font state. */ void toggleAndShow(BufferView * bv, LyXFont const & font, bool toggleall) { - if (bv->available()) { - if (bv->theLockingInset()) { - bv->theLockingInset()->setFont(bv, font, toggleall); - return; - } - LyXText * text = bv->getLyXText(); - 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()); - } + if (!bv->available()) + return; + + if (bv->theLockingInset()) { + bv->theLockingInset()->setFont(bv, font, toggleall); + return; + } + + 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()); } }