src/buffer.h

   1 // -*- C++ -*-
   2 /* This file is part of
   3  * ======================================================
   4  *
   5  *           LyX, The Document Processor
   6  *           Copyright 1995 Matthias Ettrich
   7  *
   8  *           This file is Copyleft 1996
   9  *           Lars Gullik Bjønnes
  10  *
  11  * ====================================================== */
  12
  13 #ifndef BUFFER_H
  14 #define BUFFER_H
  15
  16 #include "LString.h"
  17 #include "undo.h"
  18 #include "support/limited_stack.h"
  19
  20 #include "lyxvc.h"
  21 #include "bufferparams.h"
  22 #include "texrow.h"
  23 #include "ParagraphList.h"
  24 #include "paragraph.h"
  25 #include "author.h"
  26
  27 #include <boost/shared_ptr.hpp>
  28
  29 class BufferView;
  30 class LyXRC;
  31 class TeXErrors;
  32 class LaTeXFeatures;
  33 class Language;
  34 class ParIterator;
  35 class ParConstIterator;
  36
  37
  38 /** The buffer object.
  39   This is the buffer object. It contains all the informations about
  40   a document loaded into LyX. I am not sure if the class is complete or
  41   minimal, probably not.
  42   \author Lars Gullik Bjønnes
  43   */
  44 class Buffer {
  45 public:
  46         /// What type of log will \c getLogName() return?
  47         enum LogType {
  48                 latexlog, ///< LaTeX log
  49                 buildlog  ///< Literate build log
  50         };
  51
  52         /** Constructor
  53             \param file
  54             \param b  optional \c false by default
  55         */
  56         explicit Buffer(string const & file, bool b = false);
  57
  58         /// Destructor
  59         ~Buffer();
  60
  61         /** High-level interface to buffer functionality.
  62             This function parses a command string and executes it
  63         */
  64         bool dispatch(string const & command, bool * result = 0);
  65
  66         /// Maybe we know the function already by number...
  67         bool dispatch(int ac, string const & argument, bool * result = 0);
  68
  69         ///
  70         void resizeInsets(BufferView *);
  71
  72         /// Update window titles of all users.
  73         void updateTitles() const;
  74
  75         /// Reset autosave timers for all users.
  76         void resetAutosaveTimers() const;
  77
  78         /** Adds the BufferView to the users list.
  79             Later this func will insert the \c BufferView into a real list,
  80             not just setting a pointer.
  81         */
  82         void addUser(BufferView * u);
  83
  84         /** Removes the #BufferView# from the users list.
  85             Since we only can have one at the moment, we just reset it.
  86         */
  87         void delUser(BufferView *);
  88
  89         ///
  90         void redraw();
  91
  92         /// Load the autosaved file.
  93         void loadAutoSaveFile();
  94
  95         /** Reads a file.
  96             \param par if != 0 insert the file.
  97             \return \c false if method fails.
  98         */
  99         bool readFile(LyXLex &, string const &, Paragraph * par = 0);
 100
 101         /** Reads a file without header.
 102             \param par if != 0 insert the file.
 103             \return \c false if file is not completely read.
 104         */
 105         bool readLyXformat2(LyXLex &, Paragraph * par = 0);
 106
 107         /// This parses a single LyXformat-Token.
 108         bool parseSingleLyXformat2Token(LyXLex &, Paragraph *& par,
 109                                         Paragraph *& return_par,
 110                                         string const & token, int & pos,
 111                                         Paragraph::depth_type & depth,
 112                                         LyXFont &);
 113         ///
 114         void insertStringAsLines(Paragraph *&, lyx::pos_type &,
 115                                  LyXFont const &, string const &);
 116         ///
 117         Paragraph * getParFromID(int id) const;
 118 private:
 119         /// Parse a single inset.
 120         void readInset(LyXLex &, Paragraph *& par, int & pos, LyXFont &);
 121 public:
 122         /** Save file.
 123             Takes care of auto-save files and backup file if requested.
 124             Returns \c true if the save is successful, \c false otherwise.
 125         */
 126         bool save() const;
 127
 128         /// Write file. Returns \c false if unsuccesful.
 129         bool writeFile(string const &) const;
 130
 131         ///
 132         void writeFileAscii(string const & , int);
 133         ///
 134         void writeFileAscii(std::ostream &, int);
 135         ///
 136         string const asciiParagraph(Paragraph const &, unsigned int linelen,
 137                                     bool noparbreak = false) const;
 138         /// Just a wrapper for the method below, first creating the ofstream.
 139         void makeLaTeXFile(string const & filename,
 140                            string const & original_path,
 141                            bool nice,
 142                            bool only_body = false,
 143                            bool only_preamble = false);
 144         ///
 145         void makeLaTeXFile(std::ostream & os,
 146                            string const & original_path,
 147                            bool nice,
 148                            bool only_body = false,
 149                            bool only_preamble = false);
 150         /** LaTeX all paragraphs from par to endpar.
 151             \param \a endpar if == 0 then to the end
 152         */
 153         void latexParagraphs(std::ostream & os,
 154                              ParagraphList::iterator par,
 155                              ParagraphList::iterator endpar,
 156                              TexRow & texrow, bool moving_arg = false) const;
 157         ///
 158         void simpleDocBookOnePar(std::ostream &,
 159                                  Paragraph * par, int & desc_on,
 160                                  Paragraph::depth_type depth) const ;
 161         ///
 162         void simpleLinuxDocOnePar(std::ostream & os, Paragraph * par,
 163                                   Paragraph::depth_type depth);
 164         ///
 165         void makeLinuxDocFile(string const & filename,
 166                               bool nice, bool only_body = false);
 167         ///
 168         void makeDocBookFile(string const & filename,
 169                              bool nice, bool only_body = false);
 170         ///
 171         void sgmlError(Paragraph * par, int pos, string const & message) const;
 172
 173         /// returns the main language for the buffer (document)
 174         Language const * getLanguage() const;
 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(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(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         string const & fileName() const;
 204
 205         /// Returns the the path where the buffer lives.
 206         /// It is always an absolute path.
 207         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         string const getLatexName(bool no_path = true) const;
 213
 214         /// Get the name and type of the log.
 215         std::pair<LogType, string> const getLogName() const;
 216
 217         /// Change name of buffer. Updates "read-only" flag.
 218         void setFileName(string const & newfile);
 219
 220         /// Name of the document's parent
 221         void setParentName(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<string, string> > & keys) const;
 254         ///
 255         std::vector<string> const getLabelList() const;
 256
 257         /** This will clearly have to change later. Later we can have more
 258             than one user per buffer. */
 259         BufferView * getUser() const;
 260
 261         ///
 262         void changeLanguage(Language const * from, Language const * to);
 263         ///
 264         bool isMultiLingual();
 265
 266         /// Does this mean that this is buffer local?
 267         limited_stack<boost::shared_ptr<Undo> > undostack;
 268
 269         /// Does this mean that this is buffer local?
 270         limited_stack<boost::shared_ptr<Undo> > redostack;
 271
 272         ///
 273         BufferParams params;
 274
 275         /** The list of paragraphs.
 276             This is a linked list of paragraph, this list holds the
 277             whole contents of the document.
 278          */
 279         ParagraphList paragraphs;
 280
 281         /// LyX version control object.
 282         LyXVC lyxvc;
 283
 284         /// Where to put temporary files.
 285         string tmppath;
 286
 287         /** If we are writing a nice LaTeX file or not.
 288             While writing as LaTeX, tells whether we are
 289             doing a 'nice' LaTeX file */
 290         bool niceFile;
 291
 292         /// Used when typesetting to place errorboxes.
 293         TexRow texrow;
 294
 295         /// the author list for the document
 296         AuthorList & authors();
 297
 298 private:
 299         typedef std::map<string, bool> DepClean;
 300
 301         /// need to regenerate .tex ?
 302         DepClean dep_clean_;
 303
 304         /// the author list
 305         AuthorList authorlist;
 306
 307         /// is save needed
 308         mutable bool lyx_clean;
 309
 310         /// is autosave needed
 311         mutable bool bak_clean;
 312
 313         /// is this a unnamed file (New...)
 314         bool unnamed;
 315
 316         /// buffer is r/o
 317         bool read_only;
 318
 319         /// name of the file the buffer is associated with.
 320         string filename_;
 321
 322         /// The path to the document file.
 323         string filepath_;
 324
 325         /// Format number of buffer
 326         int file_format;
 327         /** A list of views using this buffer.
 328             Why not keep a list of the BufferViews that use this buffer?
 329
 330             At least then we don't have to do a lot of magic like:
 331             #buffer->lyx_gui->bufferview->updateLayoutChoice#. Just ask each
 332             of the buffers in the list of users to do a #updateLayoutChoice#.
 333         */
 334         BufferView * users;
 335 public:
 336         ///
 337         class inset_iterator {
 338         public:
 339                 typedef std::input_iterator_tag iterator_category;
 340                 typedef Inset value_type;
 341                 typedef ptrdiff_t difference_type;
 342                 typedef Inset * pointer;
 343                 typedef Inset & reference;
 344                 typedef ParagraphList::iterator base_type;
 345
 346                 ///
 347                 inset_iterator();
 348                 ///
 349                 inset_iterator(base_type p, base_type e);
 350                 ///
 351                 inset_iterator(base_type p, lyx::pos_type pos, base_type e);
 352
 353                 /// prefix ++
 354                 inset_iterator & operator++();
 355                 /// postfix ++
 356                 inset_iterator operator++(int);
 357                 ///
 358                 reference operator*();
 359                 ///
 360                 pointer operator->();
 361
 362                 ///
 363                 Paragraph * getPar();
 364                 ///
 365                 lyx::pos_type getPos() const;
 366                 ///
 367                 friend
 368                 bool operator==(inset_iterator const & iter1,
 369                                 inset_iterator const & iter2);
 370         private:
 371                 ///
 372                 void setParagraph();
 373                 ///
 374                 ParagraphList::iterator pit;
 375                 ///
 376                 ParagraphList::iterator pend;
 377                 ///
 378                 InsetList::iterator it;
 379         };
 380
 381         ///
 382         inset_iterator inset_iterator_begin() {
 383                 return inset_iterator(paragraphs.begin(), paragraphs.end());
 384         }
 385
 386         ///
 387         inset_iterator inset_iterator_end() {
 388                 return inset_iterator();
 389         }
 390
 391         ///
 392         inset_iterator inset_const_iterator_begin() const {
 393                 return inset_iterator(paragraphs.begin(), paragraphs.end());
 394         }
 395
 396         ///
 397         inset_iterator inset_const_iterator_end() const {
 398                 return inset_iterator();
 399         }
 400
 401         ///
 402         ParIterator par_iterator_begin();
 403         ///
 404         ParConstIterator par_iterator_begin() const;
 405         ///
 406         ParIterator par_iterator_end();
 407         ///
 408         ParConstIterator par_iterator_end() const;
 409
 410         ///
 411         Inset * getInsetFromID(int id_arg) const;
 412 };
 413
 414 bool operator==(Buffer::inset_iterator const & iter1,
 415                 Buffer::inset_iterator const & iter2);
 416
 417 bool operator!=(Buffer::inset_iterator const & iter1,
 418                 Buffer::inset_iterator const & iter2);
 419 #endif