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 #include "support/FileNameList.h"
  21
  22 #include <map>
  23 #include <list>
  24 #include <set>
  25 #include <string>
  26 #include <vector>
  27
  28
  29 namespace lyx {
  30
  31 class BiblioInfo;
  32 class BibTeXInfo;
  33 class BufferParams;
  34 class DispatchResult;
  35 class DocIterator;
  36 class docstring_list;
  37 class ErrorList;
  38 class FuncRequest;
  39 class FuncStatus;
  40 class Inset;
  41 class InsetLabel;
  42 class InsetRef;
  43 class Font;
  44 class Format;
  45 class Lexer;
  46 class Text;
  47 class LyXVC;
  48 class LaTeXFeatures;
  49 class Language;
  50 class MacroData;
  51 class MacroNameSet;
  52 class MacroSet;
  53 class OutputParams;
  54 class otexstream;
  55 class Paragraph;
  56 class ParConstIterator;
  57 class ParIterator;
  58 class ParagraphList;
  59 class TeXErrors;
  60 class TexRow;
  61 class TocBackend;
  62 class Undo;
  63 class WordLangTuple;
  64
  65 namespace frontend {
  66 class GuiBufferDelegate;
  67 class WorkAreaManager;
  68 } // namespace frontend
  69
  70 namespace support {
  71 class DocFileName;
  72 class FileName;
  73 } // namespace support
  74
  75 namespace graphics {
  76 class PreviewLoader;
  77 class Cache;
  78 } // namespace graphics
  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,
 161         /// cloning all the children, too.
 162         Buffer * cloneWithChildren() 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                                     const docstring_list & 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? True if it has either the read-only flag or the
 475         /// externally modified flag.
 476         bool isReadonly() const;
 477
 478         /// Does the buffer have the read-only flag?
 479         bool hasReadonlyFlag() const;
 480
 481         /// Set buffer read-only flag
 482         void setReadonly(bool flag = true);
 483
 484         /** Validate a buffer for LaTeX.
 485             This validates the buffer, and returns a struct for use by
 486             #makeLaTeX# and others. Its main use is to figure out what
 487             commands and packages need to be included in the LaTeX file.
 488             It (should) also check that the needed constructs are there
 489             (i.e. that the \refs points to coresponding \labels). It
 490             should perhaps inset "error" insets to help the user correct
 491             obvious mistakes.
 492         */
 493         void validate(LaTeXFeatures &) const;
 494
 495         /// Reference information is cached in the Buffer, so we do not
 496         /// have to check or read things over and over.
 497         ///
 498         /// There are two caches.
 499         ///
 500         /// One is a cache of the BibTeX files from which reference info is
 501         /// being gathered. This cache is PER BUFFER, and the cache for the
 502         /// master essentially includes the cache for its children. This gets
 503         /// invalidated when an InsetBibtex is created, deleted, or modified.
 504         ///
 505         /// The other is a cache of the reference information itself. This
 506         /// exists only in the master buffer, and when it needs to be updated,
 507         /// the children add their information to the master's cache.
 508
 509         /// Calling this method invalidates the cache and so requires a
 510         /// re-read.
 511         void invalidateBibinfoCache() const;
 512         /// Clear the bibfiles cache
 513         void clearBibFileCache() const;
 514         /// Updates the cached bibliography information, checking first to see
 515         /// whether the cache is valid. If so, we do nothing. If not, then we
 516         /// reload all the BibTeX info.
 517         /// Note that this operates on the master document.
 518         void reloadBibInfoCache() const;
 519         /// \return the bibliography information for this buffer's master,
 520         /// or just for it, if it isn't a child.
 521         BiblioInfo const & masterBibInfo() const;
 522         /// \return this buffer's bibliography information
 523         BiblioInfo const & bibInfo() const;
 524         /// collect bibliography info from the various insets in this buffer.
 525         void collectBibKeys(support::FileNameList &) const;
 526         /// add some BiblioInfo to our cache
 527         void addBiblioInfo(BiblioInfo const & bi) const;
 528         /// add a single piece of bibliography info to our cache
 529         void addBibTeXInfo(docstring const & key, BibTeXInfo const & bi) const;
 530         ///
 531         void makeCitationLabels() const;
 532         ///
 533         void invalidateCiteLabels() const;
 534         ///
 535         bool citeLabelsValid() const;
 536         ///
 537         void getLabelList(std::vector<docstring> &) const;
 538
 539         /// This removes the .aux and .bbl files from the temp dir.
 540         void removeBiblioTempFiles() const;
 541
 542         ///
 543         void changeLanguage(Language const * from, Language const * to);
 544
 545         ///
 546         bool isMultiLingual() const;
 547         ///
 548         std::set<Language const *> getLanguages() const;
 549
 550         ///
 551         BufferParams & params();
 552         BufferParams const & params() const;
 553         ///
 554         BufferParams const & masterParams() const;
 555
 556         /** The list of paragraphs.
 557             This is a linked list of paragraph, this list holds the
 558             whole contents of the document.
 559          */
 560         ParagraphList & paragraphs();
 561         ParagraphList const & paragraphs() const;
 562
 563         /// LyX version control object.
 564         LyXVC & lyxvc();
 565         LyXVC const & lyxvc() const;
 566
 567         /// Where to put temporary files.
 568         std::string const temppath() const;
 569
 570         /// Used when typesetting to place errorboxes.
 571         TexRow const & texrow() const;
 572         TexRow & texrow();
 573
 574         ///
 575         ParIterator par_iterator_begin();
 576         ///
 577         ParConstIterator par_iterator_begin() const;
 578         ///
 579         ParIterator par_iterator_end();
 580         ///
 581         ParConstIterator par_iterator_end() const;
 582
 583         // Position of the child buffer where it appears first in the master.
 584         DocIterator firstChildPosition(Buffer const * child);
 585
 586         /** \returns true only when the file is fully loaded.
 587          *  Used to prevent the premature generation of previews
 588          *  and by the citation inset.
 589          */
 590         bool isFullyLoaded() const;
 591         /// Set by buffer_funcs' newFile.
 592         void setFullyLoaded(bool);
 593
 594         /// FIXME: Needed by RenderPreview.
 595         graphics::PreviewLoader * loader() const;
 596         /// Update the LaTeX preview snippets associated with this buffer
 597         void updatePreviews() const;
 598         /// Remove any previewed LaTeX snippets associated with this buffer
 599         void removePreviews() const;
 600         ///
 601         graphics::Cache & graphicsCache() const;
 602
 603         /// Our main text (inside the top InsetText)
 604         Text & text() const;
 605
 606         /// Our top InsetText
 607         Inset & inset() const;
 608
 609         //
 610         // Macro handling
 611         //
 612         /// Collect macro definitions in paragraphs
 613         void updateMacros() const;
 614         /// Iterate through the whole buffer and try to resolve macros
 615         void updateMacroInstances(UpdateType) const;
 616
 617         /// List macro names of this buffer, the parent and the children
 618         void listMacroNames(MacroNameSet & macros) const;
 619         /// Collect macros of the parent and its children in front of this buffer.
 620         void listParentMacros(MacroSet & macros, LaTeXFeatures & features) const;
 621
 622         /// Return macro defined before pos (or in the master buffer)
 623         MacroData const * getMacro(docstring const & name, DocIterator const & pos, bool global = true) const;
 624         /// Return macro defined anywhere in the buffer (or in the master buffer)
 625         MacroData const * getMacro(docstring const & name, bool global = true) const;
 626         /// Return macro defined before the inclusion of the child
 627         MacroData const * getMacro(docstring const & name, Buffer const & child, bool global = true) const;
 628
 629         /// Collect user macro names at loading time
 630         typedef std::set<docstring> UserMacroSet;
 631         mutable UserMacroSet usermacros;
 632
 633         /// Replace the inset contents for insets which InsetCode is equal
 634         /// to the passed \p inset_code.
 635         void changeRefsIfUnique(docstring const & from, docstring const & to);
 636
 637         /// get source code (latex/docbook) for some paragraphs, or all paragraphs
 638         /// including preamble
 639         /// returns nullptr if Id to Row conversion is unsupported
 640         unique_ptr<TexRow> getSourceCode(odocstream & os,
 641                         std::string const & format, pit_type par_begin,
 642                         pit_type par_end, OutputWhat output, bool master) const;
 643
 644         /// Access to error list.
 645         /// This method is used only for GUI visualisation of Buffer related
 646         /// errors (like parsing or LateX compilation). This method is const
 647         /// because modifying the returned ErrorList does not touch the document
 648         /// contents.
 649         ErrorList & errorList(std::string const & type) const;
 650
 651         /// The Toc backend.
 652         /// This is useful only for screen visualisation of the Buffer. This
 653         /// method is const because modifying this backend does not touch
 654         /// the document contents.
 655         TocBackend & tocBackend() const;
 656
 657         ///
 658         Undo & undo();
 659
 660         /// This function is called when the buffer is changed.
 661         void changed(bool update_metrics) const;
 662         ///
 663         void setChild(DocIterator const & dit, Buffer * child);
 664         ///
 665         void updateTocItem(std::string const &, DocIterator const &) const;
 666         /// This function is called when the buffer structure is changed.
 667         void structureChanged() const;
 668         /// This function is called when some parsing error shows up.
 669         void errors(std::string const & err, bool from_master = false) const;
 670         /// This function is called when the buffer busy status change.
 671         void setBusy(bool on) const;
 672         /// Update window titles of all users.
 673         void updateTitles() const;
 674         /// Reset autosave timers for all users.
 675         void resetAutosaveTimers() const;
 676         ///
 677         void message(docstring const & msg) const;
 678
 679         ///
 680         void setGuiDelegate(frontend::GuiBufferDelegate * gui);
 681         ///
 682         bool hasGuiDelegate() const;
 683
 684         ///
 685         ExportStatus doExport(std::string const & target, bool put_in_tempdir) const;
 686         /// Export buffer to format \p format and open the result in a suitable viewer.
 687         /// Note: This has nothing to do with preview of graphics or math formulas.
 688         ExportStatus preview(std::string const & format) const;
 689         /// true if there was a previous preview this session of this buffer and
 690         /// there was an error on the previous preview of this buffer.
 691         bool lastPreviewError() const;
 692
 693 private:
 694         ///
 695         ExportStatus doExport(std::string const & target, bool put_in_tempdir,
 696                 std::string & result_file) const;
 697         /// target is a format name optionally followed by a space
 698         /// and a destination file-name
 699         ExportStatus doExport(std::string const & target, bool put_in_tempdir,
 700                 bool includeall, std::string & result_file) const;
 701         ///
 702         ExportStatus preview(std::string const & format, bool includeall) const;
 703         ///
 704         void setMathFlavor(OutputParams & op) const;
 705
 706 public:
 707         ///
 708         bool isExporting() const;
 709
 710         /// A collection of InsetRef insets and their position in the buffer
 711         typedef std::vector<std::pair<Inset *, ParIterator> > References;
 712         /// Get all InsetRef insets and their positions associated with
 713         /// the InsetLabel with the label string \p label
 714         References const & references(docstring const & label) const;
 715         /// Add an InsetRef at position \p it to the Insetlabel
 716         /// with the label string \p label
 717         void addReference(docstring const & label, Inset * inset, ParIterator it);
 718         /// Clear the whole reference cache
 719         void clearReferenceCache() const;
 720         /// Set the InsetLabel for a given \p label string. \p active
 721         /// determines whether this is an active label (see @ref activeLabel)
 722         void setInsetLabel(docstring const & label, InsetLabel const * il,
 723                            bool const active);
 724         /// \return the InsetLabel associated with this \p label string
 725         /// If \p active is true we only return active labels
 726         /// (see @ref activeLabel)
 727         InsetLabel const * insetLabel(docstring const & label,
 728                                       bool const active = false) const;
 729         /// \return true if this \param label is an active label.
 730         /// Inactive labels are currently deleted labels (in ct mode)
 731         bool activeLabel(docstring const & label) const;
 732
 733         /// return a list of all used branches (also in children)
 734         void getUsedBranches(std::list<docstring> &, bool const from_master = false) const;
 735
 736         /// sets the buffer_ member for every inset in this buffer.
 737         // FIXME This really shouldn't be needed, but at the moment it's not
 738         // clear how to do it just for the individual pieces we need.
 739         void setBuffersForInsets() const;
 740         /// Updates screen labels and some other information associated with
 741         /// insets and paragraphs. Actually, it's more like a general "recurse
 742         /// through the Buffer" routine, that visits all the insets and paragraphs.
 743         void updateBuffer() const { updateBuffer(UpdateMaster, InternalUpdate); }
 744         /// \param scope: whether to start with the master document or just
 745         /// do this one.
 746         /// \param output: whether we are preparing for output.
 747         void updateBuffer(UpdateScope scope, UpdateType utype) const;
 748         ///
 749         void updateBuffer(ParIterator & parit, UpdateType utype) const;
 750
 751         /// Spellcheck starting from \p from.
 752         /// \p from initial position, will then points to the next misspelled
 753         ///    word.
 754         /// \p to will points to the end of the next misspelled word.
 755         /// \p word_lang will contain the found misspelled word.
 756         /// \return progress if a new word was found.
 757         int spellCheck(DocIterator & from, DocIterator & to,
 758                 WordLangTuple & word_lang, docstring_list & suggestions) const;
 759         ///
 760         void checkChildBuffers();
 761         ///
 762         void checkMasterBuffer();
 763
 764         /// If the document is being saved to a new location and the named file
 765         /// exists at the old location, return its updated path relative to the
 766         /// new buffer path if possible, otherwise return its absolute path.
 767         /// In all other cases, this is a no-op and name is returned unchanged.
 768         /// If a non-empty ext is given, the existence of name.ext is checked
 769         /// but the returned path will not contain this extension.
 770         /// Similarly, when loading a document that was moved from the location
 771         /// where it was saved, return the correct path relative to the new
 772         /// location.
 773         std::string includedFilePath(std::string const & name,
 774                                 std::string const & ext = empty_string()) const;
 775
 776         /// compute statistics between \p from and \p to
 777         /// \p from initial position
 778         /// \p to points to the end position
 779         /// \p skipNoOutput if notes etc. should be ignored
 780         void updateStatistics(DocIterator & from, DocIterator & to,
 781                                                   bool skipNoOutput = true) const;
 782         /// statistics accessor functions
 783         int wordCount() const;
 784         int charCount(bool with_blanks) const;
 785
 786         // this is const because it does not modify the buffer's real contents,
 787         // only the mutable flag.
 788         void setChangesPresent(bool) const;
 789         bool areChangesPresent() const;
 790         void updateChangesPresent() const;
 791         ///
 792         void registerBibfiles(docstring_list const & bf) const;
 793         ///
 794         support::FileName getBibfilePath(docstring const & bibid) const;
 795
 796 private:
 797         friend class MarkAsExporting;
 798         /// mark the buffer as busy exporting something, or not
 799         void setExportStatus(bool e) const;
 800
 801         ///
 802         References & getReferenceCache(docstring const & label);
 803         /// Change name of buffer. Updates "read-only" flag.
 804         void setFileName(support::FileName const & fname);
 805         ///
 806         void getLanguages(std::set<Language const *> &) const;
 807         /// Checks whether any of the referenced bibfiles have changed since the
 808         /// last time we loaded the cache. Note that this does NOT update the
 809         /// cached information.
 810         void checkIfBibInfoCacheIsValid() const;
 811         /// Update the list of all bibfiles in use (including bibfiles
 812         /// of loaded child documents).
 813         void updateBibfilesCache(UpdateScope scope = UpdateMaster) const;
 814         /// Return the list with all bibfiles in use (including bibfiles
 815         /// of loaded child documents).
 816         docstring_list const &
 817                 getBibfiles(UpdateScope scope = UpdateMaster) const;
 818         ///
 819         void collectChildren(ListOfBuffers & children, bool grand_children) const;
 820
 821         /// noncopyable
 822         Buffer(Buffer const &);
 823         void operator=(Buffer const &);
 824
 825         /// Use the Pimpl idiom to hide the internals.
 826         class Impl;
 827         /// The pointer never changes although *pimpl_'s contents may.
 828         Impl * const d;
 829 };
 830
 831
 832 /// Helper class, to guarantee that the export status
 833 /// gets reset properly. To use, simply create a local variable:
 834 ///    MarkAsExporting mex(bufptr);
 835 /// and leave the rest to us.
 836 class MarkAsExporting {
 837 public:
 838         MarkAsExporting(Buffer const * buf) : buf_(buf)
 839         {
 840                 buf_->setExportStatus(true);
 841         }
 842         ~MarkAsExporting()
 843         {
 844                 buf_->setExportStatus(false);
 845         }
 846 private:
 847         Buffer const * const buf_;
 848 };
 849
 850
 851 } // namespace lyx
 852
 853 #endif