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