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