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 #include "lyx_gui_misc.h"
  37
  38
  39 class LyXRC;
  40 class TeXErrors;
  41 class LaTeXFeatures;
  42
  43 extern void updateAllVisibleBufferRelatedPopups();
  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         /* The path is stripped if no_path is true (default) */
 240         string getLatexName(bool no_path = true) const {
 241                 return ChangeExtension(MakeLatexName(filename),
 242                                        ".tex", no_path);
 243         }
 244
 245         /// Change name of buffer. Updates "read-only" flag.
 246         void fileName(string const & newfile);
 247
 248         /// Name of the document's parent
 249         void setParentName(string const &);
 250
 251         /// Is buffer read-only?
 252         bool isReadonly() const { return read_only; }
 253
 254         /// Set buffer read-only flag
 255         void setReadonly(bool flag = true) {
 256                 if (read_only != flag) {
 257                         read_only = flag;
 258                         updateTitles();
 259                         updateAllVisibleBufferRelatedPopups();
 260                 }
 261                 if (read_only) {
 262                         WarnReadonly(filename);
 263                 }
 264         }
 265
 266         /// returns true if the buffer contains a LaTeX document
 267         bool isLatex() const;
 268         /// returns true if the buffer contains a LinuxDoc document
 269         bool isLinuxDoc() const;
 270         /// returns true if the buffer contains a DocBook document
 271         bool isDocBook() const;
 272         /// returns true if the buffer contains either a LinuxDoc 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 #if 0
 281         ///
 282         void setOldPaperStuff();
 283 #endif
 284
 285         /** Validate a buffer for LaTeX.
 286             This validates the buffer, and returns a struct for use by
 287             makeLaTeX and others. Its main use is to figure out what commands
 288             and packages need to be included in the LaTeX file. It (should)
 289             also check that the needed constructs are there (i.e. that the \refs
 290             points to coresponding \labels). It should perhaps inset "error"
 291             insets to help the user correct obvious mistakes.
 292         */
 293         void validate(LaTeXFeatures &); //the correct parameters to be
 294         //included later
 295
 296         /** Insert an inset into the buffer
 297             Insert inset into buffer, placing it in a layout of lout,
 298             if no_table make sure that it doesn't end up in a table. */
 299         //void insertInset(Inset *, string const & lout = string(),
 300         //               bool no_table = false);
 301
 302         ///
 303         //void setCursorFromRow (int);
 304
 305         ///
 306         string getIncludeonlyList(char delim = ',');
 307         ///
 308         string getReferenceList(char delim = '|');
 309         ///
 310         string getBibkeyList(char delim = '|');
 311         ///
 312         //bool gotoLabel(string const &);
 313
 314         /// removes all autodeletable insets
 315         //bool removeAutoInsets();
 316
 317         /** This will clearly have to change later. Later we can have more
 318             than one user per buffer. */
 319         BufferView * getUser() const { return users; }
 320
 321         //@}
 322
 323         /// Does this mean that this is buffer local?
 324         UndoStack undostack;
 325
 326         /// Does this mean that this is buffer local?
 327         UndoStack redostack;
 328
 329         ///
 330         BufferParams params;
 331
 332         /** is a list of paragraphs.
 333          */
 334         LyXParagraph * paragraph;
 335
 336         /// RCS object
 337         LyXVC lyxvc;
 338
 339         /// where the temporaries go if we want them
 340         string tmppath;
 341
 342         ///
 343         string filepath;
 344
 345         /** While writing as LaTeX, tells whether we are
 346             doing a 'nice' LaTeX file */
 347         bool niceFile;
 348
 349         /// Used when typesetting to place errorboxes.
 350         TexRow texrow;
 351 private:
 352         ///
 353         //void insertErrors(TeXErrors &);
 354
 355         ///
 356         void linuxDocHandleFootnote(ostream & os,
 357                                     LyXParagraph * & par, int const depth);
 358         ///
 359         void DocBookHandleCaption(ostream & os, string & inner_tag,
 360                                   int const depth, int desc_on,
 361                                   LyXParagraph * & par);
 362         ///
 363         void DocBookHandleFootnote(ostream & os,
 364                                    LyXParagraph * & par, int const depth);
 365         ///
 366         void sgmlOpenTag(ostream & os, int depth,
 367                          string const & latexname) const;
 368         ///
 369         void sgmlCloseTag(ostream & os, int depth,
 370                           string const & latexname) const;
 371         ///
 372         void LinuxDocError(LyXParagraph * par, int pos, char const * message);
 373         ///
 374         void SimpleLinuxDocOnePar(ostream & os, LyXParagraph * par,
 375                                   int desc_on, int const depth);
 376         ///
 377         void SimpleDocBookOnePar(string & file, string & extra,
 378                                  LyXParagraph * par, int & desc_on,
 379                                  int const depth);
 380
 381         /// LinuxDoc.
 382         void push_tag(ostream & os, char const * tag,
 383                       int & pos, char stack[5][3]);
 384
 385         /// LinuxDoc.
 386         void pop_tag(ostream & os, char const * tag,
 387                      int & pos, char stack[5][3]);
 388
 389         ///
 390         void RoffAsciiTable(ostream &, LyXParagraph * par);
 391
 392         /// is save needed
 393         bool lyx_clean;
 394
 395         /// is autosave needed
 396         bool bak_clean;
 397
 398         /** do we need to run LaTeX, changed 23/03/98, Heinrich Bauer
 399             We have to distinguish between TeX-runs executed in the original
 400             directory (in which the original LyX-file resides) and TeX-runs
 401             executed in a temporary directory. The first situation is valid
 402             for a dvi-export, the latter one for printing or previewing. */
 403         bool dvi_clean_orgd;
 404         bool dvi_clean_tmpd;
 405
 406         /// do we need to run weave/tangle
 407         bool nw_clean;
 408
 409         /// is regenerating .tex necessary
 410         DEPCLEAN * dep_clean;
 411
 412         /// buffer is r/o
 413         bool read_only;
 414
 415         /// name of the file the buffer is associated with.
 416         string filename;
 417
 418         /// Format number of buffer
 419         float format;
 420
 421         /** A list of views using this buffer.
 422             Why not keep a list of the BufferViews that use this buffer?
 423
 424             At least then we don't have to do a lot of magic like:
 425             buffer->lyx_gui->bufferview->updateLayoutChoice. Just ask each
 426             of the buffers in the list of users to do a updateLayoutChoice.
 427         */
 428         BufferView * users;
 429
 430 };
 431
 432
 433 inline
 434 void Buffer::setParentName(string const & name)
 435 {
 436         params.parentname = name;
 437 }
 438
 439 #endif