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 makeLaTeXFile(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 makeLinuxDocFile(std::string const & filename,
 159                               OutputParams const & runparams_in,
 160                               bool only_body = false);
 161         ///
 162         void makeDocBookFile(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 LinuxDoc document
 236         bool isLinuxDoc() const;
 237         /// returns \c true if the buffer contains a DocBook document
 238         bool isDocBook() const;
 239         /** returns \c true if the buffer contains either a LinuxDoc
 240             or DocBook document */
 241         bool isSGML() const;
 242         /// returns \c true if the buffer contains a Wed document
 243         bool isLiterate() const;
 244
 245         /** Validate a buffer for LaTeX.
 246             This validates the buffer, and returns a struct for use by
 247             #makeLaTeX# and others. Its main use is to figure out what
 248             commands and packages need to be included in the LaTeX file.
 249             It (should) also check that the needed constructs are there
 250             (i.e. that the \refs points to coresponding \labels). It
 251             should perhaps inset "error" insets to help the user correct
 252             obvious mistakes.
 253         */
 254         void validate(LaTeXFeatures &) const;
 255
 256         /// return all bibkeys from buffer and its childs
 257         void fillWithBibKeys(std::vector<std::pair<std::string, std::string> > & keys) const;
 258         /// Update the cache with all bibfiles in use (including bibfiles
 259         /// of loaded child documents).
 260         void updateBibfilesCache();
 261         /// Return the cache with all bibfiles in use (including bibfiles
 262         /// of loaded child documents).
 263         std::vector<std::string> const & getBibfilesCache() const;
 264         ///
 265         void getLabelList(std::vector<std::string> &) const;
 266
 267         ///
 268         void changeLanguage(Language const * from, Language const * to);
 269
 270         ///
 271         void updateDocLang(Language const * nlang);
 272
 273         ///
 274         bool isMultiLingual() const;
 275
 276         /// Does this mean that this is buffer local?
 277         limited_stack<Undo> & undostack();
 278         limited_stack<Undo> const & undostack() const;
 279
 280         /// Does this mean that this is buffer local?
 281         limited_stack<Undo> & redostack();
 282         limited_stack<Undo> const & redostack() const;
 283
 284         ///
 285         BufferParams & params();
 286         BufferParams const & params() const;
 287
 288         /** The list of paragraphs.
 289             This is a linked list of paragraph, this list holds the
 290             whole contents of the document.
 291          */
 292         ParagraphList & paragraphs();
 293         ParagraphList const & paragraphs() const;
 294
 295         /// LyX version control object.
 296         LyXVC & lyxvc();
 297         LyXVC const & lyxvc() const;
 298
 299         /// Where to put temporary files.
 300         std::string const & temppath() const;
 301
 302         /// Used when typesetting to place errorboxes.
 303         TexRow & texrow();
 304         TexRow const & texrow() const;
 305
 306         ///
 307         ParIterator par_iterator_begin();
 308         ///
 309         ParConstIterator par_iterator_begin() const;
 310         ///
 311         ParIterator par_iterator_end();
 312         ///
 313         ParConstIterator par_iterator_end() const;
 314
 315         /** \returns true only when the file is fully loaded.
 316          *  Used to prevent the premature generation of previews
 317          *  and by the citation inset.
 318          */
 319         bool fully_loaded() const;
 320         /// Set by buffer_funcs' newFile.
 321         void fully_loaded(bool);
 322
 323         /// Our main text (inside the top InsetText)
 324         LyXText & text() const;
 325
 326         /// Our top InsetText!
 327         InsetBase & inset() const;
 328
 329         //
 330         // Macro handling
 331         //
 332         ///
 333         void buildMacros();
 334         ///
 335         bool hasMacro(std::string const & name) const;
 336         ///
 337         MacroData const & getMacro(std::string const & name) const;
 338         ///
 339         void insertMacro(std::string const & name, MacroData const & data);
 340         ///
 341         void saveCursor(StableDocIterator cursor, StableDocIterator anchor);
 342         ///
 343         StableDocIterator getCursor() const { return cursor_; }
 344         ///
 345         StableDocIterator getAnchor() const { return anchor_; }
 346         ///
 347         void changeRefsIfUnique(std::string const & from, std::string const & to);
 348         /// get source code (latex/docbook/linuxdoc) for some paragraphs
 349         void getSourceCode(std::ostream & os, lyx::pit_type par_begin, lyx::pit_type par_end);
 350
 351         /// errorList_ accessor.
 352         ErrorList const & getErrorList() const;
 353         /// replace the internal errorList_
 354         /** FIXME: This method is const for now because the ErrorList GUI
 355         * showing mechanism is used by other classes in order to show their
 356         * own processing errors (ex: Converter.C).
 357         */
 358         void setErrorList(ErrorList const &) const;
 359         /// add an error to the errorList_
 360         /** FIXME: This method is const for now because the ErrorList GUI
 361         * showing mechanism is used by other classes in order to show their
 362         * own processing errors (ex: Converter.C).
 363         */
 364         void addError(ErrorItem const &) const;
 365
 366 private:
 367         /** Inserts a file into a document
 368             \return \c false if method fails.
 369         */
 370         bool readFile(LyXLex &, std::string const & filename);
 371
 372         bool do_writeFile(std::ostream & ofs) const;
 373
 374         /// Use the Pimpl idiom to hide the internals.
 375         class Impl;
 376         /// The pointer never changes although *pimpl_'s contents may.
 377         boost::scoped_ptr<Impl> const pimpl_;
 378
 379         /// Save the cursor Position on Buffer switch
 380         /// this would not be needed if every Buffer would have
 381         /// it's BufferView, this should be FIXED in future.
 382         StableDocIterator cursor_;
 383         StableDocIterator anchor_;
 384         /// A cache for the bibfiles (including bibfiles of loaded child
 385         /// documents), needed for appropriate update of natbib labels.
 386         std::vector<std::string> bibfilesCache_;
 387
 388         /// An error list (replaces the error insets)
 389         /** FIXME: This member is mutable for now because the ErrorList GUI
 390         * showing mechanism is used by other classes in order to show their
 391         * own processing errors (ex: Converter.C).
 392         */
 393         mutable ErrorList errorList_;
 394 };
 395
 396 #endif