X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fbuffer.h;h=880cff61b3d91dbbeb4706985e469e5747b8782e;hb=98c966c64594611e469313314abd1e59524adb4a;hp=efcfea6fd714de79ad1bdf74d56021ec6b68ec7d;hpb=27de1486ca34aaad446adb798d71a77d6f6304da;p=lyx.git diff --git a/src/buffer.h b/src/buffer.h index efcfea6fd7..880cff61b3 100644 --- a/src/buffer.h +++ b/src/buffer.h @@ -1,468 +1,604 @@ // -*- C++ -*- /* This file is part of -* ====================================================== -* -* LyX, The Document Processor -* Copyright (C) 1995 Matthias Ettrich -* -* This file is Copyleft (C) 1996 -* Lars Gullik Bjønnes -* -*======================================================*/ - -// Change Log: -// =========== -// 23/03/98 Heinrich Bauer (heinrich.bauer@t-mobil.de) -// Spots marked "changed Heinrich Bauer, 23/03/98" modified due to the -// following bug: dvi file export did not work after printing (or previewing) -// and vice versa as long as the same file was concerned. This happened -// every time the LyX-file was left unchanged between the two actions mentioned -// above. - -#ifndef _BUFFER_H_ -#define _BUFFER_H_ + * ====================================================== + * + * LyX, The Document Processor + * Copyright 1995 Matthias Ettrich + * + * This file is Copyleft 1996 + * Lars Gullik Bjønnes + * + * ====================================================== */ + +#ifndef BUFFER_H +#define BUFFER_H #ifdef __GNUG__ #pragma interface #endif +#include "LString.h" #include "undo.h" -#include "BufferView.h" +#include "undostack.h" #include "lyxvc.h" #include "bufferparams.h" #include "texrow.h" -#include "lyxtext.h" +#include "paragraph.h" +class BufferView; class LyXRC; class TeXErrors; class LaTeXFeatures; +class Language; +class ParIterator; -extern void updateAllVisibleBufferRelatedPopups(); -extern void WarnReadonly(); +// When lyx 1.3.x starts we should enable this +// btw. we should also test this with 1.2 so that we +// do not get any surprises. (Lgb) +//#define NO_COMPABILITY 1 /// struct DEPCLEAN { /// bool clean; /// - LString master; + string master; /// - DEPCLEAN *next; + DEPCLEAN * next; }; /** The buffer object. - The is is the buffer object. It contains all the informations about + This is the buffer object. It contains all the informations about a document loaded into LyX. I am not sure if the class is complete or minimal, probably not. + \author Lars Gullik Bjønnes */ class Buffer { public: - /**@name Constructors and destructor */ - //@{ - /// - Buffer(LString const & file, LyXRC * lyxrc = NULL, bool b= false); - - /// + /// What type of log will \c getLogName() return? + enum LogType { + latexlog, ///< LaTeX log + buildlog ///< Literate build log + }; + + /** Constructor + \param file + \param b optional \c false by default + */ + explicit Buffer(string const & file, bool b = false); + + /// Destructor ~Buffer(); - //@} - - /**@name Methods */ - //@{ - - /** save the buffer's parameters as user default - This function saves a file user_lyxdir/templates/defaults.lyx - which parameters are those of the current buffer. This file - is used as a default template when creating a new - file. Returns true on success. - */ - bool saveParamsAsDefaults(); - - /// should be changed to work for a list. - void resize() - { - if (users) { - users->resize(); - } else if (text) { - delete text; - text = 0; - } - } - /// Update window titles of all users - void updateTitles(); + /** High-level interface to buffer functionality. + This function parses a command string and executes it + */ + bool dispatch(string const & command); - /// Reset autosave timers for all users - void resetAutosaveTimers(); + /// Maybe we know the function already by number... + bool dispatch(int ac, string const & argument); - /** Adds the BufferView to the users list. - Later this func will insert the BufferView into a real list, - not just setting a pointer. - */ - void addUser(BufferView *u) { users = u; } + /// + void resizeInsets(BufferView *); - /** Removes the BufferView from the users list. - Since we only can have one at the moment, we just reset it. - */ - void delUser(BufferView *){ users = 0; } + /// Update window titles of all users. + void updateTitles() const; - /// - void update(signed char f); + /// Reset autosave timers for all users. + void resetAutosaveTimers() const; - /// - void redraw(void){ - users->redraw(); - users->fitCursor(); - users->updateScrollbar(); } + /** Adds the BufferView to the users list. + Later this func will insert the \c BufferView into a real list, + not just setting a pointer. + */ + void addUser(BufferView * u); - /// Open and lock an updatable inset - void open_new_inset(UpdatableInset*); + /** Removes the #BufferView# from the users list. + Since we only can have one at the moment, we just reset it. + */ + void delUser(BufferView *); /// + void redraw(); + + /// Load the autosaved file. void loadAutoSaveFile(); - - /** Reads a file. - Returns false if it fails. - If par is given, the file is inserted. */ - bool readFile(LyXLex &, LyXParagraph *par = 0); - + + /** Reads a file. + \param par if != 0 insert the file. + \return \c false if method fails. + */ + bool readFile(LyXLex &, Paragraph * par = 0); + /** Reads a file without header. - Returns false, if file is not completely read. - If par is given, the file is inserted. */ - bool readLyXformat2(LyXLex &,LyXParagraph *par = 0); + \param par if != 0 insert the file. + \return \c false if file is not completely read. + */ + bool readLyXformat2(LyXLex &, Paragraph * par = 0); + + /// This parses a single LyXformat-Token. + bool parseSingleLyXformat2Token(LyXLex &, Paragraph *& par, + Paragraph *& return_par, + string const & token, int & pos, + Paragraph::depth_type & depth, + LyXFont &); + /// + void insertStringAsLines(Paragraph *&, lyx::pos_type &, + LyXFont const &, string const &) const; +#ifndef NO_COMPABILITY + /// + void insertErtContents(Paragraph * par, int & pos, + bool set_inactive = true); +#endif + /// + Paragraph * getParFromID(int id) const; +private: + /// Parse a single inset. + void readInset(LyXLex &, Paragraph *& par, int & pos, LyXFont &); +public: + /** Save file. + Takes care of auto-save files and backup file if requested. + Returns \c true if the save is successful, \c false otherwise. + */ + bool save() const; - /// Inserts a lyx file at cursor position. Returns false if it fails. - bool insertLyXFile(LString const & filename); + /// Write file. Returns \c false if unsuccesful. + bool writeFile(string const &, bool) const; - /// Write file. Returns false if unsuccesful. - bool writeFile(LString const &, bool); - /// - void writeFileAscii(LString const & , int); - + void writeFileAscii(string const & , int); + /// + void writeFileAscii(std::ostream &, int); /// - void makeLaTeXFile(LString const & filename, - LString const & original_path, + string const asciiParagraph(Paragraph const *, unsigned int linelen, + bool noparbreak = false) const; + /// + void makeLaTeXFile(string const & filename, + string const & original_path, bool nice, bool only_body = false); + /** LaTeX all paragraphs from par to endpar. + \param \a endpar if == 0 then to the end + */ + void latexParagraphs(std::ostream & os, Paragraph * par, + Paragraph * endpar, TexRow & texrow) const; + /// + void simpleDocBookOnePar(std::ostream &, + Paragraph * par, int & desc_on, + Paragraph::depth_type depth) const ; + /// + void simpleLinuxDocOnePar(std::ostream & os, Paragraph * par, + Paragraph::depth_type depth); + /// + void makeLinuxDocFile(string const & filename, + bool nice, bool only_body = false); + /// + void makeDocBookFile(string const & filename, + bool nice, bool only_body = false); + /// Open SGML/XML tag. + void sgmlOpenTag(std::ostream & os, Paragraph::depth_type depth, + string const & latexname) const; + /// Closes SGML/XML tag. + void sgmlCloseTag(std::ostream & os, Paragraph::depth_type depth, + string const & latexname) const; + /// + void sgmlError(Paragraph * par, int pos, string const & message) const; + /// returns the main language for the buffer (document) + Language const * getLanguage() const; + /// + int runChktex(); + /// + bool isLyxClean() const; + /// + bool isBakClean() const; /// - int runLaTeX(); + bool isDepClean(string const & name) const; - /// - int runLiterate(); + /// + void markLyxClean() const; - /// - int buildProgram(); + /// + void markBakClean(); /// - int runChktex(); + void markDepClean(string const & name); /// - void makeLinuxDocFile(LString const & filename, int column); + void setUnnamed(bool flag = true); + /// - void makeDocBookFile(LString const & filename, int column); + bool isUnnamed(); - /// returns the main language for the buffer (document) - LString GetLanguage() const { - return params.language; - } - - /// - bool isLyxClean() const { return lyx_clean; } - - /// changed Heinrich Bauer, 23/03/98 - bool isDviClean(); - - /// - bool isNwClean() const { return nw_clean; } - - /// - bool isBakClean() const { return bak_clean; } - - /// - bool isDepClean(LString const & name) const; - - /// - void markLyxClean() { - if (!lyx_clean) { - lyx_clean = true; - updateTitles(); - } - // if the .lyx file has been saved, we don't need an - // autosave - bak_clean = true; - } + /// Mark this buffer as dirty. + void markDirty(); - /// changed Heinrich Bauer, 23/03/98 - void markDviClean(); - - /// - void markNwClean() { nw_clean = true; } - - /// - void markBakClean() { bak_clean = true; } - - /// - void markDepClean(LString const & name); - - /// - void markDviDirty(); - - /// - void markNwDirty() { nw_clean = false; } - - /// - void markDirty() { - if (lyx_clean) { - lyx_clean = false; - updateTitles(); - } - dvi_clean_tmpd = false; - dvi_clean_orgd = false; - nw_clean = false; - bak_clean = false; - DEPCLEAN* tmp = dep_clean; - while (tmp) { - tmp->clean = false; - tmp = tmp->next; - } - } + /// Returns the buffer's filename. It is always an absolute path. + string const & fileName() const; - /// - LString getFileName() const { return filename; } + /// Returns the the path where the buffer lives. + /// It is always an absolute path. + string const & filePath() const; + + /** A transformed version of the file name, adequate for LaTeX. + \param no_path optional if \c true then the path is stripped. + */ + string const getLatexName(bool no_path = true) const; + + /// Get the name and type of the log. + std::pair const getLogName() const; /// Change name of buffer. Updates "read-only" flag. - void setFileName(LString const & newfile); + void setFileName(string const & newfile); /// Name of the document's parent - void setParentName(LString const &); + void setParentName(string const &); /// Is buffer read-only? - bool isReadonly() { return read_only; } + bool isReadonly() const; /// Set buffer read-only flag - void setReadonly(bool flag = true) - { - if (read_only != flag) { - read_only = flag; - updateTitles(); - updateAllVisibleBufferRelatedPopups(); - } - if (read_only) { - WarnReadonly(); - } - } + void setReadonly(bool flag = true); + + /// returns \c true if the buffer contains a LaTeX document + bool isLatex() const; + /// returns \c true if the buffer contains a LinuxDoc document + bool isLinuxDoc() const; + /// returns \c true if the buffer contains a DocBook document + bool isDocBook() const; + /** returns \c true if the buffer contains either a LinuxDoc + or DocBook document */ + bool isSGML() const; + /// returns \c true if the buffer contains a Wed document + bool isLiterate() const; - /// returns true if the buffer contains a LaTeX document - bool isLatex(); - /// returns true if the buffer contains a LinuxDoc document - bool isLinuxDoc(); - /// returns true if the buffer contains a DocBook document - bool isDocBook(); - /// returns true if the buffer contains either a LinuxDoc or DocBook document - bool isSGML(); - /// returns true if the buffer contains a Wed document - bool isLiterate(); + /** Validate a buffer for LaTeX. + This validates the buffer, and returns a struct for use by + #makeLaTeX# and others. Its main use is to figure out what + commands and packages need to be included in the LaTeX file. + It (should) also check that the needed constructs are there + (i.e. that the \refs points to coresponding \labels). It + should perhaps inset "error" insets to help the user correct + obvious mistakes. + */ + void validate(LaTeXFeatures &) const; /// - void setPaperStuff(); - + string const getIncludeonlyList(char delim = ','); /// - void setOldPaperStuff(); - - /** Validate a buffer for LaTeX. - This validates the buffer, and returns a struct for use by - makeLaTeX and others. Its main use is to figure out what commands - and packages need to be included in the LaTeX file. It (should) - also check that the needed constructs are there (i.e. that the \refs - points to coresponding \labels). It should perhaps inset "error" - insets to help the user correct obvious mistakes. - */ - void validate(LaTeXFeatures&); //the correct parameters to be - //included later - - /** Insert an inset into the buffer - Insert inset into buffer, placing it in a layout of lout, - if no_table make sure that it doesn't end up in a table. */ - void insertInset(Inset *, LString const &lout=LString(), - bool no_table = false); - - /// - void setCursorFromRow (int); - + std::vector > const getBibkeyList(); /// - LString getIncludeonlyList(char delim=','); + struct TocItem { + TocItem(Paragraph * p, int d, string const & s) + : par(p), depth(d), str(s) {} + /// + Paragraph * par; + /// + int depth; + /// + string str; + }; /// - LString getReferenceList(char delim='|'); + typedef std::vector SingleList; /// - LString getBibkeyList(char delim='|'); + typedef std::map Lists; /// - bool gotoLabel(const LString&); - - /// removes all autodeletable insets - bool removeAutoInsets(); + Lists const getLists() const; + /// + std::vector const getLabelList(); /** This will clearly have to change later. Later we can have more - than one user per buffer. */ - BufferView* getUser() const { return users; } + than one user per buffer. */ + BufferView * getUser() const; - //@} + /// + void changeLanguage(Language const * from, Language const * to); + /// + bool isMultiLingual(); + + /// Does this mean that this is buffer local? + UndoStack undostack; /// Does this mean that this is buffer local? - UndoStack undostack; - - /// Does this mean that this is buffer local? - UndoStack redostack; - + UndoStack redostack; + /// BufferParams params; - - /** is a list of paragraphs. - */ - LyXParagraph *paragraph; - - /** This holds the mapping between buffer paragraphs and screen rows. - Should be moved to BufferView. (Asger) - */ - LyXText *text; - /// - UpdatableInset* the_locking_inset; + /** The list of paragraphs. + This is a linked list of paragraph, this list holds the + whole contents of the document. + */ + Paragraph * paragraph; - /// RCS object + /// LyX version control object. LyXVC lyxvc; - /// where the temporaries go if we want them - LString tmppath; - - /// - LString filepath; + /// Where to put temporary files. + string tmppath; - /** While writing as LaTeX, tells whether we are + /** If we are writing a nice LaTeX file or not. + While writing as LaTeX, tells whether we are doing a 'nice' LaTeX file */ bool niceFile; -protected: - /// - void InsetUnlock(); - - /// - inline void InsetSleep(); - - /// - inline void InsetWakeup(); - - /// - bool inset_slept; - - /// - int slx; - /// - int sly; + + /// Used when typesetting to place errorboxes. + TexRow texrow; private: - /// - void insertErrors(TeXErrors &); - - /// - void linuxDocHandleFootnote(FILE *file,LyXParagraph* &par, int const depth); - /// - void DocBookHandleCaption(FILE *file, LString &inner_tag, - int const depth, int desc_on, - LyXParagraph* &par); - /// - void DocBookHandleFootnote(FILE *file,LyXParagraph* &par, int const depth); - /// - void sgmlOpenTag(FILE * file,int depth,LString & latexname); - /// - void sgmlCloseTag(FILE * file,int depth,LString & latexname); - /// - void LinuxDocError(LyXParagraph *par, int pos, char const *message); - /// - void SimpleLinuxDocOnePar(FILE *file, LyXParagraph *par, int desc_on, int const depth); - /// - void SimpleDocBookOnePar(LString &file, LString &extra, LyXParagraph *par, int & desc_on, int const depth); + /// is save needed + mutable bool lyx_clean; - /// LinuxDoc. - void push_tag(FILE *file, char const *tag, int& pos, char stack[5][3]); - - /// LinuxDoc. - void pop_tag(FILE *file, char const * tag, int& pos, char stack[5][3]); + /// is autosave needed + mutable bool bak_clean; - /// - void RoffAsciiTable(FILE *file, LyXParagraph *par); + /// is this a unnamed file (New...) + bool unnamed; - /// is save needed - bool lyx_clean; - - /// is autosave needed - bool bak_clean; - - /// do we need to run LaTeX, changed 23/03/98, Heinrich Bauer - /// We have to distinguish between TeX-runs executed in the original - /// directory (in which the original LyX-file resides) and TeX-runs - /// executed in a temporary directory. The first situation is valid - /// for a dvi-export, the latter one for printing or previewing. - bool dvi_clean_orgd; - bool dvi_clean_tmpd; - - /// do we need to run weave/tangle - bool nw_clean; - - /// is regenerating .tex necessary - DEPCLEAN *dep_clean; + /// is regenerating #.tex# necessary + DEPCLEAN * dep_clean; /// buffer is r/o bool read_only; /// name of the file the buffer is associated with. - LString filename; + string filename_; + + /// The path to the document file. + string filepath_; /// Format number of buffer - float format; - + int file_format; /** A list of views using this buffer. - Why not keep a list of the BufferViews that use this buffer? + Why not keep a list of the BufferViews that use this buffer? - At least then we don't have to do a lot of magic like: - buffer->lyx_gui->bufferview->updateLayoutChoice. Just ask each - of the buffers in the list of users to do a updateLayoutChoice. - */ - BufferView *users; + At least then we don't have to do a lot of magic like: + #buffer->lyx_gui->bufferview->updateLayoutChoice#. Just ask each + of the buffers in the list of users to do a #updateLayoutChoice#. + */ + BufferView * users; +public: /// - friend class BufferList; + class inset_iterator { + public: + typedef std::input_iterator_tag iterator_category; + typedef Inset value_type; + typedef ptrdiff_t difference_type; + typedef Inset * pointer; + typedef Inset & reference; + + + /// + inset_iterator() : par(0) /*, it(0)*/ {} + // + inset_iterator(Paragraph * paragraph) : par(paragraph) { + setParagraph(); + } + /// + inset_iterator(Paragraph * paragraph, lyx::pos_type pos); + /// + inset_iterator & operator++() { // prefix ++ + if (par) { + ++it; + if (it == par->inset_iterator_end()) { + par = par->next(); + setParagraph(); + } + } + return *this; + } + /// + inset_iterator operator++(int) { // postfix ++ + inset_iterator tmp(par, it.getPos()); + if (par) { + ++it; + if (it == par->inset_iterator_end()) { + par = par->next(); + setParagraph(); + } + } + return tmp; + } + /// + Inset * operator*() { return *it; } + + /// + Paragraph * getPar() { return par; } + /// + lyx::pos_type getPos() const { return it.getPos(); } + /// + friend + bool operator==(inset_iterator const & iter1, + inset_iterator const & iter2); + private: + /// + void setParagraph(); + /// + Paragraph * par; + /// + Paragraph::inset_iterator it; + }; + + /// + inset_iterator inset_iterator_begin() { + return inset_iterator(paragraph); + } + /// + inset_iterator inset_iterator_end() { + return inset_iterator(); + } /// - friend class BufferView; + inset_iterator inset_const_iterator_begin() const { + return inset_iterator(paragraph); + } + /// + inset_iterator inset_const_iterator_end() const { + return inset_iterator(); + } - /// Used when typesetting to place errorboxes. - TexRow texrow; + /// + ParIterator par_iterator_begin(); + /// + ParIterator par_iterator_end(); + + /// + Inset * getInsetFromID(int id_arg) const; }; -inline -void Buffer::InsetSleep() +inline +void Buffer::addUser(BufferView * u) { - if (the_locking_inset && !inset_slept) { - the_locking_inset->GetCursorPos(slx, sly); - the_locking_inset->InsetUnlock(); - inset_slept = true; - } + users = u; } -inline -void Buffer::InsetWakeup() +inline +void Buffer::delUser(BufferView *) { - if (the_locking_inset && inset_slept) { - the_locking_inset->Edit(slx, sly); - inset_slept = false; - } + users = 0; } -inline -void Buffer::setParentName(LString const &name) +inline +Language const * Buffer::getLanguage() const { - params.parentname = name; + return params.language; } +inline +bool Buffer::isLyxClean() const +{ + return lyx_clean; +} + + +inline +bool Buffer::isBakClean() const +{ + return bak_clean; +} + + +inline +void Buffer::markLyxClean() const +{ + if (!lyx_clean) { + lyx_clean = true; + updateTitles(); + } + // if the .lyx file has been saved, we don't need an + // autosave + bak_clean = true; +} + + +inline +void Buffer::markBakClean() +{ + bak_clean = true; +} + + +inline +void Buffer::setUnnamed(bool flag) +{ + unnamed = flag; +} + + +inline +bool Buffer::isUnnamed() +{ + return unnamed; +} + + +inline +void Buffer::markDirty() +{ + if (lyx_clean) { + lyx_clean = false; + updateTitles(); + } + bak_clean = false; + DEPCLEAN * tmp = dep_clean; + while (tmp) { + tmp->clean = false; + tmp = tmp->next; + } +} + + +inline +string const & Buffer::fileName() const +{ + return filename_; +} + + +inline +string const & Buffer::filePath() const +{ + return filepath_; +} + + +inline +bool Buffer::isReadonly() const +{ + return read_only; +} + + +inline +BufferView * Buffer::getUser() const +{ + return users; +} + + +inline +void Buffer::setParentName(string const & name) +{ + params.parentname = name; +} + + +/// +inline +bool operator==(Buffer::TocItem const & a, Buffer::TocItem const & b) +{ + return a.par == b.par && a.str == b.str; + // No need to compare depth. +} + + +/// +inline +bool operator!=(Buffer::TocItem const & a, Buffer::TocItem const & b) +{ + return !(a == b); + // No need to compare depth. +} + + +/// +inline +bool operator==(Buffer::inset_iterator const & iter1, + Buffer::inset_iterator const & iter2) +{ + return iter1.par == iter2.par + && (iter1.par == 0 || iter1.it == iter2.it); +} + + +/// +inline +bool operator!=(Buffer::inset_iterator const & iter1, + Buffer::inset_iterator const & iter2) +{ + return !(iter1 == iter2); +} + #endif