#include "BufferParams.h"
#include "BufferView.h"
#include "BufferParams.h"
+#include "ColorSet.h"
#include "Counters.h"
#include "Cursor.h"
#include "DispatchResult.h"
#include "InsetIterator.h"
#include "LaTeXFeatures.h"
#include "Lexer.h"
-#include "MetricsInfo.h"
+#include "LyXRC.h"
#include "OutputParams.h"
#include "ParIterator.h"
#include "TextClass.h"
#include "support/debug.h"
#include "support/docstream.h"
#include "support/gettext.h"
+#include "support/lstrings.h"
#include "support/Translator.h"
#include "frontends/Application.h"
namespace {
typedef Translator<string, InsetNoteParams::Type> NoteTranslator;
-typedef Translator<docstring, InsetNoteParams::Type> NoteTranslatorLoc;
NoteTranslator const init_notetranslator()
{
}
-NoteTranslatorLoc const init_notetranslator_loc()
-{
- NoteTranslatorLoc translator(_("Note[[InsetNote]]"), InsetNoteParams::Note);
- translator.addPair(_("Comment"), InsetNoteParams::Comment);
- translator.addPair(_("Greyed out"), InsetNoteParams::Greyedout);
- return translator;
-}
-
-
NoteTranslator const & notetranslator()
{
- static NoteTranslator translator = init_notetranslator();
+ static NoteTranslator const translator = init_notetranslator();
return translator;
}
-NoteTranslatorLoc const & notetranslator_loc()
-{
- static NoteTranslatorLoc translator = init_notetranslator_loc();
- return translator;
-}
-
} // anon
-
-
InsetNoteParams::InsetNoteParams()
: type(Note)
{}
/////////////////////////////////////////////////////////////////////
//
-// InsetNode
+// InsetNote
//
/////////////////////////////////////////////////////////////////////
-InsetNote::InsetNote(Buffer const & buf, string const & label)
+InsetNote::InsetNote(Buffer * buf, string const & label)
: InsetCollapsable(buf)
{
params_.type = notetranslator().find(label);
}
-docstring InsetNote::editMessage() const
-{
- return _("Opened Note Inset");
-}
-
-
-docstring InsetNote::name() const
+docstring InsetNote::layoutName() const
{
return from_ascii("Note:" + notetranslator().find(params_.type));
}
}
-void InsetNote::setButtonLabel()
-{
- docstring const label = notetranslator_loc().find(params_.type);
- setLabel(label);
-}
-
-
bool InsetNote::showInsetDialog(BufferView * bv) const
{
bv->showDialog("note", params2string(params()),
void InsetNote::doDispatch(Cursor & cur, FuncRequest & cmd)
{
- switch (cmd.action) {
-
- case LFUN_INSET_MODIFY:
+ switch (cmd.action()) {
+
+ case LFUN_INSET_MODIFY: {
+ // Do not do anything if converting to the same type of Note.
+ // A quick break here is done instead of disabling the LFUN
+ // because disabling the LFUN would lead to a greyed out
+ // entry, which might confuse users.
+ // In the future, we might want to have a radio button for
+ // switching between notes.
+ InsetNoteParams params;
+ string2params(to_utf8(cmd.argument()), params);
+ if (params_.type == params.type)
+ break;
+
+ cur.recordUndoInset(this);
string2params(to_utf8(cmd.argument()), params_);
- // get a bp from cur:
- setLayout(cur.buffer().params());
+ setButtonLabel();
+ // what we really want here is a TOC update, but that means
+ // a full buffer update
+ cur.forceBufferUpdate();
break;
+ }
case LFUN_INSET_DIALOG_UPDATE:
cur.bv().updateDialog("note", params2string(params()));
bool InsetNote::getStatus(Cursor & cur, FuncRequest const & cmd,
FuncStatus & flag) const
{
- switch (cmd.action) {
+ switch (cmd.action()) {
case LFUN_INSET_MODIFY:
// disallow comment and greyed out in commands
}
-void InsetNote::addToToc(DocIterator const & cpit)
+void InsetNote::addToToc(DocIterator const & cpit, bool output_active,
+ UpdateType utype) const
{
DocIterator pit = cpit;
- pit.push_back(CursorSlice(*this));
+ pit.push_back(CursorSlice(const_cast<InsetNote &>(*this)));
- Toc & toc = buffer().tocBackend().toc("note");
+ InsetLayout const & il = getLayout();
docstring str;
- str = notetranslator_loc().find(params_.type) + from_ascii(": ")
- + getNewLabel(str);
- toc.push_back(TocItem(pit, 0, str));
+ text().forOutliner(str, TOC_ENTRY_LENGTH);
+ str = translateIfPossible(il.labelstring()) + ": " + str;
+
+ shared_ptr<Toc> toc = buffer().tocBackend().toc("note");
+ toc->push_back(TocItem(pit, 0, str, output_active));
+
// Proceed with the rest of the inset.
- InsetCollapsable::addToToc(cpit);
+ bool doing_output = output_active && producesOutput();
+ InsetCollapsable::addToToc(cpit, doing_output, utype);
}
}
-int InsetNote::latex(odocstream & os, OutputParams const & runparams_in) const
+void InsetNote::latex(otexstream & os, OutputParams const & runparams_in) const
{
if (params_.type == InsetNoteParams::Note)
- return 0;
+ return;
OutputParams runparams(runparams_in);
if (params_.type == InsetNoteParams::Comment) {
runparams.exportdata.reset(new ExportData);
}
- odocstringstream ss;
- InsetCollapsable::latex(ss, runparams);
// the space after the comment in 'a[comment] b' will be eaten by the
// comment environment since the space before b is ignored with the
// following latex output:
// b
//
// Adding {} before ' b' fixes this.
- if (params_.type == InsetNoteParams::Comment)
- ss << "{}";
+ // The {} will be automatically added, but only if needed, for all
+ // insets whose InsetLayout Display tag is false. This is achieved
+ // by telling otexstream to protect an immediately following space
+ // and is done for both comment and greyedout insets.
+ InsetCollapsable::latex(os, runparams);
- docstring const str = ss.str();
- os << str;
runparams_in.encoding = runparams.encoding;
- // Return how many newlines we issued.
- return int(count(str.begin(), str.end(), '\n'));
}
-int InsetNote::plaintext(odocstream & os,
- OutputParams const & runparams_in) const
+int InsetNote::plaintext(odocstringstream & os,
+ OutputParams const & runparams_in, size_t max_length) const
{
if (params_.type == InsetNoteParams::Note)
return 0;
runparams.exportdata.reset(new ExportData);
}
os << '[' << buffer().B_("note") << ":\n";
- InsetText::plaintext(os, runparams);
+ InsetText::plaintext(os, runparams, max_length);
os << "\n]";
return PLAINTEXT_NEWLINE + 1; // one char on a separate line
}
+docstring InsetNote::xhtml(XHTMLStream & xs, OutputParams const & rp) const
+{
+ if (params_.type == InsetNoteParams::Note)
+ return docstring();
+
+ return InsetCollapsable::xhtml(xs, rp);
+}
+
+
void InsetNote::validate(LaTeXFeatures & features) const
{
- if (params_.type == InsetNoteParams::Comment)
- features.require("verbatim");
- if (params_.type == InsetNoteParams::Greyedout) {
- features.require("color");
- features.require("lyxgreyedout");
+ switch (params_.type) {
+ case InsetNoteParams::Comment:
+ if (features.runparams().flavor == OutputParams::HTML)
+ // we do output this but set display to "none" by default,
+ // but people might want to use it.
+ InsetCollapsable::validate(features);
+ else
+ // Only do the requires
+ features.useInsetLayout(getLayout());
+ break;
+ case InsetNoteParams::Greyedout:
+ InsetCollapsable::validate(features);
+ break;
+ case InsetNoteParams::Note:
+ break;
}
- InsetText::validate(features);
}
-docstring InsetNote::contextMenu(BufferView const &, int, int) const
+string InsetNote::contextMenuName() const
{
- return from_ascii("context-note");
+ return "context-note";
+}
+
+bool InsetNote::allowSpellCheck() const
+{
+ return (params_.type == InsetNoteParams::Greyedout || lyxrc.spellcheck_notes);
+}
+
+FontInfo InsetNote::getFont() const
+{
+ FontInfo font = getLayout().font();
+ // FIXME: This hardcoded color is a hack!
+ if (params_.type == InsetNoteParams::Greyedout
+ && buffer().params().notefontcolor != lyx::rgbFromHexName("#cccccc")) {
+ ColorCode c = lcolor.getFromLyXName("notefontcolor");
+ if (c != Color_none)
+ font.setColor(c);
+ }
+ return font;
}
Lexer lex;
lex.setStream(data);
lex.setContext("InsetNote::string2params");
- lex >> "note" >> "Note";
+ lex >> "note";
+ // There are cases, such as when we are called via getStatus() from
+ // Dialog::canApply(), where we are just called with "note" rather
+ // than a full "note Note TYPE".
+ if (!lex.isOK())
+ return;
+ lex >> "Note";
params.read(lex);
}
-bool mutateNotes(Cursor & cur, string const & source, string const &target)
-{
- InsetNoteParams::Type typeSrc = notetranslator().find(source);
- InsetNoteParams::Type typeTrt = notetranslator().find(target);
- // syntax check of arguments
- string sSrc = notetranslator().find(typeSrc);
- string sTrt = notetranslator().find(typeTrt);
- if ((sSrc != source) || (sTrt != target))
- return false;
-
- // did we found some conforming inset?
- bool ret = false;
-
- cur.beginUndoGroup();
- Inset & inset = cur.buffer().inset();
- InsetIterator it = inset_iterator_begin(inset);
- InsetIterator const end = inset_iterator_end(inset);
- for (; it != end; ++it) {
- if (it->lyxCode() == NOTE_CODE) {
- InsetNote & ins = static_cast<InsetNote &>(*it);
- if (ins.params().type == typeSrc) {
- cur.buffer().undo().recordUndo(it);
- FuncRequest fr(LFUN_INSET_MODIFY, "note Note " + target);
- ins.dispatch(cur, fr);
- ret = true;
- }
- }
- }
- cur.endUndoGroup();
-
- return ret;
-}
} // namespace lyx