X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fsession.h;h=4cf5dcb0808bd0c10c32f43d4bcd0f3f5c347941;hb=cd4033aef3a3f1efdb5a676b8bab3d367f53a830;hp=5458211206f53ff28c9d87e7575eb448c1bea62e;hpb=34770cd68bdc30b0685cdf2cfbae9463ef1747c5;p=lyx.git diff --git a/src/session.h b/src/session.h index 5458211206..4cf5dcb080 100644 --- a/src/session.h +++ b/src/session.h @@ -13,7 +13,8 @@ #ifndef SESSION_H #define SESSION_H -#include +#include "support/filename.h" +#include "support/types.h" #include #include @@ -35,33 +36,40 @@ const long maxlastfiles = 20; */ namespace lyx { -class Session : boost::noncopyable { +/** base class for all sections in the session file +*/ +class SessionSection : boost::noncopyable { public: /// - typedef boost::tuple FilePos; - /// - typedef std::map FilePosMap; - /// - typedef std::deque LastFiles; - /// - typedef std::vector LastOpened; + virtual ~SessionSection() {} + + /// read section from std::istream + virtual void read(std::istream & is) = 0; + + /// write to std::ostream + virtual void write(std::ostream & os) const = 0; +}; + + +class LastFilesSection : SessionSection +{ +public: /// - typedef boost::tuple Bookmark; + typedef std::deque LastFiles; + +public: /// - typedef std::vector BookmarkList; + explicit LastFilesSection(unsigned int num = 4); + /// - typedef std::map MiscInfo; + void read(std::istream & is); -public: - /** Read the session file. - @param num length of lastfiles - */ - explicit Session(unsigned int num = 4); + /// + void write(std::ostream & os) const; - /** Write the session file. - */ - void writeFile() const; + /// Return lastfiles container (deque) + LastFiles const lastFiles() const { return lastfiles; } /** Insert #file# into the lastfile dequeue. This funtion inserts #file# into the last files list. If the file @@ -70,86 +78,343 @@ public: file in the list is popped from the end. @param file the file to insert in the lastfile list. */ - void addLastFile(std::string const & file); + void add(support::FileName const & file); - /** add cursor position to the fname entry in the filepos map - @param fname file entry for which to save position information - @param pos position of the cursor when the file is closed. +private: + /// Default number of lastfiles. + unsigned int const default_num_last_files; + + /// Max number of lastfiles. + unsigned int const absolute_max_last_files; + + /// a list of lastfiles + LastFiles lastfiles; + + /// number of files in the lastfiles list. + unsigned int num_lastfiles; + + /** Used by the constructor to set the number of stored last files. + @param num the number of lastfiles to set. */ - void saveFilePosition(std::string const & fname, FilePos pos); + void setNumberOfLastFiles(unsigned int num); +}; - /** clear lastopened file list - */ - void clearLastOpenedFiles(); + +class LastOpenedSection : SessionSection +{ +public: + /// + typedef std::vector LastOpened; + +public: + /// + void read(std::istream & is); + + /// + void write(std::ostream & os) const; + + /// Return lastopened container (vector) + LastOpened const getfiles() const { return lastopened; } /** add file to lastopened file list @param file filename to add */ - void addLastOpenedFile(std::string const & file); + void add(support::FileName const & file); + + /** clear lastopened file list + */ + void clear(); + +private: + /// a list of lastopened files + LastOpened lastopened; +}; + + +class LastFilePosSection : SessionSection +{ +public: + /// + typedef boost::tuple FilePos; + + /// + typedef std::map FilePosMap; + +public: + /// + LastFilePosSection() : num_lastfilepos(100) {} + + /// + void read(std::istream & is); + + /// + void write(std::ostream & os) const; + + /** add cursor position to the fname entry in the filepos map + @param fname file entry for which to save position information + @param pos position of the cursor when the file is closed. + */ + void save(support::FileName const & fname, FilePos pos); /** load saved cursor position from the fname entry in the filepos map @param fname file entry for which to load position information */ - FilePos loadFilePosition(std::string const & fname) const; + FilePos load(support::FileName const & fname) const; - /// Return lastfiles container (deque) - LastFiles const lastFiles() const { return lastfiles; } +private: + /// default number of lastfilepos to save */ + unsigned int const num_lastfilepos; - /// Return lastopened container (vector) - LastOpened const lastOpenedFiles() const { return lastopened; } - /** save a bookmark - @bookmark bookmark to be saved - */ - void saveBookmark(Bookmark const & bookmark); + /// a map of file positions + FilePosMap lastfilepos; +}; + + +class BookmarksSection : SessionSection +{ +public: + /// bookmarks + class Bookmark { + public: + /// Filename + support::FileName filename; + /// Cursor pit, will be saved/restored by .lyx/session + pit_type par_pit; + /// Cursor paragraph Id, used to lcoate bookmarks for opened files + int par_id; + /// Cursor position within a paragraph + pos_type par_pos; + /// + Bookmark() : par_id(0), par_pos(0) {} + /// + Bookmark(support::FileName const & f, pit_type pit, int id, pos_type pos) + : filename(f), par_pit(pit), par_id(id), par_pos(pos) {} + /// set bookmark par_id, this is because newly loaded bookmark + /// may have zero par_id and par_pit can change during editing, see bug 3092 + void setPos(pit_type pit, int id) { + par_pit = pit; + par_id = id; + } + }; + + /// + typedef std::deque BookmarkList; + +public: + /// constructor, set max_bookmarks + /// allow 20 regular bookmarks + BookmarksSection() : bookmarks(0), max_bookmarks(20) {} + + /// Save the current position as bookmark + /// if save==false, save to temp_bookmark + void save(support::FileName const & fname, pit_type pit, int par_id, pos_type par_pos, bool persistent); + + /// return bookmark, return temp_bookmark if i==0 + Bookmark const & bookmark(unsigned int i) const; + + /// does the given bookmark have a saved position ? + bool isValid(unsigned int i) const; + + /// + unsigned int size() const { return bookmarks.size(); } + + /// clear all bookmarks + void clear() { bookmarks.clear(); } + + /// + void read(std::istream & is); + + /// + void write(std::ostream & os) const; /** return bookmark list. Non-const container is used since bookmarks will be cleaned after use. */ - BookmarkList & loadBookmarks() { return bookmarks; } + BookmarkList & load() { return bookmarks; } + +private: + /// temp bookmark (previously saved_positions[0]), this is really ugly + /// c.f. ./frontends/controllers/ControlRef.C + /// FIXME: a separate LFUN may be a better solution + Bookmark temp_bookmark; + + /// a list of bookmarks + BookmarkList bookmarks; + + /// + unsigned int const max_bookmarks; +}; + + +class ToolbarSection : SessionSection +{ +public: + /// information about a toolbar, not all information can be + /// saved/restored by all frontends, but this class provides + /// a superset of things that can be managed by session. + class ToolbarInfo + { + public: + /// + ToolbarInfo() : + state(ON), location(NOTSET), posx(0), posy(0) { } + /// + ToolbarInfo(int s, int loc, int x=0, int y=0) : + state(static_cast(s)), + location(static_cast(loc)), + posx(x), + posy(y) + { } + + public: + enum State { + ON, + OFF, + AUTO + }; + + /// on/off/auto + State state; + + /// location: this can be intepreted differently. + enum Location { + TOP, + BOTTOM, + LEFT, + RIGHT, + NOTSET + }; + + Location location; + + /// x-position of the toolbar + int posx; + + /// y-position of the toolbar + int posy; + + /// potentially, icons + }; + + typedef boost::tuple ToolbarItem; + + /// info for each toolbar + typedef std::vector ToolbarList; + + +public: + /// + void read(std::istream & is); + + /// + void write(std::ostream & os) const; + + /// return reference to toolbar info, create a new one if needed + ToolbarInfo & load(std::string const & name); + + /// toolbar begin + ToolbarList::const_iterator begin() { return toolbars.begin(); } + + /// toolbar end + ToolbarList::const_iterator end() { return toolbars.end(); } + +private: + /// toolbar information + ToolbarList toolbars; +}; + +/// comparison operator to sort toolbars, the rules are: +/// ON before OFF +/// TOP < BOTTOM < LEFT < RIGHT +/// Line at each side +/// order in each line +bool operator< (ToolbarSection::ToolbarItem const & a, ToolbarSection::ToolbarItem const & b); + + +class SessionInfoSection : SessionSection +{ +public: + /// + typedef std::map MiscInfo; + +public: + /// + void read(std::istream & is); + + /// + void write(std::ostream & os) const; /** set session info @param key key of the value to store @param value value, a string without newline ('\n') */ - void saveSessionInfo(std::string const & key, std::string const & value); + void save(std::string const & key, std::string const & value); /** load session info @param key a key to extract value from the session file @param release whether or not clear the value. Default to true since most of such values are supposed to be used only once. */ - std::string const loadSessionInfo(std::string const & key, bool release = true); + std::string const load(std::string const & key, bool release = true); + private: - /// Default number of lastfiles. - unsigned int const default_num_last_files; + /// a map to save session info + MiscInfo sessioninfo; +}; - /// Max number of lastfiles. - unsigned int const absolute_max_last_files; - /// default number of lastfilepos to save */ - unsigned int const num_lastfilepos; +class Session : boost::noncopyable { - /// file to save session, determined in the constructor. - std::string session_file; +public: + /** Read the session file. + @param num length of lastfiles + */ + explicit Session(unsigned int num = 4); - /// a list of lastfiles - LastFiles lastfiles; + /** Write the session file. + */ + void writeFile() const; - /// a list of bookmarks - BookmarkList bookmarks; + /// + LastFilesSection & lastFiles() { return last_files; } + + /// + LastFilesSection const & lastFiles() const { return last_files; } - /// a map to save session info - MiscInfo sessioninfo; + /// + LastOpenedSection & lastOpened() { return last_opened; } - /// number of files in the lastfiles list. - unsigned int num_lastfiles; + /// + LastOpenedSection const & lastOpened() const { return last_opened; } + + /// + LastFilePosSection & lastFilePos() { return last_file_pos; } + + /// + LastFilePosSection const & lastFilePos() const { return last_file_pos; } - /// a map of file positions - FilePosMap lastfilepos; + /// + BookmarksSection & bookmarks() { return bookmarks_; } - /// a list of lastopened files - LastOpened lastopened; + /// + BookmarksSection const & bookmarks() const { return bookmarks_; } + + /// + ToolbarSection & toolbars() { return toolbars_; } + + /// + ToolbarSection const & toolbars() const { return toolbars_; } + + /// + SessionInfoSection & sessionInfo() { return session_info; } + + /// + SessionInfoSection const & sessionInfo() const { return session_info; } + +private: + /// file to save session, determined in the constructor. + support::FileName session_file; /** Read the session file. Reads the #.lyx/session# at the beginning of the LyX session. @@ -158,10 +423,23 @@ private: */ void readFile(); - /** Used by the constructor to set the number of stored last files. - @param num the number of lastfiles to set. - */ - void setNumberOfLastFiles(unsigned int num); + /// + LastFilesSection last_files; + + /// + LastOpenedSection last_opened; + + /// + LastFilePosSection last_file_pos; + + /// + BookmarksSection bookmarks_; + + /// + ToolbarSection toolbars_; + + /// + SessionInfoSection session_info; }; }