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 only_body = false,
 152                            bool only_preamble = false);
 153         ///
 154         void makeLaTeXFile(std::ostream & os,
 155                            string const & original_path,
 156                            LatexRunParams const &,
 157                            bool only_body = false,
 158                            bool only_preamble = false);
 159         ///
 160         void simpleDocBookOnePar(std::ostream &,
 161                                  ParagraphList::iterator par, int & desc_on,
 162                                  Paragraph::depth_type depth) const;
 163         ///
 164         void simpleLinuxDocOnePar(std::ostream & os,
 165                ParagraphList::iterator par,
 166                                  Paragraph::depth_type depth) const;
 167         ///
 168         void makeLinuxDocFile(string const & filename,
 169                               bool nice, bool only_body = false);
 170         ///
 171         void makeDocBookFile(string const & filename,
 172                              bool nice, bool only_body = false);
 173         ///
 174         void sgmlError(ParagraphList::iterator par, int pos, string const & message) const;
 175
 176         /// returns the main language for the buffer (document)
 177         Language const * getLanguage() const;
 178         /// get l10n translated to the buffers language
 179         string const B_(string const & l10n) const;
 180
 181         ///
 182         int runChktex();
 183         /// return true if the main lyx file does not need saving
 184         bool isClean() const;
 185         ///
 186         bool isBakClean() const;
 187         ///
 188         bool isDepClean(string const & name) const;
 189
 190         /// mark the main lyx file as not needing saving
 191         void markClean() const;
 192
 193         ///
 194         void markBakClean();
 195
 196         ///
 197         void markDepClean(string const & name);
 198
 199         ///
 200         void setUnnamed(bool flag = true);
 201
 202         ///
 203         bool isUnnamed();
 204
 205         /// Mark this buffer as dirty.
 206         void markDirty();
 207
 208         /// Returns the buffer's filename. It is always an absolute path.
 209         string const & fileName() const;
 210
 211         /// Returns the the path where the buffer lives.
 212         /// It is always an absolute path.
 213         string const & filePath() const;
 214
 215         /** A transformed version of the file name, adequate for LaTeX.
 216             \param no_path optional if \c true then the path is stripped.
 217         */
 218         string const getLatexName(bool no_path = true) const;
 219
 220         /// Get the name and type of the log.
 221         std::pair<LogType, string> const getLogName() const;
 222
 223         /// Change name of buffer. Updates "read-only" flag.
 224         void setFileName(string const & newfile);
 225
 226         /// Name of the document's parent
 227         void setParentName(string const &);
 228
 229         /// Is buffer read-only?
 230         bool isReadonly() const;
 231
 232         /// Set buffer read-only flag
 233         void setReadonly(bool flag = true);
 234
 235         /// returns \c true if the buffer contains a LaTeX document
 236         bool isLatex() const;
 237         /// returns \c true if the buffer contains a LinuxDoc document
 238         bool isLinuxDoc() const;
 239         /// returns \c true if the buffer contains a DocBook document
 240         bool isDocBook() const;
 241         /** returns \c true if the buffer contains either a LinuxDoc
 242             or DocBook document */
 243         bool isSGML() const;
 244         /// returns \c true if the buffer contains a Wed document
 245         bool isLiterate() const;
 246
 247         /** Validate a buffer for LaTeX.
 248             This validates the buffer, and returns a struct for use by
 249             #makeLaTeX# and others. Its main use is to figure out what
 250             commands and packages need to be included in the LaTeX file.
 251             It (should) also check that the needed constructs are there
 252             (i.e. that the \refs points to coresponding \labels). It
 253             should perhaps inset "error" insets to help the user correct
 254             obvious mistakes.
 255         */
 256         void validate(LaTeXFeatures &) const;
 257
 258         /// return all bibkeys from buffer and its childs
 259         void fillWithBibKeys(std::vector<std::pair<string, string> > & keys) const;
 260         ///
 261         std::vector<string> const getLabelList() const;
 262
 263         /** This will clearly have to change later. Later we can have more
 264             than one user per buffer. */
 265         BufferView * getUser() const;
 266
 267         ///
 268         void changeLanguage(Language const * from, Language const * to);
 269
 270         ///
 271         void updateDocLang(Language const * nlang);
 272
 273         ///
 274         bool isMultiLingual();
 275
 276         /// Does this mean that this is buffer local?
 277         limited_stack<boost::shared_ptr<Undo> > undostack;
 278
 279         /// Does this mean that this is buffer local?
 280         limited_stack<boost::shared_ptr<Undo> > redostack;
 281
 282         ///
 283         BufferParams params;
 284
 285         /** The list of paragraphs.
 286             This is a linked list of paragraph, this list holds the
 287             whole contents of the document.
 288          */
 289         ParagraphList paragraphs;
 290
 291         /// LyX version control object.
 292         LyXVC lyxvc;
 293
 294         /// Where to put temporary files.
 295         string tmppath;
 296
 297         /** If we are writing a nice LaTeX file or not.
 298             While writing as LaTeX, tells whether we are
 299             doing a 'nice' LaTeX file */
 300         bool niceFile;
 301
 302         /// Used when typesetting to place errorboxes.
 303         TexRow texrow;
 304
 305         /// the author list for the document
 306         AuthorList & authors();
 307
 308 private:
 309         typedef std::map<string, bool> DepClean;
 310
 311         /// need to regenerate .tex ?
 312         DepClean dep_clean_;
 313
 314         /// is save needed
 315         mutable bool lyx_clean;
 316
 317         /// is autosave needed
 318         mutable bool bak_clean;
 319
 320         /// is this a unnamed file (New...)
 321         bool unnamed;
 322
 323         /// buffer is r/o
 324         bool read_only;
 325
 326         /// name of the file the buffer is associated with.
 327         string filename_;
 328
 329         /// The path to the document file.
 330         string filepath_;
 331
 332         /// Format number of buffer
 333         int file_format;
 334         /** A list of views using this buffer.
 335             Why not keep a list of the BufferViews that use this buffer?
 336
 337             At least then we don't have to do a lot of magic like:
 338             #buffer->lyx_gui->bufferview->updateLayoutChoice#. Just ask each
 339             of the buffers in the list of users to do a #updateLayoutChoice#.
 340         */
 341         BufferView * users;
 342         ///
 343         boost::scoped_ptr<Messages> messages_;
 344 public:
 345         ///
 346         class inset_iterator {
 347         public:
 348                 typedef std::input_iterator_tag iterator_category;
 349                 typedef Inset value_type;
 350                 typedef ptrdiff_t difference_type;
 351                 typedef Inset * pointer;
 352                 typedef Inset & reference;
 353                 typedef ParagraphList::iterator base_type;
 354
 355                 ///
 356                 inset_iterator();
 357                 ///
 358                 inset_iterator(base_type p, base_type e);
 359                 ///
 360                 inset_iterator(base_type p, lyx::pos_type pos, base_type e);
 361
 362                 /// prefix ++
 363                 inset_iterator & operator++();
 364                 /// postfix ++
 365                 inset_iterator operator++(int);
 366                 ///
 367                 reference operator*();
 368                 ///
 369                 pointer operator->();
 370
 371                 ///
 372                 ParagraphList::iterator getPar() const;
 373                 ///
 374                 lyx::pos_type getPos() const;
 375                 ///
 376                 friend
 377                 bool operator==(inset_iterator const & iter1,
 378                                 inset_iterator const & iter2);
 379         private:
 380                 ///
 381                 void setParagraph();
 382                 ///
 383                 ParagraphList::iterator pit;
 384                 ///
 385                 ParagraphList::iterator pend;
 386                 ///
 387                 InsetList::iterator it;
 388         };
 389
 390         ///
 391         inset_iterator inset_iterator_begin() {
 392                 return inset_iterator(paragraphs.begin(), paragraphs.end());
 393         }
 394
 395         ///
 396         inset_iterator inset_iterator_end() {
 397                 return inset_iterator();
 398         }
 399
 400         ///
 401         inset_iterator inset_const_iterator_begin() const {
 402                 return inset_iterator(const_cast<ParagraphList&>(paragraphs).begin(), const_cast<ParagraphList&>(paragraphs).end());
 403         }
 404
 405         ///
 406         inset_iterator inset_const_iterator_end() const {
 407                 return inset_iterator();
 408         }
 409
 410         ///
 411         ParIterator par_iterator_begin();
 412         ///
 413         ParConstIterator par_iterator_begin() const;
 414         ///
 415         ParIterator par_iterator_end();
 416         ///
 417         ParConstIterator par_iterator_end() const;
 418
 419         ///
 420         Inset * getInsetFromID(int id_arg) const;
 421 };
 422
 423 bool operator==(Buffer::inset_iterator const & iter1,
 424                 Buffer::inset_iterator const & iter2);
 425
 426 bool operator!=(Buffer::inset_iterator const & iter1,
 427                 Buffer::inset_iterator const & iter2);
 428 #endif