src/insets/InsetNote.cpp

   1 /**
   2  * \file InsetNote.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Angus Leeming
   7  * \author Martin Vermeer
   8  * \author Jürgen Spitzmüller
   9  *
  10  * Full author contact details are available in file CREDITS.
  11  */
  12
  13 #include <config.h>
  14
  15 #include "InsetNote.h"
  16
  17 #include "Buffer.h"
  18 #include "BufferParams.h"
  19 #include "BufferView.h"
  20 #include "ColorSet.h"
  21 #include "Cursor.h"
  22 #include "DispatchResult.h"
  23 #include "Exporter.h"
  24 #include "FuncRequest.h"
  25 #include "FuncStatus.h"
  26 #include "LaTeXFeatures.h"
  27 #include "Lexer.h"
  28 #include "LyXRC.h"
  29 #include "OutputParams.h"
  30 #include "output_docbook.h"
  31 #include "ParIterator.h"
  32 #include "TextClass.h"
  33 #include "TocBackend.h"
  34
  35 #include "support/debug.h"
  36 #include "support/docstream.h"
  37 #include "support/gettext.h"
  38 #include "support/lstrings.h"
  39 #include "support/Translator.h"
  40
  41 #include "frontends/Application.h"
  42
  43 #include <algorithm>
  44 #include <sstream>
  45
  46 using namespace std;
  47
  48 namespace lyx {
  49
  50 namespace {
  51
  52 typedef Translator<string, InsetNoteParams::Type> NoteTranslator;
  53
  54 NoteTranslator const init_notetranslator()
  55 {
  56         NoteTranslator translator("Note", InsetNoteParams::Note);
  57         translator.addPair("Comment", InsetNoteParams::Comment);
  58         translator.addPair("Greyedout", InsetNoteParams::Greyedout);
  59         return translator;
  60 }
  61
  62
  63 NoteTranslator const & notetranslator()
  64 {
  65         static NoteTranslator const translator = init_notetranslator();
  66         return translator;
  67 }
  68
  69
  70 } // namespace
  71
  72
  73 InsetNoteParams::InsetNoteParams()
  74         : type(Note)
  75 {}
  76
  77
  78 void InsetNoteParams::write(ostream & os) const
  79 {
  80         string const label = notetranslator().find(type);
  81         os << "Note " << label << "\n";
  82 }
  83
  84
  85 void InsetNoteParams::read(Lexer & lex)
  86 {
  87         string label;
  88         lex >> label;
  89         if (lex)
  90                 type = notetranslator().find(label);
  91 }
  92
  93
  94 /////////////////////////////////////////////////////////////////////
  95 //
  96 // InsetNote
  97 //
  98 /////////////////////////////////////////////////////////////////////
  99
 100 InsetNote::InsetNote(Buffer * buf, string const & label)
 101         : InsetCollapsible(buf)
 102 {
 103         params_.type = notetranslator().find(label);
 104 }
 105
 106
 107 InsetNote::~InsetNote()
 108 {
 109         hideDialogs("note", this);
 110 }
 111
 112
 113 docstring InsetNote::layoutName() const
 114 {
 115         return from_ascii("Note:" + notetranslator().find(params_.type));
 116 }
 117
 118
 119 void InsetNote::write(ostream & os) const
 120 {
 121         params_.write(os);
 122         InsetCollapsible::write(os);
 123 }
 124
 125
 126 void InsetNote::read(Lexer & lex)
 127 {
 128         params_.read(lex);
 129         InsetCollapsible::read(lex);
 130 }
 131
 132
 133 bool InsetNote::showInsetDialog(BufferView * bv) const
 134 {
 135         bv->showDialog("note", params2string(params()),
 136                 const_cast<InsetNote *>(this));
 137         return true;
 138 }
 139
 140
 141 void InsetNote::doDispatch(Cursor & cur, FuncRequest & cmd)
 142 {
 143         switch (cmd.action()) {
 144
 145         case LFUN_INSET_MODIFY: {
 146                 // Do not do anything if converting to the same type of Note.
 147                 // A quick break here is done instead of disabling the LFUN
 148                 // because disabling the LFUN would lead to a greyed out
 149                 // entry, which might confuse users.
 150                 // In the future, we might want to have a radio button for
 151                 // switching between notes.
 152                 InsetNoteParams params;
 153                 string2params(to_utf8(cmd.argument()), params);
 154                 if (params_.type == params.type)
 155                   break;
 156
 157                 cur.recordUndoInset(this);
 158                 string2params(to_utf8(cmd.argument()), params_);
 159                 setButtonLabel();
 160                 // what we really want here is a TOC update, but that means
 161                 // a full buffer update
 162                 cur.forceBufferUpdate();
 163                 break;
 164         }
 165
 166         case LFUN_INSET_DIALOG_UPDATE:
 167                 cur.bv().updateDialog("note", params2string(params()));
 168                 break;
 169
 170         default:
 171                 InsetCollapsible::doDispatch(cur, cmd);
 172                 break;
 173         }
 174 }
 175
 176
 177 bool InsetNote::getStatus(Cursor & cur, FuncRequest const & cmd,
 178                 FuncStatus & flag) const
 179 {
 180         switch (cmd.action()) {
 181
 182         case LFUN_INSET_MODIFY:
 183                 if (cmd.getArg(0) == "note") {
 184                         InsetNoteParams params;
 185                         string2params(to_utf8(cmd.argument()), params);
 186                         flag.setOnOff(params_.type == params.type);
 187                 }
 188                 return true;
 189
 190         case LFUN_INSET_DIALOG_UPDATE:
 191                 flag.setEnabled(true);
 192                 return true;
 193
 194         default:
 195                 return InsetCollapsible::getStatus(cur, cmd, flag);
 196         }
 197 }
 198
 199
 200 bool InsetNote::isMacroScope() const
 201 {
 202         // LyX note has no latex output
 203         if (params_.type == InsetNoteParams::Note)
 204                 return true;
 205
 206         return InsetCollapsible::isMacroScope();
 207 }
 208
 209
 210 void InsetNote::latex(otexstream & os, OutputParams const & runparams_in) const
 211 {
 212         if (params_.type == InsetNoteParams::Note)
 213                 return;
 214
 215         OutputParams runparams(runparams_in);
 216         if (params_.type == InsetNoteParams::Comment) {
 217                 runparams.inComment = true;
 218                 // Ignore files that are exported inside a comment
 219                 runparams.exportdata.reset(new ExportData);
 220         }
 221
 222         // the space after the comment in 'a[comment] b' will be eaten by the
 223         // comment environment since the space before b is ignored with the
 224         // following latex output:
 225         //
 226         // a%
 227         // \begin{comment}
 228         // comment
 229         // \end{comment}
 230         //  b
 231         //
 232         // Adding {} before ' b' fixes this.
 233         // The {} will be automatically added, but only if needed, for all
 234         // insets whose InsetLayout Display tag is false. This is achieved
 235         // by telling otexstream to protect an immediately following space
 236         // and is done for both comment and greyedout insets.
 237         InsetCollapsible::latex(os, runparams);
 238
 239         runparams_in.encoding = runparams.encoding;
 240 }
 241
 242
 243 int InsetNote::plaintext(odocstringstream & os,
 244                          OutputParams const & runparams_in, size_t max_length) const
 245 {
 246         if (params_.type == InsetNoteParams::Note)
 247                 return 0;
 248
 249         OutputParams runparams(runparams_in);
 250         if (params_.type == InsetNoteParams::Comment) {
 251                 runparams.inComment = true;
 252                 // Ignore files that are exported inside a comment
 253                 runparams.exportdata.reset(new ExportData);
 254         }
 255         os << '[' << buffer().B_("note") << ":\n";
 256         InsetText::plaintext(os, runparams, max_length);
 257         os << "\n]";
 258
 259         return PLAINTEXT_NEWLINE + 1; // one char on a separate line
 260 }
 261
 262
 263 void InsetNote::docbook(XMLStream & xs, OutputParams const & runparams_in) const
 264 {
 265         if (params_.type == InsetNoteParams::Note)
 266                 return;
 267
 268         OutputParams runparams(runparams_in);
 269         if (params_.type == InsetNoteParams::Comment) {
 270                 xs << xml::StartTag("remark");
 271                 xs << xml::CR();
 272                 runparams.inComment = true;
 273                 // Ignore files that are exported inside a comment
 274                 runparams.exportdata.reset(new ExportData);
 275         }
 276         // Greyed out text is output as such (no way to mark text as greyed out with DocBook).
 277
 278         InsetText::docbook(xs, runparams);
 279
 280         if (params_.type == InsetNoteParams::Comment) {
 281                 xs << xml::CR();
 282                 xs << xml::EndTag("remark");
 283                 xs << xml::CR();
 284         }
 285 }
 286
 287
 288 docstring InsetNote::xhtml(XMLStream & xs, OutputParams const & rp) const
 289 {
 290         if (params_.type == InsetNoteParams::Note)
 291                 return docstring();
 292
 293         return InsetCollapsible::xhtml(xs, rp);
 294 }
 295
 296
 297 void InsetNote::validate(LaTeXFeatures & features) const
 298 {
 299         switch (params_.type) {
 300         case InsetNoteParams::Comment:
 301                 if (features.runparams().flavor == OutputParams::HTML)
 302                         // we do output this but set display to "none" by default,
 303                         // but people might want to use it.
 304                         InsetCollapsible::validate(features);
 305                 else
 306                         // Only do the requires
 307                         features.useInsetLayout(getLayout());
 308                 break;
 309         case InsetNoteParams::Greyedout:
 310                 if (features.hasRTLLanguage())
 311                         features.require("environ");
 312                 InsetCollapsible::validate(features);
 313                 break;
 314         case InsetNoteParams::Note:
 315                 break;
 316         }
 317 }
 318
 319
 320 string InsetNote::contextMenuName() const
 321 {
 322         return "context-note";
 323 }
 324
 325 bool InsetNote::allowSpellCheck() const
 326 {
 327         return (params_.type == InsetNoteParams::Greyedout || lyxrc.spellcheck_notes);
 328 }
 329
 330 FontInfo InsetNote::getFont() const
 331 {
 332         FontInfo font = getLayout().font();
 333         // FIXME: This hardcoded color is a hack!
 334         if (params_.type == InsetNoteParams::Greyedout
 335             && buffer().params().notefontcolor != lyx::rgbFromHexName("#cccccc")) {
 336                 ColorCode c = lcolor.getFromLyXName("notefontcolor");
 337                 if (c != Color_none)
 338                         font.setColor(c);
 339         }
 340         return font;
 341 }
 342
 343
 344 string InsetNote::params2string(InsetNoteParams const & params)
 345 {
 346         ostringstream data;
 347         data << "note" << ' ';
 348         params.write(data);
 349         return data.str();
 350 }
 351
 352
 353 void InsetNote::string2params(string const & in, InsetNoteParams & params)
 354 {
 355         params = InsetNoteParams();
 356
 357         if (in.empty())
 358                 return;
 359
 360         istringstream data(in);
 361         Lexer lex;
 362         lex.setStream(data);
 363         lex.setContext("InsetNote::string2params");
 364         lex >> "note";
 365         // There are cases, such as when we are called via getStatus() from
 366         // Dialog::canApply(), where we are just called with "note" rather
 367         // than a full "note Note TYPE".
 368         if (!lex.isOK())
 369                 return;
 370         lex >> "Note";
 371
 372         params.read(lex);
 373 }
 374
 375
 376 } // namespace lyx