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