home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Linux / Divers / lyx-0.13.2.tar.gz / lyx-0.13.2.tar / lyx-0.13.2 / src / buffer.h < prev    next >
C/C++ Source or Header  |  1998-04-23  |  9KB  |  408 lines
  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. #ifndef _BUFFER_H_
  14. #define _BUFFER_H_
  15.  
  16. #ifdef __GNUG__
  17. #pragma interface
  18. #endif
  19.  
  20. #include "undo.h"
  21. #include "BufferView.h"
  22. #include "lyxvc.h"
  23. #include "bufferparams.h"
  24. #include "texrow.h"
  25. #include "lyxtext.h"
  26.  
  27. class LyXRC;
  28. class TeXErrors;
  29. class LaTeXFeatures;
  30.  
  31. struct DEPCLEAN {
  32.     bool clean;
  33.     LString master;
  34.     DEPCLEAN *next;
  35. };
  36.  
  37. /** The buffer object.
  38.   The is is the buffer object. It contains all the informations about
  39.   a document loaded into LyX. I am not sure if the class is complete or
  40.   minimal, probably not.
  41.   */
  42. class Buffer {
  43. public:
  44.     /**@name Constructors and destructor */
  45.     //@{
  46.     ///
  47.     Buffer(LString const & file, LyXRC * lyxrc = NULL, bool b= false);
  48.     
  49.     ///
  50.     ~Buffer();
  51.     //@}
  52.  
  53.     /**@name Methods */
  54.     //@{
  55.  
  56.     /** save the buffer's parameters as user default
  57.        This function saves a file user_lyxdir/templates/defaults.lyx 
  58.       which parameters are those of the current buffer. This file
  59.       is used as a default template when creating a new
  60.       file. Returns true on success.
  61.       */
  62.     bool saveParamsAsDefaults();
  63.  
  64.     /// should be changed to work for a list.
  65.     void resize()
  66.     {
  67.         if (users) {
  68.             users->resize();
  69.         } else if (text) {
  70.             delete text;
  71.             text = 0;
  72.         }
  73.     }
  74.  
  75.     /// Update window titles of all users
  76.     void updateTitles();
  77.  
  78.     /// Reset autosave timers for all users
  79.     void resetAutosaveTimers();
  80.  
  81.     /** Adds the BufferView to the users list.
  82.       Later this func will insert the BufferView into a real list,
  83.       not just setting a pointer.
  84.       */
  85.     void addUser(BufferView *u) { users = u; }
  86.  
  87.     /** Removes the BufferView from the users list.
  88.        Since we only can have one at the moment, we just reset it.
  89.       */
  90.     void delUser(BufferView *){ users = 0; }
  91.  
  92.     ///
  93.     void update(signed char f);
  94.  
  95.     ///
  96.     void redraw(void){
  97.               users->redraw(); 
  98.               users->fitCursor(); 
  99.               users->updateScrollbar(); }
  100.  
  101.         /// Open and lock an updatable inset
  102.         void open_new_inset(UpdatableInset*);
  103.  
  104.     ///
  105.     void loadAutoSaveFile();
  106.     
  107.     /** Reads a file. 
  108.         Returns false if it fails.
  109.         If par is given, the file is inserted. */
  110.     bool readFile(LyXLex &, LyXParagraph *par = 0);
  111.     
  112.     /** Reads a file without header.
  113.         Returns false, if file is not completely read.
  114.         If par is given, the file is inserted. */
  115.     bool readLyXformat2(LyXLex &,LyXParagraph *par = 0);
  116.  
  117.     /// Inserts a lyx file at cursor position. Returns false if it fails.
  118.     bool insertLyXFile(LString const & filename);
  119.  
  120.     /// Write file. Returns false if unsuccesful.
  121.     bool writeFile(LString const &, bool);
  122.     
  123.     ///
  124.     void writeFileAscii(LString const & , int);
  125.     
  126.     ///
  127.     void makeLaTeXFile(LString const & filename,
  128.                LString const & original_path,
  129.                bool nice, bool only_body = false);
  130.  
  131.     ///
  132.     int runLaTeX();
  133.  
  134.     ///
  135.     int runChktex();
  136.  
  137.     ///
  138.     void makeLinuxDocFile(LString const & filename, int column);
  139.  
  140.     /// returns the main language for the buffer (document)
  141.     LString GetLanguage() const {
  142.         return params.language;
  143.     }
  144.     
  145.     ///
  146.     bool isLyxClean() const { return lyx_clean; }
  147.     
  148.     ///
  149.     bool isDviClean() const { return dvi_clean; }
  150.     
  151.     ///
  152.     bool isBakClean() const { return bak_clean; }
  153.     
  154.     ///
  155.     bool isDepClean(LString const & name) const;
  156.     
  157.     ///
  158.     void markLyxClean() { 
  159.         if (!lyx_clean) {
  160.             lyx_clean = true; 
  161.             updateTitles();
  162.         }
  163.     }
  164.  
  165.     ///
  166.     void markDviClean() { dvi_clean = true; }
  167.     
  168.     ///
  169.     void markBakClean() { bak_clean = true; }
  170.     
  171.     ///
  172.     void markDepClean(LString const & name);
  173.     
  174.     ///
  175.     void markDviDirty() { dvi_clean = false; }
  176.     
  177.     ///
  178.     void markDirty() {
  179.         if (lyx_clean) {
  180.             lyx_clean = false;
  181.             updateTitles();
  182.         }
  183.         dvi_clean = false;
  184.         bak_clean = false;
  185.         DEPCLEAN* tmp = dep_clean;
  186.         while (tmp) {
  187.             tmp->clean = false;
  188.             tmp = tmp->next;
  189.         }
  190.     }
  191.  
  192.     ///
  193.     LString getFileName() const { return filename; }
  194.  
  195.     /// Change name of buffer. Updates "read-only" flag.
  196.     void setFileName(LString const & newfile);
  197.  
  198.     /// Is buffer read-only?
  199.     bool isReadonly() { return read_only; }
  200.  
  201.     /// Set buffer read-only flag
  202.     void setReadonly(bool flag = true) 
  203.     {
  204.         if (read_only != flag) {
  205.             read_only = flag; 
  206.             updateTitles();
  207.         }
  208.     }
  209.  
  210.     ///
  211.     bool isLinuxDoc();
  212.  
  213.     ///
  214.     void setPaperStuff();
  215.  
  216.     ///
  217.     void setOldPaperStuff();
  218.     
  219.     /** Validate a buffer for LaTeX.
  220.       This validates the buffer, and returns a struct for use by
  221.       makeLaTeX and others. Its main use is to figure out what commands
  222.       and packages need to be included in the LaTeX file. It (should)
  223.       also check that the needed constructs are there (i.e. that the \refs
  224.       points to coresponding \labels). It should behaps inset "error"
  225.       insets to help the user correct obvious mistakes.
  226.      */
  227.     void validate(LaTeXFeatures&); //the correct parameters to be
  228.                        //included later 
  229.  
  230.     /** Insert an inset into the buffer
  231.       Insert inset into buffer, placing it in a layout of lout,
  232.       if no_table make sure that it doesn't end up in a table. */
  233.     void insertInset(Inset *, LString const &lout=LString(), 
  234.              bool no_table = false);
  235.     ///
  236.     LString getIncludeonlyList(char delim=',');
  237.     ///
  238.     LString getReferenceList(char delim='|');
  239.     ///
  240.     bool gotoLabel(const LString&);
  241.  
  242.     /// removes all autodeletable insets
  243.     bool removeAutoInsets();
  244.  
  245.     /** This will clearly have to change later. Later we can have more
  246.       than one user per buffer. */
  247.     BufferView* getUser() const { return users; }
  248.  
  249.         //@}
  250.  
  251.     /// Does this mean that this is buffer local?
  252.         UndoStack undostack;
  253.     
  254.     /// Does this mean that this is buffer local? 
  255.         UndoStack redostack;
  256.     
  257.     ///
  258.     BufferParams params;
  259.     
  260.     /** is a list of paragraphs.
  261.      */
  262.     LyXParagraph *paragraph;
  263.     
  264.     /** This holds the mapping between buffer paragraphs and screen rows.
  265.         Should be moved to BufferView. (Asger)
  266.      */
  267.     LyXText *text;
  268.  
  269.     ///
  270.     UpdatableInset* the_locking_inset;
  271.  
  272.     /// RCS object
  273.     LyXVC lyxvc;
  274.  
  275.     /// where the temporaries go if we want them
  276.     LString tmppath;
  277.  
  278.     ///
  279.     LString filepath;
  280.  
  281.     /// While writing as LaTeX, tells whether we are doing a 'nice' LaTeX file
  282.     bool niceFile;
  283. protected:
  284.     ///
  285.         void InsetUnlock();
  286.     
  287.     ///
  288.         inline void InsetSleep();
  289.     
  290.     ///
  291.         inline void InsetWakeup();
  292.     
  293.     ///
  294.         bool inset_slept;
  295.     
  296.     ///
  297.         int  slx, sly;
  298. private:
  299.     ///
  300.     void insertErrors(TeXErrors &);
  301.     
  302.     ///
  303.         void linuxDocInitVars();
  304.         ///
  305.         void linuxDocHandleFootnote(LyXParagraph*&par);
  306.         ///
  307.         void linuxDocStartPar(FILE *file, LyXParagraph*&par);
  308.         ///
  309.     void linuxDocOnePar(FILE*, LyXParagraph*&);
  310.         ///
  311.         bool linuxDocConvertChar(char c, LString &sgml_string);
  312.     ///
  313.     void SimpleLinuxDocOnePar(FILE *file, LyXFont &font1, 
  314.                   LyXParagraph *par, bool &verb_on, 
  315.                   int &desc_on);
  316.  
  317.     ///
  318.     void LinuxDocError(LyXParagraph *par, int pos, LString const &message);
  319.  
  320.     ///
  321.     int LinuxDocTag(LString const & layout);
  322.  
  323.     /** Gets next LinuxDoc parameter.
  324.       
  325.       This is one of the methods I don't understand. What is its
  326.       purpose? Can somebody explain please?
  327.           Yes. It's used in multi-inset-Insets ;-). Terrible. Should be 
  328.           redesigned, if we switch to LaTeX-based LyX-file. But at 
  329.           moment, e.g. URL-Insets split up into three inset-parts. 
  330.           Firstly \url{. Then comes text [text1]. After this as second
  331.           inset {} and again "normal" text[text2]. And a closing (third)
  332.           } - Inset. GetNextParameter() now reads a text inbetween
  333.           to Insets and handles further insets, which are allowed to 
  334.           arise inside such a construction.
  335.      */
  336.     int GetNextParameter(LyXParagraph *par, int pos, LString &buffer, bool convert);
  337.  
  338.     /// LinuxDoc.
  339.     void push_tag(FILE *file, char const *tag, int& pos, char stack[5][3]);
  340.     
  341.     /// LinuxDoc.
  342.     void pop_tag(FILE *file, char const * tag, int& pos, char stack[5][3]);
  343.  
  344.     ///
  345.     void RoffAsciiTable(FILE *file, LyXParagraph *par);
  346.  
  347.     /// is save needed
  348.     bool lyx_clean;
  349.     
  350.     /// is autosave needed
  351.     bool bak_clean;
  352.     
  353.     /// do we need to run LaTeX
  354.     bool dvi_clean;
  355.  
  356.     /// is regenerating .tex necessary
  357.     DEPCLEAN *dep_clean;
  358.  
  359.     /// buffer is r/o
  360.     bool read_only;
  361.  
  362.     /// name of the file the buffer is associated with.
  363.     LString filename;
  364.  
  365.     /// Format number of buffer
  366.     float format;
  367.     
  368.     /** A list of views using this buffer.
  369.       Why not keep a list of the BufferViews that use this buffer?
  370.  
  371.       At least then we don't have to do a lot of magic like:
  372.       buffer->lyx_gui->bufferview->updateLayoutChoice. Just ask each
  373.       of the buffers in the list of users to do a updateLayoutChoice.
  374.       */
  375.     BufferView *users;
  376.  
  377.     ///
  378.     friend class BufferList;
  379.     ///
  380.         friend class BufferView;
  381.  
  382.     /// Used when typesetting to place errorboxes.
  383.     TexRow texrow;
  384. };
  385.  
  386.  
  387. inline  
  388. void Buffer::InsetSleep()
  389. {
  390.     if (the_locking_inset && !inset_slept) {
  391.     the_locking_inset->GetCursorPos(slx, sly);
  392.         the_locking_inset->InsetUnlock();
  393.     inset_slept = true;
  394.     }
  395. }
  396.  
  397.  
  398. inline  
  399. void Buffer::InsetWakeup()
  400. {
  401.     if (the_locking_inset && inset_slept) {
  402.     the_locking_inset->Edit(slx, sly);
  403.     inset_slept = false;
  404.     }    
  405. }
  406.  
  407. #endif
  408.