src/buffer.h

   1 // -*- C++ -*-
   2 /* This file is part of
   3  * ======================================================
   4 *
   5 *           LyX, The Document Processor
   6 *           Copyright (C) 1995 Matthias Ettrich
   7 *
   8 *           This file is Copyleft (C) 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 "undo.h"
  30 #include "BufferView.h"
  31 #include "lyxvc.h"
  32 #include "bufferparams.h"
  33 #include "texrow.h"
  34 #include "lyxtext.h"
  35 #include "support/filetools.h"
  36
  37
  38 class LyXRC;
  39 class TeXErrors;
  40 class LaTeXFeatures;
  41
  42 extern void updateAllVisibleBufferRelatedPopups();
  43 extern void WarnReadonly();
  44
  45 ///
  46 struct DEPCLEAN {
  47         ///
  48         bool clean;
  49         ///
  50         string master;
  51         ///
  52         DEPCLEAN *next;
  53 };
  54
  55 /** The buffer object.
  56   The is is the buffer object. It contains all the informations about
  57   a document loaded into LyX. I am not sure if the class is complete or
  58   minimal, probably not.
  59   */
  60 class Buffer {
  61 public:
  62         /**@name Constructors and destructor */
  63         //@{
  64         ///
  65         Buffer(string const & file, LyXRC * lyxrc = 0, bool b = false);
  66
  67         ///
  68         ~Buffer();
  69         //@}
  70
  71         /**@name Methods */
  72         //@{
  73
  74         /** save the buffer's parameters as user default
  75             This function saves a file user_lyxdir/templates/defaults.lyx
  76             which parameters are those of the current buffer. This file
  77             is used as a default template when creating a new
  78             file. Returns true on success.
  79         */
  80         bool saveParamsAsDefaults();
  81
  82         /** high-level interface to buffer functionality
  83             This function parses a command string and executes it
  84         */
  85         void Dispatch(const string & command);
  86
  87         /// Maybe we know the function already by number...
  88         void Dispatch(int ac, const string & argument);
  89
  90         /// should be changed to work for a list.
  91         void resize()
  92                 {
  93                         if (users) {
  94                                 users->resize();
  95                         }
  96                 }
  97
  98         /// Update window titles of all users
  99         void updateTitles();
 100
 101         /// Reset autosave timers for all users
 102         void resetAutosaveTimers();
 103
 104         /** Adds the BufferView to the users list.
 105             Later this func will insert the BufferView into a real list,
 106             not just setting a pointer.
 107         */
 108         void addUser(BufferView * u) { users = u; }
 109
 110         /** Removes the BufferView from the users list.
 111             Since we only can have one at the moment, we just reset it.
 112         */
 113         void delUser(BufferView *){ users = 0; }
 114
 115         ///
 116         void redraw() {
 117                 users->redraw();
 118                 users->fitCursor();
 119                 users->updateScrollbar();
 120         }
 121
 122         /// Open and lock an updatable inset
 123         void open_new_inset(UpdatableInset *);
 124
 125         ///
 126         void loadAutoSaveFile();
 127
 128         /** Reads a file.
 129             Returns false if it fails.
 130             If par is given, the file is inserted. */
 131         bool readFile(LyXLex &, LyXParagraph * par = 0);
 132
 133         /** Reads a file without header.
 134             Returns false, if file is not completely read.
 135             If par is given, the file is inserted. */
 136         bool readLyXformat2(LyXLex &, LyXParagraph * par = 0);
 137
 138         /// Inserts a lyx file at cursor position. Returns false if it fails.
 139         bool insertLyXFile(string const & filename);
 140
 141         /// Write file. Returns false if unsuccesful.
 142         bool writeFile(string const &, bool);
 143
 144         ///
 145         void writeFileAscii(string const & , int);
 146
 147         ///
 148         void makeLaTeXFile(string const & filename,
 149                            string const & original_path,
 150                            bool nice, bool only_body = false);
 151
 152         ///
 153         int runLaTeX();
 154
 155         ///
 156         int runLiterate();
 157
 158         ///
 159         int buildProgram();
 160
 161         ///
 162         int runChktex();
 163
 164         ///
 165         void makeLinuxDocFile(string const & filename, int column);
 166         ///
 167         void makeDocBookFile(string const & filename, int column);
 168
 169         /// returns the main language for the buffer (document)
 170         string GetLanguage() const {
 171                 return params.language;
 172         }
 173
 174         ///
 175         bool isLyxClean() const { return lyx_clean; }
 176
 177         /// changed Heinrich Bauer, 23/03/98
 178         bool isDviClean();
 179
 180         ///
 181         bool isNwClean() const { return nw_clean; }
 182
 183         ///
 184         bool isBakClean() const { return bak_clean; }
 185
 186         ///
 187         bool isDepClean(string const & name) const;
 188
 189         ///
 190         void markLyxClean() {
 191                 if (!lyx_clean) {
 192                         lyx_clean = true;
 193                         updateTitles();
 194                 }
 195                 // if the .lyx file has been saved, we don't need an
 196                 // autosave
 197                 bak_clean = true;
 198         }
 199
 200         /// changed Heinrich Bauer, 23/03/98
 201         void markDviClean();
 202
 203         ///
 204         void markNwClean() { nw_clean = true; }
 205
 206         ///
 207         void markBakClean() { bak_clean = true; }
 208
 209         ///
 210         void markDepClean(string const & name);
 211
 212         ///
 213         void markDviDirty();
 214
 215         ///
 216         void markNwDirty() { nw_clean = false; }
 217
 218         ///
 219         void markDirty() {
 220                 if (lyx_clean) {
 221                         lyx_clean = false;
 222                         updateTitles();
 223                 }
 224                 dvi_clean_tmpd = false;
 225                 dvi_clean_orgd = false;
 226                 nw_clean = false;
 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         string getLatexName() const {
 240                 return ChangeExtension(MakeLatexName(filename), ".tex", true);
 241         }
 242
 243         /// Change name of buffer. Updates "read-only" flag.
 244         void fileName(string const & newfile);
 245
 246         /// Name of the document's parent
 247         void setParentName(string const &);
 248
 249         /// Is buffer read-only?
 250         bool isReadonly() { return read_only; }
 251
 252         /// Set buffer read-only flag
 253         void setReadonly(bool flag = true)
 254                 {
 255                         if (read_only != flag) {
 256                                 read_only = flag;
 257                                 updateTitles();
 258                                 updateAllVisibleBufferRelatedPopups();
 259                         }
 260                         if (read_only) {
 261                                 WarnReadonly();
 262                         }
 263                 }
 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 or DocBook document
 272         bool isSGML() const;
 273         /// returns true if the buffer contains a Wed document
 274         bool isLiterate() const;
 275
 276         ///
 277         void setPaperStuff();
 278
 279 #if 0
 280         ///
 281         void setOldPaperStuff();
 282 #endif
 283
 284         /** Validate a buffer for LaTeX.
 285             This validates the buffer, and returns a struct for use by
 286             makeLaTeX and others. Its main use is to figure out what commands
 287             and packages need to be included in the LaTeX file. It (should)
 288             also check that the needed constructs are there (i.e. that the \refs
 289             points to coresponding \labels). It should perhaps inset "error"
 290             insets to help the user correct obvious mistakes.
 291         */
 292         void validate(LaTeXFeatures &); //the correct parameters to be
 293         //included later
 294
 295         /** Insert an inset into the buffer
 296             Insert inset into buffer, placing it in a layout of lout,
 297             if no_table make sure that it doesn't end up in a table. */
 298         void insertInset(Inset *, string const & lout = string(),
 299                          bool no_table = false);
 300
 301         ///
 302         void setCursorFromRow (int);
 303
 304         ///
 305         string getIncludeonlyList(char delim = ',');
 306         ///
 307         string getReferenceList(char delim = '|');
 308         ///
 309         string getBibkeyList(char delim = '|');
 310         ///
 311         bool gotoLabel(string const &);
 312
 313         /// removes all autodeletable insets
 314         bool removeAutoInsets();
 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
 322         /// Does this mean that this is buffer local?
 323         UndoStack undostack;
 324
 325         /// Does this mean that this is buffer local?
 326         UndoStack redostack;
 327
 328         ///
 329         BufferParams params;
 330
 331         /** is a list of paragraphs.
 332          */
 333         LyXParagraph * paragraph;
 334
 335         /// per view not per buffer?
 336         UpdatableInset * the_locking_inset;
 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         ///
 352         void InsetUnlock();
 353
 354         ///
 355         inline void InsetSleep();
 356
 357         ///
 358         inline void InsetWakeup();
 359
 360         ///
 361         bool inset_slept;
 362
 363         ///
 364         int  slx;
 365         ///
 366         int sly;
 367 private:
 368         ///
 369         void insertErrors(TeXErrors &);
 370
 371         ///
 372         void linuxDocHandleFootnote(ostream & os,
 373                                     LyXParagraph * & par, int const depth);
 374         ///
 375         void DocBookHandleCaption(ostream & os, string & inner_tag,
 376                                   int const depth, int desc_on,
 377                                   LyXParagraph * & par);
 378         ///
 379         void DocBookHandleFootnote(ostream & os,
 380                                    LyXParagraph * & par, int const depth);
 381         ///
 382         void sgmlOpenTag(ostream & os, int depth,
 383                          string const & latexname) const;
 384         ///
 385         void sgmlCloseTag(ostream & os, int depth,
 386                           string const & latexname) const;
 387         ///
 388         void LinuxDocError(LyXParagraph * par, int pos, char const * message);
 389         ///
 390         void SimpleLinuxDocOnePar(ostream & os, LyXParagraph * par,
 391                                   int desc_on, int const depth);
 392         ///
 393         void SimpleDocBookOnePar(string & file, string & extra,
 394                                  LyXParagraph * par, int & desc_on,
 395                                  int const depth);
 396
 397         /// LinuxDoc.
 398         void push_tag(ostream & os, char const * tag,
 399                       int & pos, char stack[5][3]);
 400
 401         /// LinuxDoc.
 402         void pop_tag(ostream & os, char const * tag,
 403                      int & pos, char stack[5][3]);
 404
 405         ///
 406         void RoffAsciiTable(ostream &, LyXParagraph * par);
 407
 408         /// is save needed
 409         bool lyx_clean;
 410
 411         /// is autosave needed
 412         bool bak_clean;
 413
 414         /** do we need to run LaTeX, changed 23/03/98, Heinrich Bauer
 415             We have to distinguish between TeX-runs executed in the original
 416             directory (in which the original LyX-file resides) and TeX-runs
 417             executed in a temporary directory. The first situation is valid
 418             for a dvi-export, the latter one for printing or previewing. */
 419         bool dvi_clean_orgd;
 420         bool dvi_clean_tmpd;
 421
 422         /// do we need to run weave/tangle
 423         bool nw_clean;
 424
 425         /// is regenerating .tex necessary
 426         DEPCLEAN * dep_clean;
 427
 428         /// buffer is r/o
 429         bool read_only;
 430
 431         /// name of the file the buffer is associated with.
 432         string filename;
 433
 434         /// Format number of buffer
 435         float format;
 436
 437         /** A list of views using this buffer.
 438             Why not keep a list of the BufferViews that use this buffer?
 439
 440             At least then we don't have to do a lot of magic like:
 441             buffer->lyx_gui->bufferview->updateLayoutChoice. Just ask each
 442             of the buffers in the list of users to do a updateLayoutChoice.
 443         */
 444         BufferView * users;
 445
 446         /// Used when typesetting to place errorboxes.
 447         TexRow texrow;
 448 };
 449
 450
 451 inline
 452 void Buffer::InsetSleep()
 453 {
 454         if (the_locking_inset && !inset_slept) {
 455                 the_locking_inset->GetCursorPos(slx, sly);
 456                 the_locking_inset->InsetUnlock();
 457                 inset_slept = true;
 458         }
 459 }
 460
 461
 462 inline
 463 void Buffer::InsetWakeup()
 464 {
 465         if (the_locking_inset && inset_slept) {
 466                 the_locking_inset->Edit(slx, sly);
 467                 inset_slept = false;
 468         }
 469 }
 470
 471
 472 inline
 473 void Buffer::setParentName(string const & name)
 474 {
 475         params.parentname = name;
 476 }
 477
 478 #endif