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         void Dispatch(string const & command);
  84
  85         /// Maybe we know the function already by number...
  86         void 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         ///
 158         int runLaTeX();
 159
 160         ///
 161         int runLiterate();
 162
 163         ///
 164         int buildProgram();
 165
 166         ///
 167         int runChktex();
 168
 169         ///
 170         void makeLinuxDocFile(string const & filename, int column);
 171         ///
 172         void makeDocBookFile(string const & filename, int column);
 173
 174         /// returns the main language for the buffer (document)
 175         string GetLanguage() const {
 176                 return params.language;
 177         }
 178
 179         ///
 180         bool isLyxClean() const { return lyx_clean; }
 181
 182         /// changed Heinrich Bauer, 23/03/98
 183         bool isDviClean() const;
 184
 185         ///
 186         bool isNwClean() const { return nw_clean; }
 187
 188         ///
 189         bool isBakClean() const { return bak_clean; }
 190
 191         ///
 192         bool isDepClean(string const & name) const;
 193
 194         ///
 195         void markLyxClean() const {
 196                 if (!lyx_clean) {
 197                         lyx_clean = true;
 198                         updateTitles();
 199                 }
 200                 // if the .lyx file has been saved, we don't need an
 201                 // autosave
 202                 bak_clean = true;
 203         }
 204
 205         /// changed Heinrich Bauer, 23/03/98
 206         void markDviClean();
 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 markDviDirty();
 219
 220         ///
 221         void markNwDirty() { nw_clean = false; }
 222
 223         ///
 224         void markDirty() {
 225                 if (lyx_clean) {
 226                         lyx_clean = false;
 227                         updateTitles();
 228                 }
 229                 dvi_clean_tmpd = false;
 230                 dvi_clean_orgd = false;
 231                 nw_clean = false;
 232                 bak_clean = false;
 233                 DEPCLEAN * tmp = dep_clean;
 234                 while (tmp) {
 235                         tmp->clean = false;
 236                         tmp = tmp->next;
 237                 }
 238         }
 239
 240         ///
 241         string const & fileName() const { return filename; }
 242
 243         /** A transformed version of the file name, adequate for LaTeX
 244             The path is stripped if no_path is true (default) */
 245         string getLatexName(bool no_path = true) const;
 246
 247         /// Change name of buffer. Updates "read-only" flag.
 248         void fileName(string const & newfile);
 249
 250         /// Name of the document's parent
 251         void setParentName(string const &);
 252
 253         /// Is buffer read-only?
 254         bool isReadonly() const { return read_only; }
 255
 256         /// Set buffer read-only flag
 257         void setReadonly(bool flag = true);
 258
 259         /// returns true if the buffer contains a LaTeX document
 260         bool isLatex() const;
 261         /// returns true if the buffer contains a LinuxDoc document
 262         bool isLinuxDoc() const;
 263         /// returns true if the buffer contains a DocBook document
 264         bool isDocBook() const;
 265         /// returns true if the buffer contains either a LinuxDoc or DocBook document
 266         bool isSGML() const;
 267         /// returns true if the buffer contains a Wed document
 268         bool isLiterate() const;
 269
 270         ///
 271         void setPaperStuff();
 272
 273         /** Validate a buffer for LaTeX.
 274             This validates the buffer, and returns a struct for use by
 275             makeLaTeX and others. Its main use is to figure out what commands
 276             and packages need to be included in the LaTeX file. It (should)
 277             also check that the needed constructs are there (i.e. that the \refs
 278             points to coresponding \labels). It should perhaps inset "error"
 279             insets to help the user correct obvious mistakes.
 280         */
 281         void validate(LaTeXFeatures &) const;
 282
 283         ///
 284         string getIncludeonlyList(char delim = ',');
 285         ///
 286         string getReferenceList(char delim = '|');
 287         ///
 288         string getBibkeyList(char delim = '|');
 289
 290         /** This will clearly have to change later. Later we can have more
 291             than one user per buffer. */
 292         BufferView * getUser() const { return users; }
 293
 294         //@}
 295
 296         /// Does this mean that this is buffer local?
 297         UndoStack undostack;
 298
 299         /// Does this mean that this is buffer local?
 300         UndoStack redostack;
 301
 302         ///
 303         BufferParams params;
 304
 305         /** is a list of paragraphs.
 306          */
 307         LyXParagraph * paragraph;
 308
 309         /// RCS object
 310         LyXVC lyxvc;
 311
 312         /// where the temporaries go if we want them
 313         string tmppath;
 314
 315         ///
 316         string filepath;
 317
 318         /** While writing as LaTeX, tells whether we are
 319             doing a 'nice' LaTeX file */
 320         bool niceFile;
 321
 322         /// Used when typesetting to place errorboxes.
 323         TexRow texrow;
 324 private:
 325         ///
 326         void linuxDocHandleFootnote(std::ostream & os,
 327                                     LyXParagraph * & par, int const depth);
 328         ///
 329         void DocBookHandleCaption(std::ostream & os, string & inner_tag,
 330                                   int const depth, int desc_on,
 331                                   LyXParagraph * & par);
 332         ///
 333         void DocBookHandleFootnote(std::ostream & os,
 334                                    LyXParagraph * & par, int const depth);
 335         ///
 336         void sgmlOpenTag(std::ostream & os, int depth,
 337                          string const & latexname) const;
 338         ///
 339         void sgmlCloseTag(std::ostream & os, int depth,
 340                           string const & latexname) const;
 341         ///
 342         void LinuxDocError(LyXParagraph * par, int pos, char const * message);
 343         ///
 344         void SimpleLinuxDocOnePar(std::ostream & os, LyXParagraph * par,
 345                                   int desc_on, int const depth);
 346         ///
 347         void SimpleDocBookOnePar(std::ostream &, string & extra,
 348                                  LyXParagraph * par, int & desc_on,
 349                                  int const depth);
 350
 351         /// LinuxDoc.
 352         void push_tag(std::ostream & os, char const * tag,
 353                       int & pos, char stack[5][3]);
 354
 355         /// LinuxDoc.
 356         void pop_tag(std::ostream & os, char const * tag,
 357                      int & pos, char stack[5][3]);
 358
 359 #if 0
 360         ///
 361         void RoffAsciiTable(std::ostream &, LyXParagraph * par);
 362 #endif
 363
 364         /// is save needed
 365         mutable bool lyx_clean;
 366
 367         /// is autosave needed
 368         mutable bool bak_clean;
 369
 370         /** do we need to run LaTeX, changed 23/03/98, Heinrich Bauer
 371             We have to distinguish between TeX-runs executed in the original
 372             directory (in which the original LyX-file resides) and TeX-runs
 373             executed in a temporary directory. The first situation is valid
 374             for a dvi-export, the latter one for printing or previewing. */
 375         bool dvi_clean_orgd;
 376         bool dvi_clean_tmpd;
 377
 378         /// do we need to run weave/tangle
 379         bool nw_clean;
 380
 381         /// is regenerating .tex necessary
 382         DEPCLEAN * dep_clean;
 383
 384         /// buffer is r/o
 385         bool read_only;
 386
 387         /// name of the file the buffer is associated with.
 388         string filename;
 389
 390         /// Format number of buffer
 391         float format;
 392
 393         /** A list of views using this buffer.
 394             Why not keep a list of the BufferViews that use this buffer?
 395
 396             At least then we don't have to do a lot of magic like:
 397             buffer->lyx_gui->bufferview->updateLayoutChoice. Just ask each
 398             of the buffers in the list of users to do a updateLayoutChoice.
 399         */
 400         BufferView * users;
 401 };
 402
 403
 404 inline
 405 void Buffer::setParentName(string const & name)
 406 {
 407         params.parentname = name;
 408 }
 409
 410 #endif