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 // Change Log:
  14 // ===========
  15 // 23/03/98   Heinrich Bauer (heinrich.bauer@t-mobil.de)
  16 // Spots marked "changed Heinrich Bauer, 23/03/98" modified due to the
  17 // following bug: dvi file export did not work after printing (or previewing)
  18 // and vice versa as long as the same file was concerned. This happened
  19 // every time the LyX-file was left unchanged between the two actions mentioned
  20 // above.
  21
  22 #ifndef BUFFER_H
  23 #define BUFFER_H
  24
  25 #ifdef __GNUG__
  26 #pragma interface
  27 #endif
  28
  29 #include "LString.h"
  30
  31 #include "BufferView.h"
  32 #include "lyxvc.h"
  33 #include "bufferparams.h"
  34 #include "texrow.h"
  35
  36
  37 class LyXRC;
  38 class TeXErrors;
  39 class LaTeXFeatures;
  40 class auto_mem_buffer;
  41
  42 ///
  43 struct DEPCLEAN {
  44         ///
  45         bool clean;
  46         ///
  47         string master;
  48         ///
  49         DEPCLEAN * next;
  50 };
  51
  52 /** The buffer object.
  53   The is is the buffer object. It contains all the informations about
  54   a document loaded into LyX. I am not sure if the class is complete or
  55   minimal, probably not.
  56   */
  57 class Buffer {
  58 public:
  59         ///
  60         explicit Buffer(string const & file, bool b = false);
  61
  62         ///
  63         ~Buffer();
  64
  65         /** save the buffer's parameters as user default
  66             This function saves a file #user_lyxdir/templates/defaults.lyx#
  67             which parameters are those of the current buffer. This file
  68             is used as a default template when creating a new
  69             file. Returns #true# on success.
  70         */
  71         bool saveParamsAsDefaults();
  72
  73         /** High-level interface to buffer functionality.
  74             This function parses a command string and executes it
  75         */
  76         bool Dispatch(string const & command);
  77
  78         /// Maybe we know the function already by number...
  79         bool Dispatch(int ac, string const & argument);
  80
  81         /// and have an xtl buffer to work with.
  82         bool Dispatch(int, auto_mem_buffer &);
  83
  84         /// should be changed to work for a list.
  85         void resize();
  86         ///
  87         void resizeInsets(BufferView *);
  88
  89         /// Update window titles of all users
  90         void updateTitles() const;
  91
  92         /// Reset autosave timers for all users
  93         void resetAutosaveTimers() const;
  94
  95         /** Adds the BufferView to the users list.
  96             Later this func will insert the #BufferView# into a real list,
  97             not just setting a pointer.
  98         */
  99         void addUser(BufferView * u) { users = u; }
 100
 101         /** Removes the #BufferView# from the users list.
 102             Since we only can have one at the moment, we just reset it.
 103         */
 104         void delUser(BufferView *) { users = 0; }
 105
 106         ///
 107         void redraw() {
 108                 users->redraw();
 109                 users->fitCursor(users->text);
 110                 //users->updateScrollbar();
 111         }
 112
 113         ///
 114         void loadAutoSaveFile();
 115
 116         /** Reads a file.
 117             @param par if != 0 insert the file.
 118             @return #false# if method fails.
 119         */
 120         bool readFile(LyXLex &, LyXParagraph * par = 0);
 121
 122         /** Reads a file without header.
 123             @param par if != 0 insert the file.
 124             @return false if file is not completely read.
 125         */
 126         bool readLyXformat2(LyXLex &, LyXParagraph * par = 0);
 127
 128         /// This parses a single LyXformat-Token.
 129         bool parseSingleLyXformat2Token(LyXLex &, LyXParagraph *& par,
 130                                         LyXParagraph *& return_par,
 131                                         string const & token, int & pos,
 132                                         char & depth, LyXFont &
 133 #ifndef NEW_INSETS
 134                                         ,LyXParagraph::footnote_flag &,
 135                                         LyXParagraph::footnote_kind &
 136 #endif
 137                 );
 138 private:
 139         /// Parse a single inset.
 140         void readInset(LyXLex &, LyXParagraph *& par, int & pos, LyXFont &);
 141 public:
 142         /** Save file
 143             Takes care of auto-save files and backup file if requested.
 144             Returns #true# if the save is successful, #false# otherwise.
 145         */
 146         bool save() const;
 147
 148         /// Write file. Returns #false# if unsuccesful.
 149         bool writeFile(string const &, bool) const;
 150
 151         ///
 152         void writeFileAscii(string const & , int);
 153         ///
 154         void writeFileAscii(std::ostream &, int);
 155         ///
 156         string const asciiParagraph(LyXParagraph const *,
 157                                     unsigned int linelen) const;
 158         ///
 159         void makeLaTeXFile(string const & filename,
 160                            string const & original_path,
 161                            bool nice, bool only_body = false);
 162         /** LaTeX all paragraphs from par to endpar.
 163             @param endpar if == 0 then to the end
 164         */
 165         void latexParagraphs(std::ostream & os, LyXParagraph * par,
 166                              LyXParagraph * endpar, TexRow & texrow) const;
 167
 168         ///
 169         int runChktex();
 170
 171         ///
 172         void makeLinuxDocFile(string const & filename,
 173                               bool nice, bool only_body = false);
 174         ///
 175         void makeDocBookFile(string const & filename,
 176                              bool nice, bool only_body = false);
 177
 178         /// returns the main language for the buffer (document)
 179         string const GetLanguage() const {
 180                 return params.language;
 181         }
 182
 183         ///
 184         bool isLyxClean() const { return lyx_clean; }
 185
 186         ///
 187         bool isBakClean() const { return bak_clean; }
 188
 189         ///
 190         bool isDepClean(string const & name) const;
 191
 192         ///
 193         void markLyxClean() const {
 194                 if (!lyx_clean) {
 195                         lyx_clean = true;
 196                         updateTitles();
 197                 }
 198                 // if the .lyx file has been saved, we don't need an
 199                 // autosave
 200                 bak_clean = true;
 201         }
 202
 203         ///
 204         void markBakClean() { bak_clean = true; }
 205
 206         ///
 207         void markDepClean(string const & name);
 208
 209         ///
 210         void setUnnamed(bool flag=true) { unnamed = flag; }
 211
 212         ///
 213         bool isUnnamed() { return unnamed; }
 214
 215         ///
 216         void markDirty() {
 217                 if (lyx_clean) {
 218                         lyx_clean = false;
 219                         updateTitles();
 220                 }
 221                 bak_clean = false;
 222                 DEPCLEAN * tmp = dep_clean;
 223                 while (tmp) {
 224                         tmp->clean = false;
 225                         tmp = tmp->next;
 226                 }
 227         }
 228
 229         ///
 230         string const & fileName() const { return filename; }
 231
 232         /** A transformed version of the file name, adequate for LaTeX
 233             The path is stripped if no_path is true (default)
 234         */
 235         string const getLatexName(bool no_path = true) const;
 236
 237         /// Change name of buffer. Updates "read-only" flag.
 238         void fileName(string const & newfile);
 239
 240         /// Name of the document's parent
 241         void setParentName(string const &);
 242
 243         /// Is buffer read-only?
 244         bool isReadonly() const { return read_only; }
 245
 246         /// Set buffer read-only flag
 247         void setReadonly(bool flag = true);
 248
 249         /// returns #true# if the buffer contains a LaTeX document
 250         bool isLatex() const;
 251         /// returns #true# if the buffer contains a LinuxDoc document
 252         bool isLinuxDoc() const;
 253         /// returns #true# if the buffer contains a DocBook document
 254         bool isDocBook() const;
 255         /** returns #true# if the buffer contains either a LinuxDoc
 256             or DocBook document */
 257         bool isSGML() const;
 258         /// returns #true# if the buffer contains a Wed document
 259         bool isLiterate() const;
 260
 261         ///
 262         void setPaperStuff();
 263
 264         /** Validate a buffer for LaTeX.
 265             This validates the buffer, and returns a struct for use by
 266             #makeLaTeX# and others. Its main use is to figure out what
 267             commands and packages need to be included in the LaTeX file.
 268             It (should) also check that the needed constructs are there
 269             (i.e. that the \refs points to coresponding \labels). It
 270             should perhaps inset "error" insets to help the user correct
 271             obvious mistakes.
 272         */
 273         void validate(LaTeXFeatures &) const;
 274
 275         ///
 276         string const getIncludeonlyList(char delim = ',');
 277         ///
 278         std::vector<std::pair<string,string> > const getBibkeyList();
 279         ///
 280         struct TocItem {
 281                 ///
 282                 LyXParagraph * par;
 283                 ///
 284                 int depth;
 285                 ///
 286                 string str;
 287         };
 288         ///
 289         enum TocType {
 290                 ///
 291                 TOC_TOC = 0,
 292                 ///
 293                 TOC_LOF,
 294                 ///
 295                 TOC_LOT,
 296                 ///
 297                 TOC_LOA
 298         };
 299         ///
 300         std::vector<std::vector<TocItem> > const getTocList();
 301         ///
 302         std::vector<string> const getLabelList();
 303
 304         /** This will clearly have to change later. Later we can have more
 305             than one user per buffer. */
 306         BufferView * getUser() const { return users; }
 307
 308         ///
 309         void ChangeLanguage(Language const * from, Language const * to);
 310         ///
 311         bool isMultiLingual();
 312
 313         /// Does this mean that this is buffer local?
 314         UndoStack undostack;
 315
 316         /// Does this mean that this is buffer local?
 317         UndoStack redostack;
 318
 319         ///
 320         BufferParams params;
 321
 322         /** is a list of paragraphs.
 323          */
 324         LyXParagraph * paragraph;
 325
 326         /// RCS object
 327         LyXVC lyxvc;
 328
 329         /// where the temporaries go if we want them
 330         string tmppath;
 331
 332         ///
 333         string filepath;
 334
 335         /** While writing as LaTeX, tells whether we are
 336             doing a 'nice' LaTeX file */
 337         bool niceFile;
 338
 339         /// Used when typesetting to place errorboxes.
 340         TexRow texrow;
 341 private:
 342 #ifndef NEW_INSETS
 343         ///
 344         void linuxDocHandleFootnote(std::ostream & os,
 345                                     LyXParagraph * & par, int depth);
 346 #endif
 347         ///
 348         void DocBookHandleCaption(std::ostream & os, string & inner_tag,
 349                                   int depth, int desc_on,
 350                                   LyXParagraph * & par);
 351 #ifndef NEW_INSETS
 352         ///
 353         void DocBookHandleFootnote(std::ostream & os,
 354                                    LyXParagraph * & par, int depth);
 355 #endif
 356         ///
 357         void sgmlOpenTag(std::ostream & os, int depth,
 358                          string const & latexname) const;
 359         ///
 360         void sgmlCloseTag(std::ostream & os, int depth,
 361                           string const & latexname) const;
 362         ///
 363         void LinuxDocError(LyXParagraph * par, int pos,
 364                            string const & message);
 365         ///
 366         void SimpleLinuxDocOnePar(std::ostream & os, LyXParagraph * par,
 367                                   int desc_on, int depth);
 368         ///
 369         void SimpleDocBookOnePar(std::ostream &, string & extra,
 370                                  LyXParagraph * par, int & desc_on,
 371                                  int depth);
 372
 373         /// LinuxDoc.
 374         void push_tag(std::ostream & os, string const & tag,
 375                       int & pos, char stack[5][3]);
 376
 377         /// LinuxDoc.
 378         void pop_tag(std::ostream & os, string const & tag,
 379                      int & pos, char stack[5][3]);
 380
 381         /// is save needed
 382         mutable bool lyx_clean;
 383
 384         /// is autosave needed
 385         mutable bool bak_clean;
 386
 387         /// is this a unnamed file (New...)
 388         bool unnamed;
 389
 390         /// is regenerating #.tex# necessary
 391         DEPCLEAN * dep_clean;
 392
 393         /// buffer is r/o
 394         bool read_only;
 395
 396         /// name of the file the buffer is associated with.
 397         string filename;
 398
 399         /// Format number of buffer
 400         float format;
 401
 402         /** A list of views using this buffer.
 403             Why not keep a list of the BufferViews that use this buffer?
 404
 405             At least then we don't have to do a lot of magic like:
 406             #buffer->lyx_gui->bufferview->updateLayoutChoice#. Just ask each
 407             of the buffers in the list of users to do a #updateLayoutChoice#.
 408         */
 409         BufferView * users;
 410
 411 public:
 412         ///
 413         class inset_iterator {
 414         public:
 415                 ///
 416                 inset_iterator() : par(0) /*, it(0)*/ {}
 417                 //
 418                 inset_iterator(LyXParagraph * paragraph) : par(paragraph) {
 419                         SetParagraph();
 420                 }
 421                 ///
 422                 inset_iterator(LyXParagraph * paragraph,
 423                                LyXParagraph::size_type pos);
 424                 ///
 425                 inset_iterator & operator++() {
 426                         if (par) {
 427                                 ++it;
 428                                 if (it == par->inset_iterator_end()) {
 429                                         par = par->next;
 430                                         SetParagraph();
 431                                 }
 432                         }
 433                         return *this;
 434                 }
 435                 ///
 436                 Inset * operator*() {return *it; }
 437                 ///
 438                 LyXParagraph * getPar() { return par; }
 439                 ///
 440                 LyXParagraph::size_type getPos() {return it.getPos(); }
 441                 ///
 442                 friend
 443                 bool operator==(inset_iterator const & iter1,
 444                                 inset_iterator const & iter2);
 445                 //
 446                 //friend
 447                 //bool operator!=(inset_iterator const & iter1,
 448                 //              inset_iterator const & iter2);
 449         private:
 450                 ///
 451                 void SetParagraph();
 452                 ///
 453                 LyXParagraph * par;
 454                 ///
 455                 LyXParagraph::inset_iterator it;
 456         };
 457
 458         ///
 459         inset_iterator inset_iterator_begin() {
 460                 return inset_iterator(paragraph);
 461         }
 462         ///
 463         inset_iterator inset_iterator_end() {
 464                 return inset_iterator();
 465         }
 466 };
 467
 468
 469 inline
 470 void Buffer::setParentName(string const & name)
 471 {
 472         params.parentname = name;
 473 }
 474
 475 ///
 476 inline
 477 bool operator==(Buffer::TocItem const & a, Buffer::TocItem const & b) {
 478         return a.par == b.par && a.str == b.str;
 479         // No need to compare depth.
 480 }
 481
 482
 483 ///
 484 inline
 485 bool operator!=(Buffer::TocItem const & a, Buffer::TocItem const & b) {
 486         return !(a == b);
 487         // No need to compare depth.
 488 }
 489
 490 ///
 491 inline
 492 bool operator==(Buffer::inset_iterator const & iter1,
 493                 Buffer::inset_iterator const & iter2) {
 494         return iter1.par == iter2.par
 495                 && (iter1.par == 0 || iter1.it == iter2.it);
 496 }
 497
 498 ///
 499 inline
 500 bool operator!=(Buffer::inset_iterator const & iter1,
 501                 Buffer::inset_iterator const & iter2) {
 502         return !(iter1 == iter2);
 503 }
 504 #endif
 505