src/buffer.h

   1 // -*- C++ -*-
   2 /**
   3  * \file buffer.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author Lars Gullik Bjønnes
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #ifndef BUFFER_H
  13 #define BUFFER_H
  14
  15 #include "errorlist.h"
  16 #include "InsetList.h"
  17
  18 #include "dociterator.h"
  19 #include "ParagraphList_fwd.h"
  20
  21 #include "support/filename.h"
  22 #include "support/limited_stack.h"
  23 #include "support/types.h"
  24 #include "support/docstring.h"
  25 #include "support/docstream.h"
  26
  27 #include <boost/scoped_ptr.hpp>
  28 #include <boost/signal.hpp>
  29
  30 #include <iosfwd>
  31 #include <string>
  32 #include <map>
  33 #include <utility>
  34 #include <vector>
  35
  36
  37 namespace lyx {
  38
  39 class BufferParams;
  40 class ErrorItem;
  41 class FuncRequest;
  42 class InsetBase;
  43 class InsetText;
  44 class LyXFont;
  45 class LyXLex;
  46 class LyXRC;
  47 class LyXText;
  48 class LyXVC;
  49 class LaTeXFeatures;
  50 class Language;
  51 class MacroData;
  52 class OutputParams;
  53 class ParConstIterator;
  54 class ParIterator;
  55 class TeXErrors;
  56 class TexRow;
  57 class TocBackend;
  58 class Undo;
  59 class StableDocIterator;
  60
  61
  62 /** The buffer object.
  63  * This is the buffer object. It contains all the informations about
  64  * a document loaded into LyX.
  65  * The buffer object owns the LyXText (wrapped in an InsetText), which
  66  * contains the individual paragraphs of the document.
  67  *
  68  *
  69  * I am not sure if the class is complete or
  70  * minimal, probably not.
  71  * \author Lars Gullik Bjønnes
  72   */
  73 class Buffer {
  74 public:
  75         /// What type of log will \c getLogName() return?
  76         enum LogType {
  77                 latexlog, ///< LaTeX log
  78                 buildlog  ///< Literate build log
  79         };
  80
  81         /// Result of \c readFile()
  82         enum ReadStatus {
  83                 failure, ///< The file could not be read
  84                 success, ///< The file could not be read
  85                 wrongversion ///< The version of the file does not match ours
  86         };
  87
  88         /** Constructor
  89             \param file
  90             \param b  optional \c false by default
  91         */
  92         explicit Buffer(std::string const & file, bool b = false);
  93
  94         /// Destructor
  95         ~Buffer();
  96
  97         /** High-level interface to buffer functionality.
  98             This function parses a command string and executes it
  99         */
 100         bool dispatch(std::string const & command, bool * result = 0);
 101
 102         /// Maybe we know the function already by number...
 103         bool dispatch(FuncRequest const & func, bool * result = 0);
 104
 105         /// Load the autosaved file.
 106         void loadAutoSaveFile();
 107
 108         /// read a new document from a string
 109         bool readString(std::string const &);
 110         /// load a new file
 111         bool readFile(support::FileName const & filename);
 112
 113         /// read the header, returns number of unknown tokens
 114         int readHeader(LyXLex & lex);
 115
 116         /** Reads a file without header.
 117             \param par if != 0 insert the file.
 118             \return \c false if file is not completely read.
 119         */
 120         bool readDocument(LyXLex &);
 121
 122         ///
 123         void insertStringAsLines(ParagraphList & plist,
 124                 pit_type &, pos_type &,
 125                 LyXFont const &, docstring const &, bool);
 126         ///
 127         ParIterator getParFromID(int id) const;
 128         /// do we have a paragraph with this id?
 129         bool hasParWithID(int id) const;
 130
 131         /// This signal is emitted when the buffer is changed.
 132         boost::signal<void()> changed;
 133         /// This signal is emitted when some parsing error shows up.
 134         boost::signal<void(std::string)> errors;
 135         /// This signal is emitted when some message shows up.
 136         boost::signal<void(docstring)> message;
 137         /// This signal is emitted when the buffer busy status change.
 138         boost::signal<void(bool)> busy;
 139         /// This signal is emitted when the buffer readonly status change.
 140         boost::signal<void(bool)> readonly;
 141         /// Update window titles of all users.
 142         boost::signal<void()> updateTitles;
 143         /// Reset autosave timers for all users.
 144         boost::signal<void()> resetAutosaveTimers;
 145         /// This signal is emitting if the buffer is being closed.
 146         boost::signal<void()> closing;
 147
 148
 149         /** Save file.
 150             Takes care of auto-save files and backup file if requested.
 151             Returns \c true if the save is successful, \c false otherwise.
 152         */
 153         bool save() const;
 154
 155         /// Write document to stream. Returns \c false if unsuccesful.
 156         bool write(std::ostream &) const;
 157         /// Write file. Returns \c false if unsuccesful.
 158         bool writeFile(support::FileName const &) const;
 159
 160         /// Just a wrapper for writeLaTeXSource, first creating the ofstream.
 161         bool makeLaTeXFile(support::FileName const & filename,
 162                            std::string const & original_path,
 163                            OutputParams const &,
 164                            bool output_preamble = true,
 165                            bool output_body = true);
 166         /** Export the buffer to LaTeX.
 167             If \p os is a file stream, and params().inputenc is "auto" or
 168             "default", and the buffer contains text in different languages
 169             with more than one encoding, then this method will change the
 170             encoding associated to \p os. Therefore you must not call this
 171             method with a string stream if the output is supposed to go to a
 172             file. \code
 173             odocfstream ofs;
 174             ofs.open("test.tex");
 175             writeLaTeXSource(ofs, ...);
 176             ofs.close();
 177             \endcode is NOT equivalent to \code
 178             odocstringstream oss;
 179             writeLaTeXSource(oss, ...);
 180             odocfstream ofs;
 181             ofs.open("test.tex");
 182             ofs << oss.str();
 183             ofs.close();
 184             \endcode
 185          */
 186         void writeLaTeXSource(odocstream & os,
 187                            std::string const & original_path,
 188                            OutputParams const &,
 189                            bool output_preamble = true,
 190                            bool output_body = true);
 191         ///
 192         void makeDocBookFile(support::FileName const & filename,
 193                              OutputParams const & runparams_in,
 194                              bool only_body = false);
 195         ///
 196         void writeDocBookSource(odocstream & os, std::string const & filename,
 197                              OutputParams const & runparams_in,
 198                              bool only_body = false);
 199         /// returns the main language for the buffer (document)
 200         Language const * getLanguage() const;
 201         /// get l10n translated to the buffers language
 202         docstring const B_(std::string const & l10n) const;
 203
 204         ///
 205         int runChktex();
 206         /// return true if the main lyx file does not need saving
 207         bool isClean() const;
 208         ///
 209         bool isBakClean() const;
 210         ///
 211         bool isDepClean(std::string const & name) const;
 212
 213         /// mark the main lyx file as not needing saving
 214         void markClean() const;
 215
 216         ///
 217         void markBakClean();
 218
 219         ///
 220         void markDepClean(std::string const & name);
 221
 222         ///
 223         void setUnnamed(bool flag = true);
 224
 225         ///
 226         bool isUnnamed() const;
 227
 228         /// Mark this buffer as dirty.
 229         void markDirty();
 230
 231         /// Returns the buffer's filename. It is always an absolute path.
 232         std::string const fileName() const;
 233
 234         /// Returns the the path where the buffer lives.
 235         /// It is always an absolute path.
 236         std::string const & filePath() const;
 237
 238         /** A transformed version of the file name, adequate for LaTeX.
 239             \param no_path optional if \c true then the path is stripped.
 240         */
 241         std::string const getLatexName(bool no_path = true) const;
 242
 243         /// Get thee name and type of the log.
 244         std::pair<LogType, std::string> const getLogName() const;
 245
 246         /// Change name of buffer. Updates "read-only" flag.
 247         void setFileName(std::string const & newfile);
 248
 249         /// Name of the document's parent
 250         void setParentName(std::string const &);
 251
 252         /** Get the document's master (or \c this if this is not a
 253             child document)
 254          */
 255         Buffer const * getMasterBuffer() const;
 256         /** Get the document's master (or \c this if this is not a
 257             child document)
 258          */
 259         Buffer * getMasterBuffer();
 260
 261         /// Is buffer read-only?
 262         bool isReadonly() const;
 263
 264         /// Set buffer read-only flag
 265         void setReadonly(bool flag = true);
 266
 267         /// returns \c true if the buffer contains a LaTeX document
 268         bool isLatex() const;
 269         /// returns \c true if the buffer contains a DocBook document
 270         bool isDocBook() const;
 271         /// returns \c true if the buffer contains a Wed document
 272         bool isLiterate() const;
 273
 274         /** Validate a buffer for LaTeX.
 275             This validates the buffer, and returns a struct for use by
 276             #makeLaTeX# and others. Its main use is to figure out what
 277             commands and packages need to be included in the LaTeX file.
 278             It (should) also check that the needed constructs are there
 279             (i.e. that the \refs points to coresponding \labels). It
 280             should perhaps inset "error" insets to help the user correct
 281             obvious mistakes.
 282         */
 283         void validate(LaTeXFeatures &) const;
 284
 285         /// return all bibkeys from buffer and its childs
 286         void fillWithBibKeys(std::vector<std::pair<std::string, docstring> > & keys) const;
 287         /// Update the cache with all bibfiles in use (including bibfiles
 288         /// of loaded child documents).
 289         void updateBibfilesCache();
 290         /// Return the cache with all bibfiles in use (including bibfiles
 291         /// of loaded child documents).
 292         std::vector<support::FileName> const & getBibfilesCache() const;
 293         ///
 294         void getLabelList(std::vector<docstring> &) const;
 295
 296         ///
 297         void changeLanguage(Language const * from, Language const * to);
 298
 299         ///
 300         void updateDocLang(Language const * nlang);
 301
 302         ///
 303         bool isMultiLingual() const;
 304
 305         /// Does this mean that this is buffer local?
 306         limited_stack<Undo> & undostack();
 307         limited_stack<Undo> const & undostack() const;
 308
 309         /// Does this mean that this is buffer local?
 310         limited_stack<Undo> & redostack();
 311         limited_stack<Undo> const & redostack() const;
 312
 313         ///
 314         BufferParams & params();
 315         BufferParams const & params() const;
 316
 317         /** The list of paragraphs.
 318             This is a linked list of paragraph, this list holds the
 319             whole contents of the document.
 320          */
 321         ParagraphList & paragraphs();
 322         ParagraphList const & paragraphs() const;
 323
 324         /// LyX version control object.
 325         LyXVC & lyxvc();
 326         LyXVC const & lyxvc() const;
 327
 328         /// Where to put temporary files.
 329         std::string const & temppath() const;
 330
 331         /// Used when typesetting to place errorboxes.
 332         TexRow & texrow();
 333         TexRow const & texrow() const;
 334
 335         ///
 336         ParIterator par_iterator_begin();
 337         ///
 338         ParConstIterator par_iterator_begin() const;
 339         ///
 340         ParIterator par_iterator_end();
 341         ///
 342         ParConstIterator par_iterator_end() const;
 343
 344         /** \returns true only when the file is fully loaded.
 345          *  Used to prevent the premature generation of previews
 346          *  and by the citation inset.
 347          */
 348         bool fully_loaded() const;
 349         /// Set by buffer_funcs' newFile.
 350         void fully_loaded(bool);
 351
 352         /// Our main text (inside the top InsetText)
 353         LyXText & text() const;
 354
 355         /// Our top InsetText!
 356         InsetBase & inset() const;
 357
 358         //
 359         // Macro handling
 360         //
 361         ///
 362         void buildMacros();
 363         ///
 364         bool hasMacro(docstring const & name) const;
 365         ///
 366         MacroData const & getMacro(docstring const & name) const;
 367         ///
 368         void insertMacro(docstring const & name, MacroData const & data);
 369
 370         ///
 371         void saveCursor(StableDocIterator cursor, StableDocIterator anchor);
 372         ///
 373         StableDocIterator getCursor() const { return cursor_; }
 374         ///
 375         StableDocIterator getAnchor() const { return anchor_; }
 376         ///
 377         void changeRefsIfUnique(docstring const & from, docstring const & to,
 378                 InsetBase::Code code);
 379 /// get source code (latex/docbook) for some paragraphs, or all paragraphs
 380 /// including preamble
 381         void getSourceCode(odocstream & os, pit_type par_begin, pit_type par_end, bool full_source);
 382
 383         /// errorLists_ accessors.
 384         //@{
 385         ErrorList const & errorList(std::string const & type) const;
 386         ErrorList & errorList(std::string const & type);
 387         //@}
 388
 389         //@{
 390         TocBackend & tocBackend();
 391         TocBackend const & tocBackend() const;
 392         //@}
 393
 394 private:
 395         /** Inserts a file into a document
 396             \return \c false if method fails.
 397         */
 398         ReadStatus readFile(LyXLex &, support::FileName const & filename,
 399                             bool fromString = false);
 400
 401         /// Use the Pimpl idiom to hide the internals.
 402         class Impl;
 403         /// The pointer never changes although *pimpl_'s contents may.
 404         boost::scoped_ptr<Impl> const pimpl_;
 405
 406         /// Save the cursor Position on Buffer switch
 407         /// this would not be needed if every Buffer would have
 408         /// it's BufferView, this should be FIXED in future.
 409         StableDocIterator cursor_;
 410         StableDocIterator anchor_;
 411         /// A cache for the bibfiles (including bibfiles of loaded child
 412         /// documents), needed for appropriate update of natbib labels.
 413         mutable std::vector<support::FileName> bibfilesCache_;
 414
 415         /// Container for all sort of Buffer dependant errors.
 416         std::map<std::string, ErrorList> errorLists_;
 417 };
 418
 419
 420 } // namespace lyx
 421
 422 #endif