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 "InsetList.h"
  16 #include "ParagraphList_fwd.h"
  17
  18 #include "support/limited_stack.h"
  19 #include "support/types.h"
  20
  21 #include <boost/scoped_ptr.hpp>
  22 #include <boost/signals/signal0.hpp>
  23 #include <boost/signals/signal1.hpp>
  24
  25 #include <iosfwd>
  26 #include <map>
  27 #include <utility>
  28 #include <vector>
  29
  30
  31 class BufferParams;
  32 class ErrorItem;
  33 class FuncRequest;
  34 class LyXFont;
  35 class LyXLex;
  36 class LyXRC;
  37 class LyXVC;
  38 class LaTeXFeatures;
  39 class LatexRunParams;
  40 class Language;
  41 class Messages;
  42 class ParIterator;
  43 class ParConstIterator;
  44 class TeXErrors;
  45 class TexRow;
  46 class Undo;
  47
  48
  49 /** The buffer object.
  50   This is the buffer object. It contains all the informations about
  51   a document loaded into LyX. I am not sure if the class is complete or
  52   minimal, probably not.
  53   \author Lars Gullik Bjønnes
  54   */
  55 class Buffer {
  56 public:
  57         /// What type of log will \c getLogName() return?
  58         enum LogType {
  59                 latexlog, ///< LaTeX log
  60                 buildlog  ///< Literate build log
  61         };
  62
  63         /** Constructor
  64             \param file
  65             \param b  optional \c false by default
  66         */
  67         explicit Buffer(std::string const & file, bool b = false);
  68
  69         /// Destructor
  70         ~Buffer();
  71
  72         /** High-level interface to buffer functionality.
  73             This function parses a command string and executes it
  74         */
  75         bool dispatch(std::string const & command, bool * result = 0);
  76
  77         /// Maybe we know the function already by number...
  78         bool dispatch(FuncRequest const & func, bool * result = 0);
  79
  80         /// Load the autosaved file.
  81         void loadAutoSaveFile();
  82
  83         /// load a new file
  84         bool readFile(std::string const & filename);
  85
  86         bool readFile(std::string const & filename, ParagraphList::iterator pit);
  87
  88         /// read the header, returns number of unknown tokens
  89         int readHeader(LyXLex & lex);
  90
  91         /** Reads a file without header.
  92             \param par if != 0 insert the file.
  93             \return \c false if file is not completely read.
  94         */
  95         bool readBody(LyXLex &, ParagraphList::iterator pit);
  96
  97         /// This parses a single token
  98         int readParagraph(LyXLex &, std::string const & token,
  99                           ParagraphList & pars,
 100                           ParagraphList::iterator & pit,
 101                           lyx::depth_type & depth);
 102
 103         ///
 104         void insertStringAsLines(ParagraphList::iterator &, lyx::pos_type &,
 105                                  LyXFont const &, std::string const &);
 106         ///
 107         ParIterator getParFromID(int id) const;
 108         /// do we have a paragraph with this id?
 109         bool hasParWithID(int id) const;
 110
 111         /// This signal is emitted when a parsing error shows up.
 112         boost::signal1<void, ErrorItem> error;
 113         /// This signal is emitted when some message shows up.
 114         boost::signal1<void, std::string> message;
 115         /// This signal is emitted when the buffer busy status change.
 116         boost::signal1<void, bool> busy;
 117         /// This signal is emitted when the buffer readonly status change.
 118         boost::signal1<void, bool> readonly;
 119         /// Update window titles of all users.
 120         boost::signal0<void> updateTitles;
 121         /// Reset autosave timers for all users.
 122         boost::signal0<void> resetAutosaveTimers;
 123         /// This signal is emitting if the buffer is being closed.
 124         boost::signal0<void> closing;
 125
 126
 127         /** Save file.
 128             Takes care of auto-save files and backup file if requested.
 129             Returns \c true if the save is successful, \c false otherwise.
 130         */
 131         bool save() const;
 132
 133         /// Write file. Returns \c false if unsuccesful.
 134         bool writeFile(std::string const &) const;
 135
 136         ///
 137         void writeFileAscii(std::string const &, int);
 138         ///
 139         void writeFileAscii(std::ostream &, int);
 140         ///
 141         std::string const asciiParagraph(Paragraph const &, unsigned int linelen,
 142                                     bool noparbreak = false) const;
 143         /// Just a wrapper for the method below, first creating the ofstream.
 144         void makeLaTeXFile(std::string const & filename,
 145                            std::string const & original_path,
 146                            LatexRunParams const &,
 147                            bool output_preamble = true,
 148                            bool output_body = true);
 149         ///
 150         void makeLaTeXFile(std::ostream & os,
 151                            std::string const & original_path,
 152                            LatexRunParams const &,
 153                            bool output_preamble = true,
 154                            bool output_body = true);
 155         ///
 156         void simpleDocBookOnePar(std::ostream &,
 157                                  ParagraphList::iterator par,
 158                                  int & desc_on,
 159                                  lyx::depth_type depth) const;
 160         ///
 161         void simpleLinuxDocOnePar(std::ostream & os,
 162                                   ParagraphList::iterator par,
 163                                   lyx::depth_type depth) const;
 164         ///
 165         void makeLinuxDocFile(std::string const & filename,
 166                               bool nice, bool only_body = false);
 167         ///
 168         void makeDocBookFile(std::string const & filename,
 169                              bool nice, bool only_body = false);
 170         /// returns the main language for the buffer (document)
 171         Language const * getLanguage() const;
 172         /// get l10n translated to the buffers language
 173         std::string const B_(std::string const & l10n) const;
 174
 175         ///
 176         int runChktex();
 177         /// return true if the main lyx file does not need saving
 178         bool isClean() const;
 179         ///
 180         bool isBakClean() const;
 181         ///
 182         bool isDepClean(std::string const & name) const;
 183
 184         /// mark the main lyx file as not needing saving
 185         void markClean() const;
 186
 187         ///
 188         void markBakClean();
 189
 190         ///
 191         void markDepClean(std::string const & name);
 192
 193         ///
 194         void setUnnamed(bool flag = true);
 195
 196         ///
 197         bool isUnnamed();
 198
 199         /// Mark this buffer as dirty.
 200         void markDirty();
 201
 202         /// Returns the buffer's filename. It is always an absolute path.
 203         std::string const & fileName() const;
 204
 205         /// Returns the the path where the buffer lives.
 206         /// It is always an absolute path.
 207         std::string const & filePath() const;
 208
 209         /** A transformed version of the file name, adequate for LaTeX.
 210             \param no_path optional if \c true then the path is stripped.
 211         */
 212         std::string const getLatexName(bool no_path = true) const;
 213
 214         /// Get the name and type of the log.
 215         std::pair<LogType, std::string> const getLogName() const;
 216
 217         /// Change name of buffer. Updates "read-only" flag.
 218         void setFileName(std::string const & newfile);
 219
 220         /// Name of the document's parent
 221         void setParentName(std::string const &);
 222
 223         /// Is buffer read-only?
 224         bool isReadonly() const;
 225
 226         /// Set buffer read-only flag
 227         void setReadonly(bool flag = true);
 228
 229         /// returns \c true if the buffer contains a LaTeX document
 230         bool isLatex() const;
 231         /// returns \c true if the buffer contains a LinuxDoc document
 232         bool isLinuxDoc() const;
 233         /// returns \c true if the buffer contains a DocBook document
 234         bool isDocBook() const;
 235         /** returns \c true if the buffer contains either a LinuxDoc
 236             or DocBook document */
 237         bool isSGML() const;
 238         /// returns \c true if the buffer contains a Wed document
 239         bool isLiterate() const;
 240
 241         /** Validate a buffer for LaTeX.
 242             This validates the buffer, and returns a struct for use by
 243             #makeLaTeX# and others. Its main use is to figure out what
 244             commands and packages need to be included in the LaTeX file.
 245             It (should) also check that the needed constructs are there
 246             (i.e. that the \refs points to coresponding \labels). It
 247             should perhaps inset "error" insets to help the user correct
 248             obvious mistakes.
 249         */
 250         void validate(LaTeXFeatures &) const;
 251
 252         /// return all bibkeys from buffer and its childs
 253         void fillWithBibKeys(std::vector<std::pair<std::string, std::string> > & keys) const;
 254         ///
 255         void getLabelList(std::vector<std::string> &) const;
 256
 257         ///
 258         void changeLanguage(Language const * from, Language const * to);
 259
 260         ///
 261         void updateDocLang(Language const * nlang);
 262
 263         ///
 264         bool isMultiLingual();
 265
 266         /// Does this mean that this is buffer local?
 267         limited_stack<Undo> & undostack();
 268         limited_stack<Undo> const & undostack() const;
 269
 270         /// Does this mean that this is buffer local?
 271         limited_stack<Undo> & redostack();
 272         limited_stack<Undo> const & redostack() const;
 273
 274         ///
 275         BufferParams & params();
 276         BufferParams const & params() const;
 277
 278         /** The list of paragraphs.
 279             This is a linked list of paragraph, this list holds the
 280             whole contents of the document.
 281          */
 282         ParagraphList & paragraphs();
 283         ParagraphList const & paragraphs() const;
 284
 285         /// LyX version control object.
 286         LyXVC & lyxvc();
 287         LyXVC const & lyxvc() const;
 288
 289         /// Where to put temporary files.
 290         std::string const & temppath() const;
 291
 292         /** If we are writing a nice LaTeX file or not.
 293             While writing as LaTeX, tells whether we are
 294             doing a 'nice' LaTeX file */
 295         bool & niceFile();
 296         bool niceFile() const;
 297
 298         /// Used when typesetting to place errorboxes.
 299         TexRow & texrow();
 300         TexRow const & texrow() const;
 301
 302         class inset_iterator {
 303         public:
 304                 typedef std::input_iterator_tag iterator_category;
 305                 typedef InsetOld value_type;
 306                 typedef ptrdiff_t difference_type;
 307                 typedef InsetOld * pointer;
 308                 typedef InsetOld & reference;
 309                 typedef ParagraphList::iterator base_type;
 310
 311                 ///
 312                 inset_iterator();
 313                 ///
 314                 inset_iterator(base_type p, base_type e);
 315                 ///
 316                 inset_iterator(base_type p, lyx::pos_type pos, base_type e);
 317
 318                 /// prefix ++
 319                 inset_iterator & operator++();
 320                 /// postfix ++
 321                 inset_iterator operator++(int);
 322                 ///
 323                 reference operator*();
 324                 ///
 325                 pointer operator->();
 326
 327                 ///
 328                 ParagraphList::iterator getPar() const;
 329                 ///
 330                 lyx::pos_type getPos() const;
 331                 ///
 332                 friend
 333                 bool operator==(inset_iterator const & iter1,
 334                                 inset_iterator const & iter2);
 335         private:
 336                 ///
 337                 void setParagraph();
 338                 ///
 339                 ParagraphList::iterator pit;
 340                 ///
 341                 ParagraphList::iterator pend;
 342                 ///
 343                 InsetList::iterator it;
 344         };
 345
 346         /// return an iterator to all *top-level* insets in the buffer
 347         inset_iterator inset_iterator_begin();
 348
 349         /// return the end of all *top-level* insets in the buffer
 350         inset_iterator inset_iterator_end();
 351
 352         /// return a const iterator to all *top-level* insets in the buffer
 353         inset_iterator inset_const_iterator_begin() const;
 354
 355         /// return the const end of all *top-level* insets in the buffer
 356         inset_iterator inset_const_iterator_end() const;
 357
 358         ///
 359         ParIterator par_iterator_begin();
 360         ///
 361         ParConstIterator par_iterator_begin() const;
 362         ///
 363         ParIterator par_iterator_end();
 364         ///
 365         ParConstIterator par_iterator_end() const;
 366
 367         ///
 368         InsetOld * getInsetFromID(int id_arg) const;
 369
 370         /** \returns true only when the file is fully loaded.
 371          *  Used to prevent the premature generation of previews
 372          *  and by the citation inset.
 373          */
 374         bool fully_loaded() const;
 375
 376 private:
 377         /** Inserts a file into a document
 378             \param par if != 0 insert the file.
 379             \return \c false if method fails.
 380         */
 381         bool readFile(LyXLex &, std::string const & filename,
 382                       ParagraphList::iterator pit);
 383
 384         bool do_writeFile(std::ostream & ofs) const;
 385
 386         /// Use the Pimpl idiom to hide the internals.
 387         class Impl;
 388         /// The pointer never changes although *pimpl_'s contents may.
 389         boost::scoped_ptr<Impl> const pimpl_;
 390 };
 391
 392 bool operator==(Buffer::inset_iterator const & iter1,
 393                 Buffer::inset_iterator const & iter2);
 394
 395 bool operator!=(Buffer::inset_iterator const & iter1,
 396                 Buffer::inset_iterator const & iter2);
 397
 398 #endif