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