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