]> git.lyx.org Git - features.git/blob - src/buffer.h
several small and larger changes, read the Changelog
[features.git] / 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 #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                 if (users) {
93                         users->resize();
94                 }
95         }
96
97         /// Update window titles of all users
98         void updateTitles();
99
100         /// Reset autosave timers for all users
101         void resetAutosaveTimers();
102
103         /** Adds the BufferView to the users list.
104             Later this func will insert the BufferView into a real list,
105             not just setting a pointer.
106         */
107         void addUser(BufferView * u) { users = u; }
108
109         /** Removes the BufferView from the users list.
110             Since we only can have one at the moment, we just reset it.
111         */
112         void delUser(BufferView *) { users = 0; }
113         
114         ///
115         void redraw() {
116                 users->redraw(); 
117                 users->fitCursor(); 
118                 users->updateScrollbar();
119         }
120
121         ///
122         void loadAutoSaveFile();
123         
124         /** Reads a file. 
125             Returns false if it fails.
126             If par is given, the file is inserted. */
127         bool readFile(LyXLex &, LyXParagraph * par = 0);
128         
129         /** Reads a file without header.
130             Returns false, if file is not completely read.
131             If par is given, the file is inserted. */
132         bool readLyXformat2(LyXLex &, LyXParagraph * par = 0);
133
134         /// Write file. Returns false if unsuccesful.
135         bool writeFile(string const &, bool);
136         
137         ///
138         void writeFileAscii(string const & , int);
139         
140         ///
141         void makeLaTeXFile(string const & filename,
142                            string const & original_path,
143                            bool nice, bool only_body = false);
144
145         ///
146         int runLaTeX();
147
148         ///
149         int runLiterate();
150
151         ///
152         int buildProgram();
153
154         ///
155         int runChktex();
156
157         ///
158         void makeLinuxDocFile(string const & filename, int column);
159         ///
160         void makeDocBookFile(string const & filename, int column);
161
162         /// returns the main language for the buffer (document)
163         string GetLanguage() const {
164                 return params.language;
165         }
166         
167         ///
168         bool isLyxClean() const { return lyx_clean; }
169         
170         /// changed Heinrich Bauer, 23/03/98
171         bool isDviClean() const;
172         
173         ///
174         bool isNwClean() const { return nw_clean; }
175        
176         ///
177         bool isBakClean() const { return bak_clean; }
178         
179         ///
180         bool isDepClean(string const & name) const;
181         
182         ///
183         void markLyxClean() { 
184                 if (!lyx_clean) {
185                         lyx_clean = true; 
186                         updateTitles();
187                 }
188                 // if the .lyx file has been saved, we don't need an
189                 // autosave 
190                 bak_clean = true;
191         }
192
193         /// changed Heinrich Bauer, 23/03/98
194         void markDviClean();
195         
196         ///
197         void markNwClean() { nw_clean = true; }
198        
199         ///
200         void markBakClean() { bak_clean = true; }
201         
202         ///
203         void markDepClean(string const & name);
204         
205         ///
206         void markDviDirty();
207         
208         ///
209         void markNwDirty() { nw_clean = false; }
210        
211         ///
212         void markDirty() {
213                 if (lyx_clean) {
214                         lyx_clean = false;
215                         updateTitles();
216                 }
217                 dvi_clean_tmpd = false;
218                 dvi_clean_orgd = false;
219                 nw_clean = false;
220                 bak_clean = false;
221                 DEPCLEAN * tmp = dep_clean;
222                 while (tmp) {
223                         tmp->clean = false;
224                         tmp = tmp->next;
225                 }
226         }
227
228         ///
229         string const & fileName() const { return filename; }
230
231         /** A transformed version of the file name, adequate for LaTeX  
232             The path is stripped if no_path is true (default) */
233         string getLatexName(bool no_path = true) const {
234                 return ChangeExtension(MakeLatexName(filename), 
235                                        ".tex", no_path); 
236         }
237
238         /// Change name of buffer. Updates "read-only" flag.
239         void fileName(string const & newfile);
240
241         /// Name of the document's parent
242         void setParentName(string const &);
243
244         /// Is buffer read-only?
245         bool isReadonly() const { return read_only; }
246
247         /// Set buffer read-only flag
248         void setReadonly(bool flag = true) {
249                 if (read_only != flag) {
250                         read_only = flag; 
251                         updateTitles();
252                         updateAllVisibleBufferRelatedPopups();
253                 }
254                 if (read_only) {
255                         WarnReadonly(filename);
256                 }
257         }
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(ostream & os,
327                                     LyXParagraph * & par, int const depth);
328         ///
329         void DocBookHandleCaption(ostream & os, string & inner_tag,
330                                   int const depth, int desc_on,
331                                   LyXParagraph * & par);
332         ///
333         void DocBookHandleFootnote(ostream & os,
334                                    LyXParagraph * & par, int const depth);
335         ///
336         void sgmlOpenTag(ostream & os, int depth,
337                          string const & latexname) const;
338         ///
339         void sgmlCloseTag(ostream & os, int depth,
340                           string const & latexname) const;
341         ///
342         void LinuxDocError(LyXParagraph * par, int pos, char const * message);
343         ///
344         void SimpleLinuxDocOnePar(ostream & os, LyXParagraph * par,
345                                   int desc_on, int const depth);
346         ///
347         void SimpleDocBookOnePar(string & file, string & extra,
348                                  LyXParagraph * par, int & desc_on,
349                                  int const depth);
350
351         /// LinuxDoc.
352         void push_tag(ostream & os, char const * tag,
353                       int & pos, char stack[5][3]);
354         
355         /// LinuxDoc.
356         void pop_tag(ostream & os, char const * tag,
357                      int & pos, char stack[5][3]);
358         
359         ///
360         void RoffAsciiTable(ostream &, LyXParagraph * par);
361
362         /// is save needed
363         bool lyx_clean;
364         
365         /// is autosave needed
366         bool bak_clean;
367         
368         /** do we need to run LaTeX, changed 23/03/98, Heinrich Bauer
369             We have to distinguish between TeX-runs executed in the original
370             directory (in which the original LyX-file resides) and TeX-runs
371             executed in a temporary directory. The first situation is valid
372             for a dvi-export, the latter one for printing or previewing. */
373         bool dvi_clean_orgd;
374         bool dvi_clean_tmpd;
375
376         /// do we need to run weave/tangle
377         bool nw_clean;
378
379         /// is regenerating .tex necessary
380         DEPCLEAN * dep_clean;
381
382         /// buffer is r/o
383         bool read_only;
384
385         /// name of the file the buffer is associated with.
386         string filename;
387
388         /// Format number of buffer
389         float format;
390         
391         /** A list of views using this buffer.
392             Why not keep a list of the BufferViews that use this buffer?
393
394             At least then we don't have to do a lot of magic like:
395             buffer->lyx_gui->bufferview->updateLayoutChoice. Just ask each
396             of the buffers in the list of users to do a updateLayoutChoice.
397         */
398         BufferView * users;
399 };
400
401
402 inline  
403 void Buffer::setParentName(string const & name)
404 {
405         params.parentname = name;    
406 }
407
408 #endif