#define BUFFER_H
#include "OutputEnums.h"
-#include "OutputParams.h"
-
-#include "insets/InsetCode.h"
+#include "support/unique_ptr.h"
#include "support/strfwd.h"
#include "support/types.h"
+#include "support/FileNameList.h"
#include <map>
#include <list>
class MacroNameSet;
class MacroSet;
class OutputParams;
+class otexstream;
class Paragraph;
class ParConstIterator;
class ParIterator;
namespace frontend {
class GuiBufferDelegate;
class WorkAreaManager;
-}
+} // namespace frontend
namespace support {
+class DocFileName;
class FileName;
-class FileNameList;
-}
+class FileNamePairList;
+} // namespace support
namespace graphics {
class PreviewLoader;
-}
+class Cache;
+} // namespace graphics
class Buffer;
typedef std::list<Buffer *> ListOfBuffers;
+/// a list of Buffers we cloned
+typedef std::set<Buffer *> 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.
* minimal, probably not.
* \author Lars Gullik Bjønnes
*/
+
+class MarkAsExporting;
+
class Buffer {
public:
/// What type of log will \c getLogName() return?
ReadWrongVersion,
ReadFileNotFound,
ReadVCError,
- ReadAutosaveFailure,
+ ReadAutosaveFailure,
ReadEmergencyFailure,
ReadNoLyXFormat,
ReadDocumentFailure,
ReadOriginal
};
-
- /// 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 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
};
///
/// Destructor
~Buffer();
- ///
- Buffer * clone() const;
+ /// 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;
/// 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
/// read the header, returns number of unknown tokens
int readHeader(Lexer & lex);
+ double fontScalingFactor() const;
+
private:
///
typedef std::map<Buffer const *, Buffer *> BufferMap;
///
- void clone(BufferMap &) const;
- /// save timestamp and checksum of the given file.
- void saveCheckSum() const;
+ 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.
/// \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. This is only
- /// implemented for RCS.
+ /// 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
+ /// 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,
+ 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;
+ bool autoSave() const;
/// save emergency file
/// \return a status message towards the user.
docstring emergencyWrite();
//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.
+ /// 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;
/// 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
method with a string stream if the output is supposed to go to a
file. \code
ofdocstream ofs;
- otexstream os(ofs, texrow);
+ otexstream os(ofs);
ofs.open("test.tex");
writeLaTeXSource(os, ...);
ofs.close();
\endcode is NOT equivalent to \code
odocstringstream oss;
- otexstream os(oss, texrow);
+ otexstream os(oss);
writeLaTeXSource(os, ...);
ofdocstream ofs;
ofs.open("test.tex");
\endcode
*/
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,
- bool only_body = false) const;
+ OutputWhat output = FullSource) const;
/// returns the main language for the buffer (document)
Language const * language() const;
/// get l10n translated to the buffers language
///
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;
+
+ /// 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;
/// 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();
/// 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<docstring> 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.
*/
/// \return true if \p child is a child of this \c Buffer.
bool isChild(Buffer * child) const;
-
+
/// \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.
/// thing from whichever Buffer it is called.
ListOfBuffers allRelatives() const;
- /// Is buffer read-only?
+ /// 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);
*/
void validate(LaTeXFeatures &) 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,
+ /// Bibliography information is cached in the Buffer, so we do not
+ /// have to check or read things over and over.
+ /// The cache exists only in the master buffer. When it is 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.
/// or just for it, if it isn't a child.
BiblioInfo const & masterBibInfo() const;
/// collect bibliography info from the various insets in this buffer.
- void collectBibKeys() const;
+ void collectBibKeys(support::FileNameList &) 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<docstring> &) const;
+ /// This removes the .aux and .bbl files from the temp dir.
+ void removeBiblioTempFiles() const;
+
///
void changeLanguage(Language const * from, Language const * to);
///
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
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;
/// 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, std::string const format,
- pit_type par_begin, pit_type par_end, bool full_source) const;
+ /// returns nullptr if Id to Row conversion is unsupported
+ unique_ptr<TexRow> 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
///
bool hasGuiDelegate() 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:
+ ///
+ 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
- bool doExport(std::string const & target, bool put_in_tempdir,
+ ExportStatus doExport(std::string const & target, bool put_in_tempdir,
bool includeall, std::string & result_file) const;
///
- bool doExport(std::string const & target, bool put_in_tempdir,
- bool includeall = false) const;
+ ExportStatus preview(std::string const & format, bool includeall) const;
///
- bool preview(std::string const & format, bool includeall = false) const;
- /// mark the buffer as busy exporting something, or not
- void setExportStatus(bool e) const;
+ void setMathFlavor(OutputParams & op) const;
+
+public:
///
bool isExporting() const;
///
typedef std::vector<std::pair<Inset *, ParIterator> > References;
- References & references(docstring const & label);
+ ///
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;
/// return a list of all used branches (also in children)
void getUsedBranches(std::list<docstring> &, 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.
/// 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.
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;
+ ///
+ void registerBibfiles(support::FileNamePairList const & bf) const;
private:
+ friend class MarkAsExporting;
+ /// mark the buffer as busy exporting something, or not
+ void setExportStatus(bool e) const;
+
+ ///
+ References & getReferenceCache(docstring const & label);
/// Change name of buffer. Updates "read-only" flag.
void setFileName(support::FileName const & fname);
///
/// 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::FileNameList const &
- getBibfilesCache(UpdateScope scope = UpdateMaster) const;
+ support::FileNamePairList const &
+ getBibfiles(UpdateScope scope = UpdateMaster) const;
///
void collectChildren(ListOfBuffers & children, bool grand_children) const;
};
+/// 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_;
+};
+
+
} // namespace lyx
#endif