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 "OutputEnums.h"
  16
  17 #include "support/unique_ptr.h"
  18 #include "support/strfwd.h"
  19 #include "support/types.h"
  20
  21 #include <map>
  22 #include <list>
  23 #include <set>
  24 #include <string>
  25 #include <vector>
  26
  27
  28 namespace lyx {
  29
  30 class BiblioInfo;
  31 class BibTeXInfo;
  32 class BufferParams;
  33 class DispatchResult;
  34 class DocIterator;
  35 class docstring_list;
  36 class ErrorList;
  37 class FuncRequest;
  38 class FuncStatus;
  39 class Inset;
  40 class InsetLabel;
  41 class InsetRef;
  42 class Font;
  43 class Format;
  44 class Lexer;
  45 class Text;
  46 class LyXVC;
  47 class LaTeXFeatures;
  48 class Language;
  49 class MacroData;
  50 class MacroNameSet;
  51 class MacroSet;
  52 class OutputParams;
  53 class otexstream;
  54 class Paragraph;
  55 class ParConstIterator;
  56 class ParIterator;
  57 class ParagraphList;
  58 class TeXErrors;
  59 class TexRow;
  60 class TocBackend;
  61 class Undo;
  62 class WordLangTuple;
  63
  64 namespace frontend {
  65 class GuiBufferDelegate;
  66 class WorkAreaManager;
  67 }
  68
  69 namespace support {
  70 class DocFileName;
  71 class FileName;
  72 class FileNamePairList;
  73 }
  74
  75 namespace graphics {
  76 class PreviewLoader;
  77 class Cache;
  78 }
  79
  80
  81 class Buffer;
  82 typedef std::list<Buffer *> ListOfBuffers;
  83 /// a list of Buffers we cloned
  84 typedef std::set<Buffer *> CloneList;
  85
  86
  87 /** The buffer object.
  88  * This is the buffer object. It contains all the information about
  89  * a document loaded into LyX.
  90  * The buffer object owns the Text (wrapped in an InsetText), which
  91  * contains the individual paragraphs of the document.
  92  *
  93  *
  94  * I am not sure if the class is complete or
  95  * minimal, probably not.
  96  * \author Lars Gullik Bjønnes
  97  */
  98
  99 class MarkAsExporting;
 100
 101 class Buffer {
 102 public:
 103         /// What type of log will \c getLogName() return?
 104         enum LogType {
 105                 latexlog, ///< LaTeX log
 106                 buildlog  ///< Literate build log
 107         };
 108
 109         /// Result of \c readFile()
 110         enum ReadStatus {
 111                 ReadSuccess,
 112                 ReadCancel,
 113                 // failures
 114                 ReadFailure,
 115                 ReadWrongVersion,
 116                 ReadFileNotFound,
 117                 ReadVCError,
 118                 ReadAutosaveFailure,
 119                 ReadEmergencyFailure,
 120                 ReadNoLyXFormat,
 121                 ReadDocumentFailure,
 122                 // lyx2lyx
 123                 LyX2LyXNoTempFile,
 124                 LyX2LyXNotFound,
 125                 LyX2LyXOlderFormat,
 126                 LyX2LyXNewerFormat,
 127                 // other
 128                 ReadOriginal
 129         };
 130
 131         enum ExportStatus {
 132                 // export
 133                 ExportSuccess,
 134                 ExportCancel,
 135                 ExportError,
 136                 ExportNoPathToFormat,
 137                 ExportTexPathHasSpaces,
 138                 ExportConverterError,
 139                 // preview
 140                 // Implies ExportSuccess.
 141                 PreviewSuccess,
 142                 // The exported file exists but there was an error when opening
 143                 // it in a viewer.
 144                 PreviewError
 145         };
 146
 147         ///
 148         enum UpdateScope {
 149                 UpdateMaster,
 150                 UpdateChildOnly
 151         };
 152
 153         /// Constructor
 154         explicit Buffer(std::string const & file, bool readonly = false,
 155                 Buffer const * cloned_buffer = 0);
 156
 157         /// Destructor
 158         ~Buffer();
 159
 160         /// Clones the entire structure of which this Buffer is part, starting
 161         /// with the master and cloning all the children, too.
 162         Buffer * cloneFromMaster() const;
 163         /// Just clones this single Buffer. For autosave.
 164         Buffer * cloneBufferOnly() const;
 165         ///
 166         bool isClone() const;
 167
 168         /** High-level interface to buffer functionality.
 169             This function parses a command string and executes it.
 170         */
 171         void dispatch(std::string const & command, DispatchResult & result);
 172
 173         /// Maybe we know the function already by number...
 174         void dispatch(FuncRequest const & func, DispatchResult & result);
 175
 176         /// Can this function be exectued?
 177         /// \return true if we made a decision
 178         bool getStatus(FuncRequest const & cmd, FuncStatus & flag);
 179
 180         ///
 181         DocIterator getParFromID(int id) const;
 182         /// do we have a paragraph with this id?
 183         bool hasParWithID(int id) const;
 184
 185         ///
 186         frontend::WorkAreaManager & workAreaManager() const;
 187
 188         /** Save file.
 189             Takes care of auto-save files and backup file if requested.
 190             Returns \c true if the save is successful, \c false otherwise.
 191         */
 192         bool save() const;
 193         /// Renames and saves the buffer
 194         bool saveAs(support::FileName const & fn);
 195
 196         /// Write document to stream. Returns \c false if unsuccessful.
 197         bool write(std::ostream &) const;
 198         /// Write file. Returns \c false if unsuccessful.
 199         bool writeFile(support::FileName const &) const;
 200
 201         /// \name Functions involved in reading files/strings.
 202         //@{
 203         /// Loads the LyX file into the buffer. This function
 204         /// tries to extract the file from version control if it
 205         /// cannot be found. If it can be found, it will try to
 206         /// read an emergency save file or an autosave file.
 207         /// \sa loadThisLyXFile
 208         ReadStatus loadLyXFile();
 209         /// Loads the LyX file \c fn into the buffer. If you want
 210         /// to check for files in a version control container,
 211         /// emergency or autosave files, one should use \c loadLyXFile.
 212         /// /sa loadLyXFile
 213         ReadStatus loadThisLyXFile(support::FileName const & fn);
 214         /// import a new document from a string
 215         bool importString(std::string const &, docstring const &, ErrorList &);
 216         /// import a new file
 217         bool importFile(std::string const &, support::FileName const &, ErrorList &);
 218         /// read a new document from a string
 219         bool readString(std::string const &);
 220         /// Reloads the LyX file
 221         ReadStatus reload();
 222 //FIXME: The following function should be private
 223 //private:
 224         /// read the header, returns number of unknown tokens
 225         int readHeader(Lexer & lex);
 226
 227         double fontScalingFactor() const;
 228
 229 private:
 230         ///
 231         typedef std::map<Buffer const *, Buffer *> BufferMap;
 232         ///
 233         void cloneWithChildren(BufferMap &, CloneList *) const;
 234         /// save checksum of the given file.
 235         void saveCheckSum() const;
 236         /// read a new file
 237         ReadStatus readFile(support::FileName const & fn);
 238         /// Reads a file without header.
 239         /// \param par if != 0 insert the file.
 240         /// \return \c true if file is not completely read.
 241         bool readDocument(Lexer &);
 242         /// Try to extract the file from a version control container
 243         /// before reading if the file cannot be found.
 244         /// \sa LyXVC::file_not_found_hook
 245         ReadStatus extractFromVC();
 246         /// Reads the first tag of a LyX File and
 247         /// returns the file format number.
 248         ReadStatus parseLyXFormat(Lexer & lex, support::FileName const & fn,
 249                 int & file_format) const;
 250         /// Convert the LyX file to the LYX_FORMAT using
 251         /// the lyx2lyx script and returns the filename
 252         /// of the temporary file to be read
 253         ReadStatus convertLyXFormat(support::FileName const & fn,
 254                 support::FileName & tmpfile, int from_format);
 255         /// get appropriate name for backing up files from older versions
 256         support::FileName getBackupName() const;
 257         //@}
 258
 259 public:
 260         /// \name Functions involved in autosave and emergency files.
 261         //@{
 262         /// Save an autosave file to #filename.lyx#
 263         bool autoSave() const;
 264         /// save emergency file
 265         /// \return a status message towards the user.
 266         docstring emergencyWrite();
 267
 268 //FIXME:The following function should be private
 269 //private:
 270         ///
 271         void removeAutosaveFile() const;
 272
 273 private:
 274         /// Try to load an autosave file associated to \c fn.
 275         ReadStatus loadAutosave();
 276         /// Try to load an emergency file associated to \c fn.
 277         ReadStatus loadEmergency();
 278         /// Get the filename of the emergency file associated with the Buffer
 279         support::FileName getEmergencyFileName() const;
 280         /// Get the filename of the autosave file associated with the Buffer
 281         support::FileName getAutosaveFileName() const;
 282         ///
 283         void moveAutosaveFile(support::FileName const & old) const;
 284         //@}
 285
 286 public:
 287         /// Fill in the ErrorList with the TeXErrors
 288         void bufferErrors(TeXErrors const &, ErrorList &) const;
 289
 290         enum OutputWhat {
 291                 FullSource,
 292                 OnlyBody,
 293                 IncludedFile,
 294                 OnlyPreamble,
 295                 CurrentParagraph
 296         };
 297
 298         /// Just a wrapper for writeLaTeXSource, first creating the ofstream.
 299         bool makeLaTeXFile(support::FileName const & filename,
 300                            std::string const & original_path,
 301                            OutputParams const &,
 302                            OutputWhat output = FullSource) const;
 303         /** Export the buffer to LaTeX.
 304             If \p os is a file stream, and params().inputenc is "auto" or
 305             "default", and the buffer contains text in different languages
 306             with more than one encoding, then this method will change the
 307             encoding associated to \p os. Therefore you must not call this
 308             method with a string stream if the output is supposed to go to a
 309             file. \code
 310             ofdocstream ofs;
 311             otexstream os(ofs);
 312             ofs.open("test.tex");
 313             writeLaTeXSource(os, ...);
 314             ofs.close();
 315             \endcode is NOT equivalent to \code
 316             odocstringstream oss;
 317             otexstream os(oss);
 318             writeLaTeXSource(os, ...);
 319             ofdocstream ofs;
 320             ofs.open("test.tex");
 321             ofs << oss.str();
 322             ofs.close();
 323             \endcode
 324          */
 325         void writeLaTeXSource(otexstream & os,
 326                            std::string const & original_path,
 327                            OutputParams const &,
 328                            OutputWhat output = FullSource) const;
 329         ///
 330         void makeDocBookFile(support::FileName const & filename,
 331                              OutputParams const & runparams_in,
 332                              OutputWhat output = FullSource) const;
 333         ///
 334         void writeDocBookSource(odocstream & os, std::string const & filename,
 335                              OutputParams const & runparams_in,
 336                              OutputWhat output = FullSource) const;
 337         ///
 338         void makeLyXHTMLFile(support::FileName const & filename,
 339                              OutputParams const & runparams_in) const;
 340         ///
 341         void writeLyXHTMLSource(odocstream & os,
 342                              OutputParams const & runparams_in,
 343                              OutputWhat output = FullSource) const;
 344         /// returns the main language for the buffer (document)
 345         Language const * language() const;
 346         /// get l10n translated to the buffers language
 347         docstring const B_(std::string const & l10n) const;
 348
 349         ///
 350         int runChktex();
 351         /// return true if the main lyx file does not need saving
 352         bool isClean() const;
 353         ///
 354         bool isDepClean(std::string const & name) const;
 355
 356         /// Whether or not disk file has been externally modified. Uses a checksum
 357         /// which is accurate but slow, which can be a problem when it is frequently
 358         /// used, or used for a large file on a slow (network) file system.
 359         bool isChecksumModified() const;
 360
 361         /// Flag set by the FileSystemWatcher.
 362         /// Fast but (not so) inaccurate, can be cleared by the user.
 363         bool notifiesExternalModification() const;
 364         void clearExternalModification() const;
 365
 366         /// mark the main lyx file as not needing saving
 367         void markClean() const;
 368
 369         ///
 370         void markDepClean(std::string const & name);
 371
 372         ///
 373         void setUnnamed(bool flag = true);
 374
 375         /// Whether or not a filename has been assigned to this buffer
 376         bool isUnnamed() const;
 377
 378         /// Whether or not this buffer is internal.
 379         ///
 380         /// An internal buffer does not contain a real document, but some auxiliary text segment.
 381         /// It is not associated with a filename, it is never saved, thus it does not need to be
 382         /// automatically saved, nor it needs to trigger any "do you want to save ?" question.
 383         bool isInternal() const;
 384
 385         void setInternal(bool flag);
 386
 387         /// Mark this buffer as dirty.
 388         void markDirty();
 389
 390         /// Returns the buffer's filename. It is always an absolute path.
 391         support::FileName fileName() const;
 392
 393         /// Returns the buffer's filename. It is always an absolute path.
 394         std::string absFileName() const;
 395
 396         /// Returns the path where the buffer lives.
 397         /// It is always an absolute path.
 398         std::string filePath() const;
 399
 400         /** Contructs a file name of a referenced file (child doc, included graphics etc).
 401          *  Absolute names are returned as is. If the name is relative, it is
 402          *  interpreted relative to filePath() if the file exists, otherwise
 403          *  relative to the original path where the document was last saved.
 404          *  The original path may be different from filePath() if the document was
 405          *  later manually moved to a different location.
 406          */
 407         support::DocFileName getReferencedFileName(std::string const & fn) const;
 408
 409         /// Format a file name for LaTeX output (absolute or relative or filename only,
 410         /// depending on file and context)
 411         std::string const prepareFileNameForLaTeX(std::string const &,
 412                                         std::string const &, bool nice) const;
 413
 414         /** Returns a vector of bibliography (*.bib) file paths suitable for the
 415          *  output in the respective BibTeX/Biblatex macro
 416          */
 417         std::vector<docstring> const prepareBibFilePaths(OutputParams const &,
 418                                     support::FileNamePairList const bibfilelist,
 419                                     bool const extension = true) const;
 420
 421         /** Returns the path where a local layout file lives.
 422          *  An empty string is returned for standard system and user layouts.
 423          *  If possible, it is always relative to the buffer path.
 424          */
 425         std::string layoutPos() const;
 426
 427         /** Set the path to a local layout file.
 428          *  This must be an absolute path but, if possible, it is always
 429          *  stored as relative to the buffer path.
 430          */
 431         void setLayoutPos(std::string const & path);
 432
 433         /** A transformed version of the file name, adequate for LaTeX.
 434             \param no_path optional if \c true then the path is stripped.
 435         */
 436         std::string latexName(bool no_path = true) const;
 437
 438         /// Get the name and type of the log.
 439         std::string logName(LogType * type = 0) const;
 440
 441         /// Set document's parent Buffer.
 442         void setParent(Buffer const *);
 443         Buffer const * parent() const;
 444
 445         /** Get the document's master (or \c this if this is not a
 446             child document)
 447          */
 448         Buffer const * masterBuffer() const;
 449
 450         /// \return true if \p child is a child of this \c Buffer.
 451         bool isChild(Buffer * child) const;
 452
 453         /// \return true if this \c Buffer has children
 454         bool hasChildren() const;
 455
 456         /// \return a list of the direct children of this Buffer.
 457         /// this list has no duplicates and is in the order in which
 458         /// the children appear.
 459         ListOfBuffers getChildren() const;
 460
 461         /// \return a list of all descendents of this Buffer (children,
 462         /// grandchildren, etc). this list has no duplicates and is in
 463         /// the order in which the children appear.
 464         ListOfBuffers getDescendents() const;
 465
 466         /// Collect all relative buffers, in the order in which they appear.
 467         /// I.e., the "root" Buffer is first, then its first child, then any
 468         /// of its children, etc. However, there are no duplicates in this
 469         /// list.
 470         /// This is "stable", too, in the sense that it returns the same
 471         /// thing from whichever Buffer it is called.
 472         ListOfBuffers allRelatives() const;
 473
 474         /// Is buffer read-only?
 475         bool isReadonly() const;
 476
 477         /// Set buffer read-only flag
 478         void setReadonly(bool flag = true);
 479
 480         /** Validate a buffer for LaTeX.
 481             This validates the buffer, and returns a struct for use by
 482             #makeLaTeX# and others. Its main use is to figure out what
 483             commands and packages need to be included in the LaTeX file.
 484             It (should) also check that the needed constructs are there
 485             (i.e. that the \refs points to coresponding \labels). It
 486             should perhaps inset "error" insets to help the user correct
 487             obvious mistakes.
 488         */
 489         void validate(LaTeXFeatures &) const;
 490
 491         /// Reference information is cached in the Buffer, so we do not
 492         /// have to check or read things over and over.
 493         ///
 494         /// There are two caches.
 495         ///
 496         /// One is a cache of the BibTeX files from which reference info is
 497         /// being gathered. This cache is PER BUFFER, and the cache for the
 498         /// master essentially includes the cache for its children. This gets
 499         /// invalidated when an InsetBibtex is created, deleted, or modified.
 500         ///
 501         /// The other is a cache of the reference information itself. This
 502         /// exists only in the master buffer, and when it needs to be updated,
 503         /// the children add their information to the master's cache.
 504
 505         /// Calling this method invalidates the cache and so requires a
 506         /// re-read.
 507         void invalidateBibinfoCache() const;
 508         /// This invalidates the cache of files we need to check.
 509         void invalidateBibfileCache() const;
 510         /// Updates the cached bibliography information, checking first to see
 511         /// whether the cache is valid. If so, we do nothing. If not, then we
 512         /// reload all the BibTeX info.
 513         /// Note that this operates on the master document.
 514         void reloadBibInfoCache() const;
 515         /// \return the bibliography information for this buffer's master,
 516         /// or just for it, if it isn't a child.
 517         BiblioInfo const & masterBibInfo() const;
 518         /// collect bibliography info from the various insets in this buffer.
 519         void collectBibKeys() const;
 520         /// add some BiblioInfo to our cache
 521         void addBiblioInfo(BiblioInfo const & bi) const;
 522         /// add a single piece of bibliography info to our cache
 523         void addBibTeXInfo(docstring const & key, BibTeXInfo const & bi) const;
 524         ///
 525         void makeCitationLabels() const;
 526         ///
 527         bool citeLabelsValid() const;
 528         ///
 529         void getLabelList(std::vector<docstring> &) const;
 530
 531         /// This removes the .aux and .bbl files from the temp dir.
 532         void removeBiblioTempFiles() const;
 533
 534         ///
 535         void changeLanguage(Language const * from, Language const * to);
 536
 537         ///
 538         bool isMultiLingual() const;
 539         ///
 540         std::set<Language const *> getLanguages() const;
 541
 542         ///
 543         BufferParams & params();
 544         BufferParams const & params() const;
 545         ///
 546         BufferParams const & masterParams() const;
 547
 548         /** The list of paragraphs.
 549             This is a linked list of paragraph, this list holds the
 550             whole contents of the document.
 551          */
 552         ParagraphList & paragraphs();
 553         ParagraphList const & paragraphs() const;
 554
 555         /// LyX version control object.
 556         LyXVC & lyxvc();
 557         LyXVC const & lyxvc() const;
 558
 559         /// Where to put temporary files.
 560         std::string const temppath() const;
 561
 562         /// Used when typesetting to place errorboxes.
 563         TexRow const & texrow() const;
 564         TexRow & texrow();
 565
 566         ///
 567         ParIterator par_iterator_begin();
 568         ///
 569         ParConstIterator par_iterator_begin() const;
 570         ///
 571         ParIterator par_iterator_end();
 572         ///
 573         ParConstIterator par_iterator_end() const;
 574
 575         // Position of the child buffer where it appears first in the master.
 576         DocIterator firstChildPosition(Buffer const * child);
 577
 578         /** \returns true only when the file is fully loaded.
 579          *  Used to prevent the premature generation of previews
 580          *  and by the citation inset.
 581          */
 582         bool isFullyLoaded() const;
 583         /// Set by buffer_funcs' newFile.
 584         void setFullyLoaded(bool);
 585
 586         /// FIXME: Needed by RenderPreview.
 587         graphics::PreviewLoader * loader() const;
 588         /// Update the LaTeX preview snippets associated with this buffer
 589         void updatePreviews() const;
 590         /// Remove any previewed LaTeX snippets associated with this buffer
 591         void removePreviews() const;
 592         ///
 593         graphics::Cache & graphicsCache() const;
 594
 595         /// Our main text (inside the top InsetText)
 596         Text & text() const;
 597
 598         /// Our top InsetText
 599         Inset & inset() const;
 600
 601         //
 602         // Macro handling
 603         //
 604         /// Collect macro definitions in paragraphs
 605         void updateMacros() const;
 606         /// Iterate through the whole buffer and try to resolve macros
 607         void updateMacroInstances(UpdateType) const;
 608
 609         /// List macro names of this buffer, the parent and the children
 610         void listMacroNames(MacroNameSet & macros) const;
 611         /// Collect macros of the parent and its children in front of this buffer.
 612         void listParentMacros(MacroSet & macros, LaTeXFeatures & features) const;
 613
 614         /// Return macro defined before pos (or in the master buffer)
 615         MacroData const * getMacro(docstring const & name, DocIterator const & pos, bool global = true) const;
 616         /// Return macro defined anywhere in the buffer (or in the master buffer)
 617         MacroData const * getMacro(docstring const & name, bool global = true) const;
 618         /// Return macro defined before the inclusion of the child
 619         MacroData const * getMacro(docstring const & name, Buffer const & child, bool global = true) const;
 620
 621         /// Collect user macro names at loading time
 622         typedef std::set<docstring> UserMacroSet;
 623         mutable UserMacroSet usermacros;
 624
 625         /// Replace the inset contents for insets which InsetCode is equal
 626         /// to the passed \p inset_code.
 627         void changeRefsIfUnique(docstring const & from, docstring const & to);
 628
 629         /// get source code (latex/docbook) for some paragraphs, or all paragraphs
 630         /// including preamble
 631         /// returns nullptr if Id to Row conversion is unsupported
 632         unique_ptr<TexRow> getSourceCode(odocstream & os,
 633                         std::string const & format, pit_type par_begin,
 634                         pit_type par_end, OutputWhat output, bool master) const;
 635
 636         /// Access to error list.
 637         /// This method is used only for GUI visualisation of Buffer related
 638         /// errors (like parsing or LateX compilation). This method is const
 639         /// because modifying the returned ErrorList does not touch the document
 640         /// contents.
 641         ErrorList & errorList(std::string const & type) const;
 642
 643         /// The Toc backend.
 644         /// This is useful only for screen visualisation of the Buffer. This
 645         /// method is const because modifying this backend does not touch
 646         /// the document contents.
 647         TocBackend & tocBackend() const;
 648
 649         ///
 650         Undo & undo();
 651
 652         /// This function is called when the buffer is changed.
 653         void changed(bool update_metrics) const;
 654         ///
 655         void setChild(DocIterator const & dit, Buffer * child);
 656         ///
 657         void updateTocItem(std::string const &, DocIterator const &) const;
 658         /// This function is called when the buffer structure is changed.
 659         void structureChanged() const;
 660         /// This function is called when some parsing error shows up.
 661         void errors(std::string const & err, bool from_master = false) const;
 662         /// This function is called when the buffer busy status change.
 663         void setBusy(bool on) const;
 664         /// Update window titles of all users.
 665         void updateTitles() const;
 666         /// Reset autosave timers for all users.
 667         void resetAutosaveTimers() const;
 668         ///
 669         void message(docstring const & msg) const;
 670
 671         ///
 672         void setGuiDelegate(frontend::GuiBufferDelegate * gui);
 673         ///
 674         bool hasGuiDelegate() const;
 675
 676         ///
 677         ExportStatus doExport(std::string const & target, bool put_in_tempdir) const;
 678         /// Export buffer to format \p format and open the result in a suitable viewer.
 679         /// Note: This has nothing to do with preview of graphics or math formulas.
 680         ExportStatus preview(std::string const & format) const;
 681         /// true if there was a previous preview this session of this buffer and
 682         /// there was an error on the previous preview of this buffer.
 683         bool lastPreviewError() const;
 684
 685 private:
 686         ///
 687         ExportStatus doExport(std::string const & target, bool put_in_tempdir,
 688                 std::string & result_file) const;
 689         /// target is a format name optionally followed by a space
 690         /// and a destination file-name
 691         ExportStatus doExport(std::string const & target, bool put_in_tempdir,
 692                 bool includeall, std::string & result_file) const;
 693         ///
 694         ExportStatus preview(std::string const & format, bool includeall) const;
 695         ///
 696         void setMathFlavor(OutputParams & op) const;
 697
 698 public:
 699         ///
 700         bool isExporting() const;
 701
 702         ///
 703         typedef std::vector<std::pair<Inset *, ParIterator> > References;
 704         ///
 705         References const & references(docstring const & label) const;
 706         ///
 707         void addReference(docstring const & label, Inset * inset, ParIterator it);
 708         ///
 709         void clearReferenceCache() const;
 710         ///
 711         void setInsetLabel(docstring const & label, InsetLabel const * il);
 712         ///
 713         InsetLabel const * insetLabel(docstring const & label) const;
 714
 715         /// return a list of all used branches (also in children)
 716         void getUsedBranches(std::list<docstring> &, bool const from_master = false) const;
 717
 718         /// sets the buffer_ member for every inset in this buffer.
 719         // FIXME This really shouldn't be needed, but at the moment it's not
 720         // clear how to do it just for the individual pieces we need.
 721         void setBuffersForInsets() const;
 722         /// Updates screen labels and some other information associated with
 723         /// insets and paragraphs. Actually, it's more like a general "recurse
 724         /// through the Buffer" routine, that visits all the insets and paragraphs.
 725         void updateBuffer() const { updateBuffer(UpdateMaster, InternalUpdate); }
 726         /// \param scope: whether to start with the master document or just
 727         /// do this one.
 728         /// \param output: whether we are preparing for output.
 729         void updateBuffer(UpdateScope scope, UpdateType utype) const;
 730         ///
 731         void updateBuffer(ParIterator & parit, UpdateType utype) const;
 732
 733         /// Spellcheck starting from \p from.
 734         /// \p from initial position, will then points to the next misspelled
 735         ///    word.
 736         /// \p to will points to the end of the next misspelled word.
 737         /// \p word_lang will contain the found misspelled word.
 738         /// \return progress if a new word was found.
 739         int spellCheck(DocIterator & from, DocIterator & to,
 740                 WordLangTuple & word_lang, docstring_list & suggestions) const;
 741         ///
 742         void checkChildBuffers();
 743         ///
 744         void checkMasterBuffer();
 745
 746         /// If the document is being saved to a new location and the named file
 747         /// exists at the old location, return its updated path relative to the
 748         /// new buffer path if possible, otherwise return its absolute path.
 749         /// In all other cases, this is a no-op and name is returned unchanged.
 750         /// If a non-empty ext is given, the existence of name.ext is checked
 751         /// but the returned path will not contain this extension.
 752         /// Similarly, when loading a document that was moved from the location
 753         /// where it was saved, return the correct path relative to the new
 754         /// location.
 755         std::string includedFilePath(std::string const & name,
 756                                 std::string const & ext = empty_string()) const;
 757
 758         /// compute statistics between \p from and \p to
 759         /// \p from initial position
 760         /// \p to points to the end position
 761         /// \p skipNoOutput if notes etc. should be ignored
 762         void updateStatistics(DocIterator & from, DocIterator & to,
 763                                                   bool skipNoOutput = true) const;
 764         /// statistics accessor functions
 765         int wordCount() const;
 766         int charCount(bool with_blanks) const;
 767
 768         // this is const because it does not modify the buffer's real contents,
 769         // only the mutable flag.
 770         void setChangesPresent(bool) const;
 771         bool areChangesPresent() const;
 772         void updateChangesPresent() const;
 773
 774 private:
 775         friend class MarkAsExporting;
 776         /// mark the buffer as busy exporting something, or not
 777         void setExportStatus(bool e) const;
 778
 779         ///
 780         References & getReferenceCache(docstring const & label);
 781         /// Change name of buffer. Updates "read-only" flag.
 782         void setFileName(support::FileName const & fname);
 783         ///
 784         void getLanguages(std::set<Language const *> &) const;
 785         /// Checks whether any of the referenced bibfiles have changed since the
 786         /// last time we loaded the cache. Note that this does NOT update the
 787         /// cached information.
 788         void checkIfBibInfoCacheIsValid() const;
 789         /// Update the list of all bibfiles in use (including bibfiles
 790         /// of loaded child documents).
 791         void updateBibfilesCache(UpdateScope scope = UpdateMaster) const;
 792         /// Return the list with all bibfiles in use (including bibfiles
 793         /// of loaded child documents).
 794         support::FileNamePairList const &
 795                 getBibfilesCache(UpdateScope scope = UpdateMaster) const;
 796         ///
 797         void collectChildren(ListOfBuffers & children, bool grand_children) const;
 798
 799         /// noncopyable
 800         Buffer(Buffer const &);
 801         void operator=(Buffer const &);
 802
 803         /// Use the Pimpl idiom to hide the internals.
 804         class Impl;
 805         /// The pointer never changes although *pimpl_'s contents may.
 806         Impl * const d;
 807 };
 808
 809
 810 /// Helper class, to guarantee that the export status
 811 /// gets reset properly. To use, simply create a local variable:
 812 ///    MarkAsExporting mex(bufptr);
 813 /// and leave the rest to us.
 814 class MarkAsExporting {
 815 public:
 816         MarkAsExporting(Buffer const * buf) : buf_(buf)
 817         {
 818                 buf_->setExportStatus(true);
 819         }
 820         ~MarkAsExporting()
 821         {
 822                 buf_->setExportStatus(false);
 823         }
 824 private:
 825         Buffer const * const buf_;
 826 };
 827
 828
 829 } // namespace lyx
 830
 831 #endif