X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBuffer.h;h=d483de9a0839bccdc891456a46e144bc53e0f3e1;hb=28be7d552f62cc02fa86d7f79201d089bfb2d7b5;hp=898be68ff8cd8d57afbec8872223c3fb6f2d89b2;hpb=9622577c60c0975b2fae3441382ca44b5cf5de87;p=lyx.git diff --git a/src/Buffer.h b/src/Buffer.h index 898be68ff8..d483de9a08 100644 --- a/src/Buffer.h +++ b/src/Buffer.h @@ -12,12 +12,15 @@ #ifndef BUFFER_H #define BUFFER_H -#include "insets/InsetCode.h" +#include "OutputEnums.h" +#include "support/unique_ptr.h" #include "support/strfwd.h" #include "support/types.h" -#include "support/SignalSlot.h" +#include +#include +#include #include #include @@ -25,19 +28,20 @@ namespace lyx { class BiblioInfo; +class BibTeXInfo; class BufferParams; -class BufferSet; +class DispatchResult; class DocIterator; -class ErrorItem; +class docstring_list; class ErrorList; class FuncRequest; +class FuncStatus; class Inset; -class InsetRef; class InsetLabel; +class InsetRef; class Font; class Format; class Lexer; -class LyXRC; class Text; class LyXVC; class LaTeXFeatures; @@ -46,6 +50,7 @@ class MacroData; class MacroNameSet; class MacroSet; class OutputParams; +class otexstream; class Paragraph; class ParConstIterator; class ParIterator; @@ -54,6 +59,7 @@ class TeXErrors; class TexRow; class TocBackend; class Undo; +class WordLangTuple; namespace frontend { class GuiBufferDelegate; @@ -61,12 +67,25 @@ class WorkAreaManager; } namespace support { +class DocFileName; class FileName; -class FileNameList; +class FileNamePairList; +} + +namespace graphics { +class PreviewLoader; +class Cache; } + +class Buffer; +typedef std::list ListOfBuffers; +/// a list of Buffers we cloned +typedef std::set CloneList; + + /** The buffer object. - * This is the buffer object. It contains all the informations about + * This is the buffer object. It contains all the information about * a document loaded into LyX. * The buffer object owns the Text (wrapped in an InsetText), which * contains the individual paragraphs of the document. @@ -76,6 +95,9 @@ class FileNameList; * minimal, probably not. * \author Lars Gullik Bjønnes */ + +class MarkAsExporting; + class Buffer { public: /// What type of log will \c getLogName() return? @@ -86,65 +108,75 @@ public: /// Result of \c readFile() enum ReadStatus { - failure, ///< The file could not be read - success, ///< The file could not be read - wrongversion ///< The version of the file does not match ours + ReadSuccess, + ReadCancel, + // failures + ReadFailure, + ReadWrongVersion, + ReadFileNotFound, + ReadVCError, + ReadAutosaveFailure, + ReadEmergencyFailure, + ReadNoLyXFormat, + ReadDocumentFailure, + // lyx2lyx + LyX2LyXNoTempFile, + LyX2LyXNotFound, + LyX2LyXOlderFormat, + LyX2LyXNewerFormat, + // other + ReadOriginal }; + enum ExportStatus { + // export + ExportSuccess, + ExportCancel, + ExportError, + ExportNoPathToFormat, + ExportTexPathHasSpaces, + ExportConverterError, + // preview + // Implies ExportSuccess. + PreviewSuccess, + // The exported file exists but there was an error when opening + // it in a viewer. + PreviewError + }; - /// Method to check if a file is externally modified, used by - /// isExternallyModified() - /** - * timestamp is fast but inaccurate. For example, the granularity - * of timestamp on a FAT filesystem is 2 second. Also, various operations - * may touch the timestamp of a file even when its content is unchanged. - * - * checksum is accurate but slow, which can be a problem when it is - * frequently used, or used for a large file on a slow (network) file - * system. - * - * FIXME: replace this method with support/FileMonitor. - */ - enum CheckMethod { - checksum_method, ///< Use file checksum - timestamp_method, ///< Use timestamp, and checksum if timestamp has changed + /// + enum UpdateScope { + UpdateMaster, + UpdateChildOnly }; /// Constructor - explicit Buffer(std::string const & file, bool b = false); + explicit Buffer(std::string const & file, bool readonly = false, + Buffer const * cloned_buffer = 0); /// Destructor ~Buffer(); + /// Clones the entire structure of which this Buffer is part, starting + /// with the master and cloning all the children, too. + Buffer * cloneFromMaster() const; + /// Just clones this single Buffer. For autosave. + Buffer * cloneBufferOnly() const; + /// + bool isClone() const; + /** High-level interface to buffer functionality. - This function parses a command string and executes it + This function parses a command string and executes it. */ - bool dispatch(std::string const & command, bool * result = 0); + void dispatch(std::string const & command, DispatchResult & result); /// Maybe we know the function already by number... - bool dispatch(FuncRequest const & func, bool * result = 0); + void dispatch(FuncRequest const & func, DispatchResult & result); - /// Load the autosaved file. - void loadAutoSaveFile(); + /// Can this function be exectued? + /// \return true if we made a decision + bool getStatus(FuncRequest const & cmd, FuncStatus & flag); - /// read a new document from a string - bool readString(std::string const &); - /// load a new file - bool readFile(support::FileName const & filename); - - /// read the header, returns number of unknown tokens - int readHeader(Lexer & lex); - - /** Reads a file without header. - \param par if != 0 insert the file. - \return \c true if file is not completely read. - */ - bool readDocument(Lexer &); - - /// - void insertStringAsLines(ParagraphList & plist, - pit_type &, pos_type &, - Font const &, docstring const &, bool); /// DocIterator getParFromID(int id) const; /// do we have a paragraph with this id? @@ -158,24 +190,116 @@ public: Returns \c true if the save is successful, \c false otherwise. */ bool save() const; + /// Renames and saves the buffer + bool saveAs(support::FileName const & fn); - /// Write document to stream. Returns \c false if unsuccesful. + /// Write document to stream. Returns \c false if unsuccessful. bool write(std::ostream &) const; - /// Write file. Returns \c false if unsuccesful. + /// Write file. Returns \c false if unsuccessful. bool writeFile(support::FileName const &) const; - /// Loads LyX file \c filename into buffer, * and \return success - bool loadLyXFile(support::FileName const & s); + /// \name Functions involved in reading files/strings. + //@{ + /// Loads the LyX file into the buffer. This function + /// tries to extract the file from version control if it + /// cannot be found. If it can be found, it will try to + /// read an emergency save file or an autosave file. + /// \sa loadThisLyXFile + ReadStatus loadLyXFile(); + /// Loads the LyX file \c fn into the buffer. If you want + /// to check for files in a version control container, + /// emergency or autosave files, one should use \c loadLyXFile. + /// /sa loadLyXFile + ReadStatus loadThisLyXFile(support::FileName const & fn); + /// import a new document from a string + bool importString(std::string const &, docstring const &, ErrorList &); + /// import a new file + bool importFile(std::string const &, support::FileName const &, ErrorList &); + /// read a new document from a string + bool readString(std::string const &); + /// Reloads the LyX file + ReadStatus reload(); +//FIXME: The following function should be private +//private: + /// read the header, returns number of unknown tokens + int readHeader(Lexer & lex); + + double fontScalingFactor() const; + +private: + /// + typedef std::map BufferMap; + /// + void cloneWithChildren(BufferMap &, CloneList *) const; + /// save checksum of the given file. + void saveCheckSum() const; + /// read a new file + ReadStatus readFile(support::FileName const & fn); + /// Reads a file without header. + /// \param par if != 0 insert the file. + /// \return \c true if file is not completely read. + bool readDocument(Lexer &); + /// Try to extract the file from a version control container + /// before reading if the file cannot be found. + /// \sa LyXVC::file_not_found_hook + ReadStatus extractFromVC(); + /// Reads the first tag of a LyX File and + /// returns the file format number. + ReadStatus parseLyXFormat(Lexer & lex, support::FileName const & fn, + int & file_format) const; + /// Convert the LyX file to the LYX_FORMAT using + /// the lyx2lyx script and returns the filename + /// of the temporary file to be read + ReadStatus convertLyXFormat(support::FileName const & fn, + support::FileName & tmpfile, int from_format); + /// get appropriate name for backing up files from older versions + support::FileName getBackupName() const; + //@} + +public: + /// \name Functions involved in autosave and emergency files. + //@{ + /// Save an autosave file to #filename.lyx# + bool autoSave() const; + /// save emergency file + /// \return a status message towards the user. + docstring emergencyWrite(); + +//FIXME:The following function should be private +//private: + /// + void removeAutosaveFile() const; +private: + /// Try to load an autosave file associated to \c fn. + ReadStatus loadAutosave(); + /// Try to load an emergency file associated to \c fn. + ReadStatus loadEmergency(); + /// Get the filename of the emergency file associated with the Buffer + support::FileName getEmergencyFileName() const; + /// Get the filename of the autosave file associated with the Buffer + support::FileName getAutosaveFileName() const; + /// + void moveAutosaveFile(support::FileName const & old) const; + //@} + +public: /// Fill in the ErrorList with the TeXErrors void bufferErrors(TeXErrors const &, ErrorList &) const; + enum OutputWhat { + FullSource, + OnlyBody, + IncludedFile, + OnlyPreamble, + CurrentParagraph + }; + /// Just a wrapper for writeLaTeXSource, first creating the ofstream. bool makeLaTeXFile(support::FileName const & filename, std::string const & original_path, OutputParams const &, - bool output_preamble = true, - bool output_body = true) const; + OutputWhat output = FullSource) const; /** Export the buffer to LaTeX. If \p os is a file stream, and params().inputenc is "auto" or "default", and the buffer contains text in different languages @@ -184,31 +308,39 @@ public: method with a string stream if the output is supposed to go to a file. \code ofdocstream ofs; + otexstream os(ofs); ofs.open("test.tex"); - writeLaTeXSource(ofs, ...); + writeLaTeXSource(os, ...); ofs.close(); \endcode is NOT equivalent to \code odocstringstream oss; - writeLaTeXSource(oss, ...); + otexstream os(oss); + writeLaTeXSource(os, ...); ofdocstream ofs; ofs.open("test.tex"); ofs << oss.str(); ofs.close(); \endcode */ - void writeLaTeXSource(odocstream & os, + void writeLaTeXSource(otexstream & os, std::string const & original_path, OutputParams const &, - bool output_preamble = true, - bool output_body = true) const; + OutputWhat output = FullSource) const; /// void makeDocBookFile(support::FileName const & filename, OutputParams const & runparams_in, - bool only_body = false) const; + OutputWhat output = FullSource) const; /// void writeDocBookSource(odocstream & os, std::string const & filename, OutputParams const & runparams_in, - bool only_body = false) const; + OutputWhat output = FullSource) const; + /// + void makeLyXHTMLFile(support::FileName const & filename, + OutputParams const & runparams_in) const; + /// + void writeLyXHTMLSource(odocstream & os, + OutputParams const & runparams_in, + OutputWhat output = FullSource) const; /// returns the main language for the buffer (document) Language const * language() const; /// get l10n translated to the buffers language @@ -219,31 +351,39 @@ public: /// return true if the main lyx file does not need saving bool isClean() const; /// - bool isBakClean() const; - /// bool isDepClean(std::string const & name) const; - /// whether or not disk file has been externally modified - bool isExternallyModified(CheckMethod method) const; + /// Whether or not disk file has been externally modified. Uses a checksum + /// which is accurate but slow, which can be a problem when it is frequently + /// used, or used for a large file on a slow (network) file system. + bool isChecksumModified() const; - /// save timestamp and checksum of the given file. - void saveCheckSum(support::FileName const & file) const; + /// Flag set by the FileSystemWatcher. + /// Fast but (not so) inaccurate, can be cleared by the user. + bool notifiesExternalModification() const; + void clearExternalModification() const; /// mark the main lyx file as not needing saving void markClean() const; - /// - void markBakClean() const; - /// void markDepClean(std::string const & name); /// void setUnnamed(bool flag = true); - /// + /// Whether or not a filename has been assigned to this buffer bool isUnnamed() const; + /// Whether or not this buffer is internal. + /// + /// An internal buffer does not contain a real document, but some auxiliary text segment. + /// It is not associated with a filename, it is never saved, thus it does not need to be + /// automatically saved, nor it needs to trigger any "do you want to save ?" question. + bool isInternal() const; + + void setInternal(bool flag); + /// Mark this buffer as dirty. void markDirty(); @@ -253,28 +393,55 @@ public: /// Returns the buffer's filename. It is always an absolute path. std::string absFileName() const; - /// Returns the the path where the buffer lives. + /// Returns the path where the buffer lives. /// It is always an absolute path. std::string filePath() const; + /** Contructs a file name of a referenced file (child doc, included graphics etc). + * Absolute names are returned as is. If the name is relative, it is + * interpreted relative to filePath() if the file exists, otherwise + * relative to the original path where the document was last saved. + * The original path may be different from filePath() if the document was + * later manually moved to a different location. + */ + support::DocFileName getReferencedFileName(std::string const & fn) const; + + /// Format a file name for LaTeX output (absolute or relative or filename only, + /// depending on file and context) + std::string const prepareFileNameForLaTeX(std::string const &, + std::string const &, bool nice) const; + + /** Returns a vector of bibliography (*.bib) file paths suitable for the + * output in the respective BibTeX/Biblatex macro + */ + std::vector const prepareBibFilePaths(OutputParams const &, + support::FileNamePairList const bibfilelist, + bool const extension = true) const; + + /** Returns the path where a local layout file lives. + * An empty string is returned for standard system and user layouts. + * If possible, it is always relative to the buffer path. + */ + std::string layoutPos() const; + + /** Set the path to a local layout file. + * This must be an absolute path but, if possible, it is always + * stored as relative to the buffer path. + */ + void setLayoutPos(std::string const & path); + /** A transformed version of the file name, adequate for LaTeX. \param no_path optional if \c true then the path is stripped. */ std::string latexName(bool no_path = true) const; - /// Get thee name and type of the log. + /// Get the name and type of the log. std::string logName(LogType * type = 0) const; - /// Change name of buffer. Updates "read-only" flag. - void setFileName(std::string const & newfile); - /// Set document's parent Buffer. void setParent(Buffer const *); Buffer const * parent() const; - // Collect all relative buffer - std::vector allRelatives() const; - /** Get the document's master (or \c this if this is not a child document) */ @@ -283,19 +450,37 @@ public: /// \return true if \p child is a child of this \c Buffer. bool isChild(Buffer * child) const; - /// Is buffer read-only? + /// \return true if this \c Buffer has children + bool hasChildren() const; + + /// \return a list of the direct children of this Buffer. + /// this list has no duplicates and is in the order in which + /// the children appear. + ListOfBuffers getChildren() const; + + /// \return a list of all descendents of this Buffer (children, + /// grandchildren, etc). this list has no duplicates and is in + /// the order in which the children appear. + ListOfBuffers getDescendents() const; + + /// Collect all relative buffers, in the order in which they appear. + /// I.e., the "root" Buffer is first, then its first child, then any + /// of its children, etc. However, there are no duplicates in this + /// list. + /// This is "stable", too, in the sense that it returns the same + /// thing from whichever Buffer it is called. + ListOfBuffers allRelatives() const; + + /// Is buffer read-only? True if it has either the read-only flag or the + /// externally modified flag. bool isReadonly() const; + /// Does the buffer have the read-only flag? + bool hasReadonlyFlag() const; + /// Set buffer read-only flag void setReadonly(bool flag = true); - /// returns \c true if the buffer contains a LaTeX document - bool isLatex() const; - /// returns \c true if the buffer contains a DocBook document - bool isDocBook() const; - /// returns \c true if the buffer contains a Wed document - bool isLiterate() const; - /** Validate a buffer for LaTeX. This validates the buffer, and returns a struct for use by #makeLaTeX# and others. Its main use is to figure out what @@ -307,31 +492,62 @@ public: */ void validate(LaTeXFeatures &) const; - /// Update the cache with all bibfiles in use (including bibfiles - /// of loaded child documents). - void updateBibfilesCache() const; - /// - void invalidateBibinfoCache(); - /// Return the cache with all bibfiles in use (including bibfiles - /// of loaded child documents). - support::FileNameList const & getBibfilesCache() const; + /// Reference information is cached in the Buffer, so we do not + /// have to check or read things over and over. + /// + /// There are two caches. + /// + /// One is a cache of the BibTeX files from which reference info is + /// being gathered. This cache is PER BUFFER, and the cache for the + /// master essentially includes the cache for its children. This gets + /// invalidated when an InsetBibtex is created, deleted, or modified. + /// + /// The other is a cache of the reference information itself. This + /// exists only in the master buffer, and when it needs to be updated, + /// the children add their information to the master's cache. + + /// Calling this method invalidates the cache and so requires a + /// re-read. + void invalidateBibinfoCache() const; + /// This invalidates the cache of files we need to check. + void invalidateBibfileCache() const; + /// Updates the cached bibliography information, checking first to see + /// whether the cache is valid. If so, we do nothing. If not, then we + /// reload all the BibTeX info. + /// Note that this operates on the master document. + void reloadBibInfoCache() const; /// \return the bibliography information for this buffer's master, /// or just for it, if it isn't a child. BiblioInfo const & masterBibInfo() const; - /// \return the bibliography information for this buffer ONLY. - BiblioInfo const & localBibInfo() const; + /// collect bibliography info from the various insets in this buffer. + void collectBibKeys() const; + /// add some BiblioInfo to our cache + void addBiblioInfo(BiblioInfo const & bi) const; + /// add a single piece of bibliography info to our cache + void addBibTeXInfo(docstring const & key, BibTeXInfo const & bi) const; + /// + void makeCitationLabels() const; + /// + bool citeLabelsValid() const; /// void getLabelList(std::vector &) const; + /// This removes the .aux and .bbl files from the temp dir. + void removeBiblioTempFiles() const; + /// void changeLanguage(Language const * from, Language const * to); /// bool isMultiLingual() const; + /// + std::set getLanguages() const; /// BufferParams & params(); BufferParams const & params() const; + /// + BufferParams const & masterParams() const; /** The list of paragraphs. This is a linked list of paragraph, this list holds the @@ -371,6 +587,15 @@ public: /// Set by buffer_funcs' newFile. void setFullyLoaded(bool); + /// FIXME: Needed by RenderPreview. + graphics::PreviewLoader * loader() const; + /// Update the LaTeX preview snippets associated with this buffer + void updatePreviews() const; + /// Remove any previewed LaTeX snippets associated with this buffer + void removePreviews() const; + /// + graphics::Cache & graphicsCache() const; + /// Our main text (inside the top InsetText) Text & text() const; @@ -383,7 +608,7 @@ public: /// Collect macro definitions in paragraphs void updateMacros() const; /// Iterate through the whole buffer and try to resolve macros - void updateMacroInstances() const; + void updateMacroInstances(UpdateType) const; /// List macro names of this buffer, the parent and the children void listMacroNames(MacroNameSet & macros) const; @@ -397,15 +622,20 @@ public: /// Return macro defined before the inclusion of the child MacroData const * getMacro(docstring const & name, Buffer const & child, bool global = true) const; + /// Collect user macro names at loading time + typedef std::set UserMacroSet; + mutable UserMacroSet usermacros; + /// Replace the inset contents for insets which InsetCode is equal /// to the passed \p inset_code. - void changeRefsIfUnique(docstring const & from, docstring const & to, - InsetCode code); + void changeRefsIfUnique(docstring const & from, docstring const & to); /// get source code (latex/docbook) for some paragraphs, or all paragraphs /// including preamble - void getSourceCode(odocstream & os, pit_type par_begin, pit_type par_end, - bool full_source) const; + /// returns nullptr if Id to Row conversion is unsupported + unique_ptr getSourceCode(odocstream & os, + std::string const & format, pit_type par_begin, + pit_type par_end, OutputWhat output, bool master) const; /// Access to error list. /// This method is used only for GUI visualisation of Buffer related @@ -424,17 +654,17 @@ public: Undo & undo(); /// This function is called when the buffer is changed. - void changed() const; + void changed(bool update_metrics) const; + /// + void setChild(DocIterator const & dit, Buffer * child); /// void updateTocItem(std::string const &, DocIterator const &) const; /// This function is called when the buffer structure is changed. void structureChanged() const; /// This function is called when some parsing error shows up. - void errors(std::string const & err) const; + void errors(std::string const & err, bool from_master = false) const; /// This function is called when the buffer busy status change. void setBusy(bool on) const; - /// This function is called when the buffer readonly status change. - void setReadOnly(bool on) const; /// Update window titles of all users. void updateTitles() const; /// Reset autosave timers for all users. @@ -442,80 +672,161 @@ public: /// void message(docstring const & msg) const; + /// void setGuiDelegate(frontend::GuiBufferDelegate * gui); - /// - void autoSave() const; + bool hasGuiDelegate() const; - /// return the format of the buffer on a string - std::string bufferFormat() const; + /// + ExportStatus doExport(std::string const & target, bool put_in_tempdir) const; + /// Export buffer to format \p format and open the result in a suitable viewer. + /// Note: This has nothing to do with preview of graphics or math formulas. + ExportStatus preview(std::string const & format) const; + /// true if there was a previous preview this session of this buffer and + /// there was an error on the previous preview of this buffer. + bool lastPreviewError() const; +private: /// - bool doExport(std::string const & format, bool put_in_tempdir, + ExportStatus doExport(std::string const & target, bool put_in_tempdir, std::string & result_file) const; + /// target is a format name optionally followed by a space + /// and a destination file-name + ExportStatus doExport(std::string const & target, bool put_in_tempdir, + bool includeall, std::string & result_file) const; /// - bool doExport(std::string const & format, bool put_in_tempdir) const; + ExportStatus preview(std::string const & format, bool includeall) const; /// - bool preview(std::string const & format) const; - /// - bool isExportable(std::string const & format) const; + void setMathFlavor(OutputParams & op) const; + +public: /// - std::vector exportableFormats(bool only_viewable) const; + bool isExporting() const; /// - typedef std::vector > References; - References & references(docstring const & label); + typedef std::vector > References; + /// References const & references(docstring const & label) const; + /// + void addReference(docstring const & label, Inset * inset, ParIterator it); + /// void clearReferenceCache() const; + /// void setInsetLabel(docstring const & label, InsetLabel const * il); + /// InsetLabel const * insetLabel(docstring const & label) const; - // FIXME: buf should should be const because updateLabels() modifies - // the contents of the paragraphs. - void updateLabels(bool childonly = false) const; - /// - void updateLabels(ParIterator & parit) const; + /// return a list of all used branches (also in children) + void getUsedBranches(std::list &, bool const from_master = false) const; + + /// sets the buffer_ member for every inset in this buffer. + // FIXME This really shouldn't be needed, but at the moment it's not + // clear how to do it just for the individual pieces we need. + void setBuffersForInsets() const; + /// Updates screen labels and some other information associated with + /// insets and paragraphs. Actually, it's more like a general "recurse + /// through the Buffer" routine, that visits all the insets and paragraphs. + void updateBuffer() const { updateBuffer(UpdateMaster, InternalUpdate); } + /// \param scope: whether to start with the master document or just + /// do this one. + /// \param output: whether we are preparing for output. + void updateBuffer(UpdateScope scope, UpdateType utype) const; + /// + void updateBuffer(ParIterator & parit, UpdateType utype) const; + + /// Spellcheck starting from \p from. + /// \p from initial position, will then points to the next misspelled + /// word. + /// \p to will points to the end of the next misspelled word. + /// \p word_lang will contain the found misspelled word. + /// \return progress if a new word was found. + int spellCheck(DocIterator & from, DocIterator & to, + WordLangTuple & word_lang, docstring_list & suggestions) const; + /// + void checkChildBuffers(); + /// + void checkMasterBuffer(); + + /// If the document is being saved to a new location and the named file + /// exists at the old location, return its updated path relative to the + /// new buffer path if possible, otherwise return its absolute path. + /// In all other cases, this is a no-op and name is returned unchanged. + /// If a non-empty ext is given, the existence of name.ext is checked + /// but the returned path will not contain this extension. + /// Similarly, when loading a document that was moved from the location + /// where it was saved, return the correct path relative to the new + /// location. + std::string includedFilePath(std::string const & name, + std::string const & ext = empty_string()) const; + + /// compute statistics between \p from and \p to + /// \p from initial position + /// \p to points to the end position + /// \p skipNoOutput if notes etc. should be ignored + void updateStatistics(DocIterator & from, DocIterator & to, + bool skipNoOutput = true) const; + /// statistics accessor functions + int wordCount() const; + int charCount(bool with_blanks) const; + + // this is const because it does not modify the buffer's real contents, + // only the mutable flag. + void setChangesPresent(bool) const; + bool areChangesPresent() const; + void updateChangesPresent() const; private: - /// search for macro in local (buffer) table or in children - MacroData const * getBufferMacro(docstring const & name, - DocIterator const & pos) const; - /** Update macro table starting with position of it - \param it in some text inset - */ - void updateMacros(DocIterator & it, - DocIterator & scope) const; - - /// - void collectRelatives(BufferSet & bufs) const; + friend class MarkAsExporting; + /// mark the buffer as busy exporting something, or not + void setExportStatus(bool e) const; /// - bool readFileHelper(support::FileName const & s); + References & getReferenceCache(docstring const & label); + /// Change name of buffer. Updates "read-only" flag. + void setFileName(support::FileName const & fname); + /// + void getLanguages(std::set &) const; + /// Checks whether any of the referenced bibfiles have changed since the + /// last time we loaded the cache. Note that this does NOT update the + /// cached information. + void checkIfBibInfoCacheIsValid() const; + /// Update the list of all bibfiles in use (including bibfiles + /// of loaded child documents). + void updateBibfilesCache(UpdateScope scope = UpdateMaster) const; + /// Return the list with all bibfiles in use (including bibfiles + /// of loaded child documents). + support::FileNamePairList const & + getBibfilesCache(UpdateScope scope = UpdateMaster) const; /// - std::vector backends() const; - /** Inserts a file into a document - \return \c false if method fails. - */ - ReadStatus readFile(Lexer &, support::FileName const & filename, - bool fromString = false); + void collectChildren(ListOfBuffers & children, bool grand_children) const; + + /// noncopyable + Buffer(Buffer const &); + void operator=(Buffer const &); /// Use the Pimpl idiom to hide the internals. class Impl; /// The pointer never changes although *pimpl_'s contents may. Impl * const d; +}; - frontend::GuiBufferDelegate * gui_; - /// This function is called when the buffer structure is changed. - Signal structureChanged_; - /// This function is called when some parsing error shows up. - //Signal errors(std::string const &) = 0; - /// This function is called when some message shows up. - //Signal message(docstring const &) = 0; - /// This function is called when the buffer busy status change. - //Signal setBusy(bool) = 0; - /// Reset autosave timers for all users. - Signal resetAutosaveTimers_; +/// Helper class, to guarantee that the export status +/// gets reset properly. To use, simply create a local variable: +/// MarkAsExporting mex(bufptr); +/// and leave the rest to us. +class MarkAsExporting { +public: + MarkAsExporting(Buffer const * buf) : buf_(buf) + { + buf_->setExportStatus(true); + } + ~MarkAsExporting() + { + buf_->setExportStatus(false); + } +private: + Buffer const * const buf_; };