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();
 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         ///
 155         void makeLaTeXFile(string const & filename,
 156                            string const & original_path,
 157                            bool nice, bool only_body = false);
 158         /** LaTeX all paragraphs from par to endpar.
 159             @param endpar if == 0 then to the end
 160         */
 161         void latexParagraphs(std::ostream & os, LyXParagraph * par,
 162                              LyXParagraph * endpar, TexRow & texrow) const;
 163
 164         ///
 165         int runLiterate();
 166
 167         ///
 168         int buildProgram();
 169
 170         ///
 171         int runChktex();
 172
 173         ///
 174         void makeLinuxDocFile(string const & filename,
 175                               bool nice, bool only_body = false);
 176         ///
 177         void makeDocBookFile(string const & filename,
 178                              bool nice, bool only_body = false);
 179
 180         /// returns the main language for the buffer (document)
 181         string const GetLanguage() const {
 182                 return params.language;
 183         }
 184
 185         ///
 186         bool isLyxClean() const { return lyx_clean; }
 187
 188         ///
 189         bool isNwClean() const { return nw_clean; }
 190
 191         ///
 192         bool isBakClean() const { return bak_clean; }
 193
 194         ///
 195         bool isDepClean(string const & name) const;
 196
 197         ///
 198         void markLyxClean() const {
 199                 if (!lyx_clean) {
 200                         lyx_clean = true;
 201                         updateTitles();
 202                 }
 203                 // if the .lyx file has been saved, we don't need an
 204                 // autosave
 205                 bak_clean = true;
 206         }
 207
 208         ///
 209         void markNwClean() { nw_clean = true; }
 210
 211         ///
 212         void markBakClean() { bak_clean = true; }
 213
 214         ///
 215         void markDepClean(string const & name);
 216
 217         ///
 218         void markNwDirty() { nw_clean = false; }
 219
 220         ///
 221         void setUnnamed(bool flag=true) { unnamed = flag; }
 222
 223         ///
 224         bool isUnnamed() { return unnamed; }
 225
 226         ///
 227         void markDirty() {
 228                 if (lyx_clean) {
 229                         lyx_clean = false;
 230                         updateTitles();
 231                 }
 232                 nw_clean = false;
 233                 bak_clean = false;
 234                 DEPCLEAN * tmp = dep_clean;
 235                 while (tmp) {
 236                         tmp->clean = false;
 237                         tmp = tmp->next;
 238                 }
 239         }
 240
 241         ///
 242         string const & fileName() const { return filename; }
 243
 244         /** A transformed version of the file name, adequate for LaTeX
 245             The path is stripped if no_path is true (default)
 246         */
 247         string const getLatexName(bool no_path = true) const;
 248
 249         /// Change name of buffer. Updates "read-only" flag.
 250         void fileName(string const & newfile);
 251
 252         /// Name of the document's parent
 253         void setParentName(string const &);
 254
 255         /// Is buffer read-only?
 256         bool isReadonly() const { return read_only; }
 257
 258         /// Set buffer read-only flag
 259         void setReadonly(bool flag = true);
 260
 261         /// returns #true# if the buffer contains a LaTeX document
 262         bool isLatex() const;
 263         /// returns #true# if the buffer contains a LinuxDoc document
 264         bool isLinuxDoc() const;
 265         /// returns #true# if the buffer contains a DocBook document
 266         bool isDocBook() const;
 267         /** returns #true# if the buffer contains either a LinuxDoc
 268             or DocBook document */
 269         bool isSGML() const;
 270         /// returns #true# if the buffer contains a Wed document
 271         bool isLiterate() const;
 272
 273         ///
 274         void setPaperStuff();
 275
 276         /** Validate a buffer for LaTeX.
 277             This validates the buffer, and returns a struct for use by
 278             #makeLaTeX# and others. Its main use is to figure out what
 279             commands and packages need to be included in the LaTeX file.
 280             It (should) also check that the needed constructs are there
 281             (i.e. that the \refs points to coresponding \labels). It
 282             should perhaps inset "error" insets to help the user correct
 283             obvious mistakes.
 284         */
 285         void validate(LaTeXFeatures &) const;
 286
 287         ///
 288         string const getIncludeonlyList(char delim = ',');
 289         ///
 290         std::vector<std::pair<string,string> > const getBibkeyList();
 291         ///
 292         struct TocItem {
 293                 ///
 294                 LyXParagraph * par;
 295                 ///
 296                 int depth;
 297                 ///
 298                 string str;
 299         };
 300         ///
 301         enum TocType {
 302                 ///
 303                 TOC_TOC = 0,
 304                 ///
 305                 TOC_LOF,
 306                 ///
 307                 TOC_LOT,
 308                 ///
 309                 TOC_LOA
 310         };
 311         ///
 312         std::vector<std::vector<TocItem> > const getTocList();
 313         ///
 314         std::vector<string> const getLabelList();
 315
 316         /** This will clearly have to change later. Later we can have more
 317             than one user per buffer. */
 318         BufferView * getUser() const { return users; }
 319
 320         ///
 321         void ChangeLanguage(Language const * from, Language const * to);
 322         ///
 323         bool isMultiLingual();
 324
 325         /// Does this mean that this is buffer local?
 326         UndoStack undostack;
 327
 328         /// Does this mean that this is buffer local?
 329         UndoStack redostack;
 330
 331         ///
 332         BufferParams params;
 333
 334         /** is a list of paragraphs.
 335          */
 336         LyXParagraph * paragraph;
 337
 338         /// RCS object
 339         LyXVC lyxvc;
 340
 341         /// where the temporaries go if we want them
 342         string tmppath;
 343
 344         ///
 345         string filepath;
 346
 347         /** While writing as LaTeX, tells whether we are
 348             doing a 'nice' LaTeX file */
 349         bool niceFile;
 350
 351         /// Used when typesetting to place errorboxes.
 352         TexRow texrow;
 353 private:
 354 #ifndef NEW_INSETS
 355         ///
 356         void linuxDocHandleFootnote(std::ostream & os,
 357                                     LyXParagraph * & par, int const depth);
 358 #endif
 359         ///
 360         void DocBookHandleCaption(std::ostream & os, string & inner_tag,
 361                                   int const depth, int desc_on,
 362                                   LyXParagraph * & par);
 363 #ifndef NEW_INSETS
 364         ///
 365         void DocBookHandleFootnote(std::ostream & os,
 366                                    LyXParagraph * & par, int const depth);
 367 #endif
 368         ///
 369         void sgmlOpenTag(std::ostream & os, int depth,
 370                          string const & latexname) const;
 371         ///
 372         void sgmlCloseTag(std::ostream & os, int depth,
 373                           string const & latexname) const;
 374         ///
 375         void LinuxDocError(LyXParagraph * par, int pos,
 376                            string const & message);
 377         ///
 378         void SimpleLinuxDocOnePar(std::ostream & os, LyXParagraph * par,
 379                                   int desc_on, int const depth);
 380         ///
 381         void SimpleDocBookOnePar(std::ostream &, string & extra,
 382                                  LyXParagraph * par, int & desc_on,
 383                                  int const depth);
 384
 385         /// LinuxDoc.
 386         void push_tag(std::ostream & os, string const & tag,
 387                       int & pos, char stack[5][3]);
 388
 389         /// LinuxDoc.
 390         void pop_tag(std::ostream & os, string const & tag,
 391                      int & pos, char stack[5][3]);
 392
 393         /// is save needed
 394         mutable bool lyx_clean;
 395
 396         /// is autosave needed
 397         mutable bool bak_clean;
 398
 399         /// do we need to run weave/tangle
 400         bool nw_clean;
 401
 402         /// is this a unnamed file (New...)
 403         bool unnamed;
 404
 405         /// is regenerating #.tex# necessary
 406         DEPCLEAN * dep_clean;
 407
 408         /// buffer is r/o
 409         bool read_only;
 410
 411         /// name of the file the buffer is associated with.
 412         string filename;
 413
 414         /// Format number of buffer
 415         float format;
 416
 417         /** A list of views using this buffer.
 418             Why not keep a list of the BufferViews that use this buffer?
 419
 420             At least then we don't have to do a lot of magic like:
 421             #buffer->lyx_gui->bufferview->updateLayoutChoice#. Just ask each
 422             of the buffers in the list of users to do a #updateLayoutChoice#.
 423         */
 424         BufferView * users;
 425
 426 public:
 427         ///
 428         class inset_iterator {
 429         public:
 430                 ///
 431                 inset_iterator() : par(0) /*, it(0)*/ {}
 432                 //
 433                 inset_iterator(LyXParagraph * paragraph) : par(paragraph) {
 434                         SetParagraph();
 435                 }
 436                 ///
 437                 inset_iterator(LyXParagraph * paragraph,
 438                                LyXParagraph::size_type pos);
 439                 ///
 440                 inset_iterator & operator++() {
 441                         if (par) {
 442                                 ++it;
 443                                 if (it == par->inset_iterator_end()) {
 444                                         par = par->next;
 445                                         SetParagraph();
 446                                 }
 447                         }
 448                         return *this;
 449                 }
 450                 ///
 451                 Inset * operator*() {return *it; }
 452                 ///
 453                 LyXParagraph * getPar() { return par; }
 454                 ///
 455                 LyXParagraph::size_type getPos() {return it.getPos(); }
 456                 ///
 457                 friend
 458                 bool operator==(inset_iterator const & iter1,
 459                                 inset_iterator const & iter2);
 460                 //
 461                 //friend
 462                 //bool operator!=(inset_iterator const & iter1,
 463                 //              inset_iterator const & iter2);
 464         private:
 465                 ///
 466                 void SetParagraph();
 467                 ///
 468                 LyXParagraph * par;
 469                 ///
 470                 LyXParagraph::inset_iterator it;
 471         };
 472
 473         ///
 474         inset_iterator inset_iterator_begin() {
 475                 return inset_iterator(paragraph);
 476         }
 477         ///
 478         inset_iterator inset_iterator_end() {
 479                 return inset_iterator();
 480         }
 481 };
 482
 483
 484 inline
 485 void Buffer::setParentName(string const & name)
 486 {
 487         params.parentname = name;
 488 }
 489
 490 ///
 491 inline
 492 bool operator==(Buffer::TocItem const & a, Buffer::TocItem const & b) {
 493         return a.par == b.par && a.str == b.str;
 494         // No need to compare depth.
 495 }
 496
 497
 498 ///
 499 inline
 500 bool operator!=(Buffer::TocItem const & a, Buffer::TocItem const & b) {
 501         return !(a == b);
 502         // No need to compare depth.
 503 }
 504
 505 ///
 506 inline
 507 bool operator==(Buffer::inset_iterator const & iter1,
 508                 Buffer::inset_iterator const & iter2) {
 509         return iter1.par == iter2.par
 510                 && (iter1.par == 0 || iter1.it == iter2.it);
 511 }
 512
 513 ///
 514 inline
 515 bool operator!=(Buffer::inset_iterator const & iter1,
 516                 Buffer::inset_iterator const & iter2) {
 517         return !(iter1 == iter2);
 518 }
 519 #endif
 520