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