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 "InsetIterator.h"
  27 #include "LaTeXFeatures.h"
  28 #include "Lexer.h"
  29 #include "LyXRC.h"
  30 #include "OutputParams.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 Inset::DisplayType InsetNote::display() const
 120 {
 121         return Inline;
 122 }
 123
 124
 125 void InsetNote::write(ostream & os) const
 126 {
 127         params_.write(os);
 128         InsetCollapsible::write(os);
 129 }
 130
 131
 132 void InsetNote::read(Lexer & lex)
 133 {
 134         params_.read(lex);
 135         InsetCollapsible::read(lex);
 136 }
 137
 138
 139 bool InsetNote::showInsetDialog(BufferView * bv) const
 140 {
 141         bv->showDialog("note", params2string(params()),
 142                 const_cast<InsetNote *>(this));
 143         return true;
 144 }
 145
 146
 147 void InsetNote::doDispatch(Cursor & cur, FuncRequest & cmd)
 148 {
 149         switch (cmd.action()) {
 150
 151         case LFUN_INSET_MODIFY: {
 152                 // Do not do anything if converting to the same type of Note.
 153                 // A quick break here is done instead of disabling the LFUN
 154                 // because disabling the LFUN would lead to a greyed out
 155                 // entry, which might confuse users.
 156                 // In the future, we might want to have a radio button for
 157                 // switching between notes.
 158                 InsetNoteParams params;
 159                 string2params(to_utf8(cmd.argument()), params);
 160                 if (params_.type == params.type)
 161                   break;
 162
 163                 cur.recordUndoInset(this);
 164                 string2params(to_utf8(cmd.argument()), params_);
 165                 setButtonLabel();
 166                 // what we really want here is a TOC update, but that means
 167                 // a full buffer update
 168                 cur.forceBufferUpdate();
 169                 break;
 170         }
 171
 172         case LFUN_INSET_DIALOG_UPDATE:
 173                 cur.bv().updateDialog("note", params2string(params()));
 174                 break;
 175
 176         default:
 177                 InsetCollapsible::doDispatch(cur, cmd);
 178                 break;
 179         }
 180 }
 181
 182
 183 bool InsetNote::getStatus(Cursor & cur, FuncRequest const & cmd,
 184                 FuncStatus & flag) const
 185 {
 186         switch (cmd.action()) {
 187
 188         case LFUN_INSET_MODIFY:
 189                 if (cmd.getArg(0) == "note") {
 190                         InsetNoteParams params;
 191                         string2params(to_utf8(cmd.argument()), params);
 192                         flag.setOnOff(params_.type == params.type);
 193                 }
 194                 return true;
 195
 196         case LFUN_INSET_DIALOG_UPDATE:
 197                 flag.setEnabled(true);
 198                 return true;
 199
 200         default:
 201                 return InsetCollapsible::getStatus(cur, cmd, flag);
 202         }
 203 }
 204
 205
 206 bool InsetNote::isMacroScope() const
 207 {
 208         // LyX note has no latex output
 209         if (params_.type == InsetNoteParams::Note)
 210                 return true;
 211
 212         return InsetCollapsible::isMacroScope();
 213 }
 214
 215
 216 void InsetNote::latex(otexstream & os, OutputParams const & runparams_in) const
 217 {
 218         if (params_.type == InsetNoteParams::Note)
 219                 return;
 220
 221         OutputParams runparams(runparams_in);
 222         if (params_.type == InsetNoteParams::Comment) {
 223                 runparams.inComment = true;
 224                 // Ignore files that are exported inside a comment
 225                 runparams.exportdata.reset(new ExportData);
 226         }
 227
 228         // the space after the comment in 'a[comment] b' will be eaten by the
 229         // comment environment since the space before b is ignored with the
 230         // following latex output:
 231         //
 232         // a%
 233         // \begin{comment}
 234         // comment
 235         // \end{comment}
 236         //  b
 237         //
 238         // Adding {} before ' b' fixes this.
 239         // The {} will be automatically added, but only if needed, for all
 240         // insets whose InsetLayout Display tag is false. This is achieved
 241         // by telling otexstream to protect an immediately following space
 242         // and is done for both comment and greyedout insets.
 243         InsetCollapsible::latex(os, runparams);
 244
 245         runparams_in.encoding = runparams.encoding;
 246 }
 247
 248
 249 int InsetNote::plaintext(odocstringstream & os,
 250                          OutputParams const & runparams_in, size_t max_length) const
 251 {
 252         if (params_.type == InsetNoteParams::Note)
 253                 return 0;
 254
 255         OutputParams runparams(runparams_in);
 256         if (params_.type == InsetNoteParams::Comment) {
 257                 runparams.inComment = true;
 258                 // Ignore files that are exported inside a comment
 259                 runparams.exportdata.reset(new ExportData);
 260         }
 261         os << '[' << buffer().B_("note") << ":\n";
 262         InsetText::plaintext(os, runparams, max_length);
 263         os << "\n]";
 264
 265         return PLAINTEXT_NEWLINE + 1; // one char on a separate line
 266 }
 267
 268
 269 int InsetNote::docbook(odocstream & os, OutputParams const & runparams_in) const
 270 {
 271         if (params_.type == InsetNoteParams::Note)
 272                 return 0;
 273
 274         OutputParams runparams(runparams_in);
 275         if (params_.type == InsetNoteParams::Comment) {
 276                 os << "<remark>\n";
 277                 runparams.inComment = true;
 278                 // Ignore files that are exported inside a comment
 279                 runparams.exportdata.reset(new ExportData);
 280         }
 281
 282         int const n = InsetText::docbook(os, runparams);
 283
 284         if (params_.type == InsetNoteParams::Comment)
 285                 os << "\n</remark>\n";
 286
 287         // Return how many newlines we issued.
 288         //return int(count(str.begin(), str.end(), '\n'));
 289         return n + 1 + 2;
 290 }
 291
 292
 293 docstring InsetNote::xhtml(XHTMLStream & xs, OutputParams const & rp) const
 294 {
 295         if (params_.type == InsetNoteParams::Note)
 296                 return docstring();
 297
 298         return InsetCollapsible::xhtml(xs, rp);
 299 }
 300
 301
 302 void InsetNote::validate(LaTeXFeatures & features) const
 303 {
 304         switch (params_.type) {
 305         case InsetNoteParams::Comment:
 306                 if (features.runparams().flavor == OutputParams::HTML)
 307                         // we do output this but set display to "none" by default,
 308                         // but people might want to use it.
 309                         InsetCollapsible::validate(features);
 310                 else
 311                         // Only do the requires
 312                         features.useInsetLayout(getLayout());
 313                 break;
 314         case InsetNoteParams::Greyedout:
 315                 InsetCollapsible::validate(features);
 316                 break;
 317         case InsetNoteParams::Note:
 318                 break;
 319         }
 320 }
 321
 322
 323 string InsetNote::contextMenuName() const
 324 {
 325         return "context-note";
 326 }
 327
 328 bool InsetNote::allowSpellCheck() const
 329 {
 330         return (params_.type == InsetNoteParams::Greyedout || lyxrc.spellcheck_notes);
 331 }
 332
 333 FontInfo InsetNote::getFont() const
 334 {
 335         FontInfo font = getLayout().font();
 336         // FIXME: This hardcoded color is a hack!
 337         if (params_.type == InsetNoteParams::Greyedout
 338             && buffer().params().notefontcolor != lyx::rgbFromHexName("#cccccc")) {
 339                 ColorCode c = lcolor.getFromLyXName("notefontcolor");
 340                 if (c != Color_none)
 341                         font.setColor(c);
 342         }
 343         return font;
 344 }
 345
 346
 347 string InsetNote::params2string(InsetNoteParams const & params)
 348 {
 349         ostringstream data;
 350         data << "note" << ' ';
 351         params.write(data);
 352         return data.str();
 353 }
 354
 355
 356 void InsetNote::string2params(string const & in, InsetNoteParams & params)
 357 {
 358         params = InsetNoteParams();
 359
 360         if (in.empty())
 361                 return;
 362
 363         istringstream data(in);
 364         Lexer lex;
 365         lex.setStream(data);
 366         lex.setContext("InsetNote::string2params");
 367         lex >> "note";
 368         // There are cases, such as when we are called via getStatus() from
 369         // Dialog::canApply(), where we are just called with "note" rather
 370         // than a full "note Note TYPE".
 371         if (!lex.isOK())
 372                 return;
 373         lex >> "Note";
 374
 375         params.read(lex);
 376 }
 377
 378
 379 } // namespace lyx