X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fbuffer.h;h=ca1e2692bea41dae2480effdfbd4cc720c7d996e;hb=8effd3eec4f9f143572875416ed8815e2a26cd12;hp=95cfdb8d7d322599f90e76d7441d283c2072fe05;hpb=53b464c5e95ed708e9464db0499826894be450fd;p=lyx.git diff --git a/src/buffer.h b/src/buffer.h index 95cfdb8d7d..ca1e2692be 100644 --- a/src/buffer.h +++ b/src/buffer.h @@ -1,14 +1,14 @@ // -*- 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 -* -* ====================================================== */ + * + * LyX, The Document Processor + * Copyright 1995 Matthias Ettrich + * + * This file is Copyleft 1996 + * Lars Gullik Bjønnes + * + * ====================================================== */ // Change Log: // =========== @@ -26,21 +26,19 @@ #pragma interface #endif -#include "undo.h" +#include "LString.h" + #include "BufferView.h" #include "lyxvc.h" #include "bufferparams.h" #include "texrow.h" -#include "lyxtext.h" -#include "support/filetools.h" -#include "lyx_gui_misc.h" class LyXRC; class TeXErrors; class LaTeXFeatures; - -extern void updateAllVisibleBufferRelatedPopups(); +class auto_mem_buffer; +class Language; /// struct DEPCLEAN { @@ -49,7 +47,7 @@ struct DEPCLEAN { /// string master; /// - DEPCLEAN *next; + DEPCLEAN * next; }; /** The buffer object. @@ -59,127 +57,133 @@ struct DEPCLEAN { */ class Buffer { public: - /**@name Constructors and destructor */ - //@{ /// - Buffer(string const & file, LyXRC * lyxrc = 0, bool b = false); + explicit Buffer(string const & file, bool b = false); /// ~Buffer(); - //@} - - /**@name Methods */ - //@{ /** save the buffer's parameters as user default - This function saves a file user_lyxdir/templates/defaults.lyx + 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. + file. Returns #true# on success. */ bool saveParamsAsDefaults(); - /** high-level interface to buffer functionality + /** High-level interface to buffer functionality. This function parses a command string and executes it */ - void Dispatch(const string & command); + bool Dispatch(string const & command); /// Maybe we know the function already by number... - void Dispatch(int ac, const string & argument); + bool Dispatch(int ac, string const & argument); + + /// and have an xtl buffer to work with. + bool Dispatch(int, auto_mem_buffer &); /// should be changed to work for a list. - void resize() - { - if (users) { - users->resize(); - } - } + void resize(); + /// + void resizeInsets(BufferView *); /// Update window titles of all users - void updateTitles(); + void updateTitles() const; /// Reset autosave timers for all users - void resetAutosaveTimers(); + void resetAutosaveTimers() const; /** Adds the BufferView to the users list. - Later this func will insert the BufferView into a real list, + Later this func will insert the #BufferView# into a real list, not just setting a pointer. */ void addUser(BufferView * u) { users = u; } - /** Removes the BufferView from the users list. + /** 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; } + void delUser(BufferView *) { users = 0; } /// void redraw() { users->redraw(); - users->fitCursor(); - users->updateScrollbar(); + users->fitCursor(users->text); + //users->updateScrollbar(); } - /// Open and lock an updatable inset - //void open_new_inset(UpdatableInset *); - /// void loadAutoSaveFile(); /** Reads a file. - Returns false if it fails. - If par is given, the file is inserted. */ + @param par if != 0 insert the file. + @return #false# if method fails. + */ bool readFile(LyXLex &, LyXParagraph * par = 0); /** Reads a file without header. - Returns false, if file is not completely read. - If par is given, the file is inserted. */ + @param par if != 0 insert the file. + @return false if file is not completely read. + */ bool readLyXformat2(LyXLex &, LyXParagraph * par = 0); - /// Inserts a lyx file at cursor position. Returns false if it fails. - //bool insertLyXFile(string const & filename); - - /// Write file. Returns false if unsuccesful. - bool writeFile(string const &, bool); + /// This parses a single LyXformat-Token. + bool parseSingleLyXformat2Token(LyXLex &, LyXParagraph *& par, + LyXParagraph *& return_par, + string const & token, int & pos, + char & depth, LyXFont & +#ifndef NEW_INSETS + ,LyXParagraph::footnote_flag &, + LyXParagraph::footnote_kind & +#endif + ); +private: + /// Parse a single inset. + void readInset(LyXLex &, LyXParagraph *& par, int & pos, LyXFont &); +public: + /** Save file + Takes care of auto-save files and backup file if requested. + Returns #true# if the save is successful, #false# otherwise. + */ + bool save() const; + + /// Write file. Returns #false# if unsuccesful. + bool writeFile(string const &, bool) const; /// void writeFileAscii(string const & , int); - + /// + void writeFileAscii(std::ostream &, int); + /// + string const asciiParagraph(LyXParagraph const *, + unsigned int linelen) const; /// void makeLaTeXFile(string const & filename, string const & original_path, bool nice, bool only_body = false); - - /// - int runLaTeX(); - - /// - int runLiterate(); - - /// - int buildProgram(); + /** LaTeX all paragraphs from par to endpar. + @param endpar if == 0 then to the end + */ + void latexParagraphs(std::ostream & os, LyXParagraph * par, + LyXParagraph * endpar, TexRow & texrow) const; /// int runChktex(); /// - void makeLinuxDocFile(string const & filename, int column); + void makeLinuxDocFile(string const & filename, + bool nice, bool only_body = false); /// - void makeDocBookFile(string const & filename, int column); + void makeDocBookFile(string const & filename, + bool nice, bool only_body = false); /// returns the main language for the buffer (document) - string GetLanguage() const { + Language const * 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; } @@ -187,7 +191,7 @@ public: bool isDepClean(string const & name) const; /// - void markLyxClean() { + void markLyxClean() const { if (!lyx_clean) { lyx_clean = true; updateTitles(); @@ -197,12 +201,6 @@ public: bak_clean = true; } - /// changed Heinrich Bauer, 23/03/98 - void markDviClean(); - - /// - void markNwClean() { nw_clean = true; } - /// void markBakClean() { bak_clean = true; } @@ -210,20 +208,17 @@ public: void markDepClean(string const & name); /// - void markDviDirty(); - - /// - void markNwDirty() { nw_clean = false; } - + void setUnnamed(bool flag=true) { unnamed = flag; } + + /// + bool isUnnamed() { return unnamed; } + /// 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) { @@ -235,90 +230,86 @@ public: /// string const & fileName() const { return filename; } - /// A transformed version of the file name, adequate for LaTeX - /* The path is stripped if no_path is true (default) */ - string getLatexName(bool no_path = true) const { - return ChangeExtension(MakeLatexName(filename), - ".tex", no_path); - } + /** A transformed version of the file name, adequate for LaTeX + The path is stripped if no_path is true (default) + */ + string const getLatexName(bool no_path = true) const; /// Change name of buffer. Updates "read-only" flag. - void fileName(string const & newfile); + void setFileName(string const & newfile); /// Name of the document's parent void setParentName(string const &); /// Is buffer read-only? - bool isReadonly() { return read_only; } + bool isReadonly() const { return read_only; } /// Set buffer read-only flag - void setReadonly(bool flag = true) { - if (read_only != flag) { - read_only = flag; - updateTitles(); - updateAllVisibleBufferRelatedPopups(); - } - if (read_only) { - WarnReadonly(filename); - } - } + void setReadonly(bool flag = true); - /// returns true if the buffer contains a LaTeX document + /// returns #true# if the buffer contains a LaTeX document bool isLatex() const; - /// returns true if the buffer contains a LinuxDoc document + /// returns #true# if the buffer contains a LinuxDoc document bool isLinuxDoc() const; - /// returns true if the buffer contains a DocBook document + /// returns #true# if the buffer contains a DocBook document bool isDocBook() const; - /// returns true if the buffer contains either a LinuxDoc or DocBook document + /** returns #true# if the buffer contains either a LinuxDoc + or DocBook document */ bool isSGML() const; - /// returns true if the buffer contains a Wed document + /// returns #true# if the buffer contains a Wed document bool isLiterate() const; /// void setPaperStuff(); -#if 0 - /// - void setOldPaperStuff(); -#endif - /** 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. + #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 *, string const & lout = string(), - // bool no_table = false); - - /// - //void setCursorFromRow (int); + void validate(LaTeXFeatures &) const; /// - string getIncludeonlyList(char delim = ','); + string const getIncludeonlyList(char delim = ','); /// - string getReferenceList(char delim = '|'); + std::vector > const getBibkeyList(); /// - string getBibkeyList(char delim = '|'); + struct TocItem { + /// + LyXParagraph * par; + /// + int depth; + /// + string str; + }; /// - //bool gotoLabel(string const &); - - /// removes all autodeletable insets - //bool removeAutoInsets(); + enum TocType { + /// + TOC_TOC = 0, + /// + TOC_LOF, + /// + TOC_LOT, + /// + TOC_LOA + }; + /// + std::vector > const getTocList(); + /// + 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; } - //@} + /// + void ChangeLanguage(Language const * from, Language const * to); + /// + bool isMultiLingual(); /// Does this mean that this is buffer local? UndoStack undostack; @@ -349,64 +340,55 @@ public: /// Used when typesetting to place errorboxes. TexRow texrow; private: - /// - //void insertErrors(TeXErrors &); - +#ifndef NEW_INSETS /// - void linuxDocHandleFootnote(ostream & os, - LyXParagraph * & par, int const depth); + void linuxDocHandleFootnote(std::ostream & os, + LyXParagraph * & par, int depth); +#endif /// - void DocBookHandleCaption(ostream & os, string & inner_tag, - int const depth, int desc_on, + void DocBookHandleCaption(std::ostream & os, string & inner_tag, + int depth, int desc_on, LyXParagraph * & par); +#ifndef NEW_INSETS /// - void DocBookHandleFootnote(ostream & os, - LyXParagraph * & par, int const depth); + void DocBookHandleFootnote(std::ostream & os, + LyXParagraph * & par, int depth); +#endif /// - void sgmlOpenTag(ostream & os, int depth, + void sgmlOpenTag(std::ostream & os, int depth, string const & latexname) const; /// - void sgmlCloseTag(ostream & os, int depth, + void sgmlCloseTag(std::ostream & os, int depth, string const & latexname) const; /// - void LinuxDocError(LyXParagraph * par, int pos, char const * message); + void LinuxDocError(LyXParagraph * par, int pos, + string const & message); /// - void SimpleLinuxDocOnePar(ostream & os, LyXParagraph * par, - int desc_on, int const depth); + void SimpleLinuxDocOnePar(std::ostream & os, LyXParagraph * par, + int desc_on, int depth); /// - void SimpleDocBookOnePar(string & file, string & extra, + void SimpleDocBookOnePar(std::ostream &, string & extra, LyXParagraph * par, int & desc_on, - int const depth); + int depth); /// LinuxDoc. - void push_tag(ostream & os, char const * tag, + void push_tag(std::ostream & os, string const & tag, int & pos, char stack[5][3]); /// LinuxDoc. - void pop_tag(ostream & os, char const * tag, + void pop_tag(std::ostream & os, string const & tag, int & pos, char stack[5][3]); - - /// - void RoffAsciiTable(ostream &, LyXParagraph * par); /// is save needed - bool lyx_clean; + mutable bool lyx_clean; /// is autosave needed - bool bak_clean; + mutable 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 + /// is this a unnamed file (New...) + bool unnamed; + + /// is regenerating #.tex# necessary DEPCLEAN * dep_clean; /// buffer is r/o @@ -422,11 +404,86 @@ private: 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. + #buffer->lyx_gui->bufferview->updateLayoutChoice#. Just ask each + of the buffers in the list of users to do a #updateLayoutChoice#. */ BufferView * users; +public: + /// + 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(LyXParagraph * paragraph) : par(paragraph) { + SetParagraph(); + } + /// + inset_iterator(LyXParagraph * paragraph, + LyXParagraph::size_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; } + + /// + LyXParagraph * getPar() { return par; } + /// + LyXParagraph::size_type getPos() const { return it.getPos(); } + /// + friend + bool operator==(inset_iterator const & iter1, + inset_iterator const & iter2); + // + //friend + //bool operator!=(inset_iterator const & iter1, + // inset_iterator const & iter2); + private: + /// + void SetParagraph(); + /// + LyXParagraph * par; + /// + LyXParagraph::inset_iterator it; + }; + + /// + inset_iterator inset_iterator_begin() { + return inset_iterator(paragraph); + } + /// + inset_iterator inset_iterator_end() { + return inset_iterator(); + } }; @@ -436,4 +493,34 @@ 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 +