src/session.h

   1 // -*- C++ -*-
   2 /**
   3  * \file session.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author Lars Gullik Bjønnes
   8  * \author Bo Peng
   9  *
  10  * Full author contact details are available in file CREDITS.
  11  */
  12
  13 #ifndef SESSION_H
  14 #define SESSION_H
  15
  16 #include "support/filename.h"
  17 #include "support/types.h"
  18
  19 #include <boost/utility.hpp>
  20 #include <boost/tuple/tuple.hpp>
  21
  22 #include <string>
  23 #include <deque>
  24 #include <vector>
  25 #include <map>
  26
  27 // used by at least frontends/qt2/QPref.C
  28 const long maxlastfiles = 20;
  29
  30 /** This session file maintains
  31   1. the latest documents loaded (lastfiles)
  32   2. cursor positions of files closed (lastfilepos)
  33   3. opened files when a lyx session is closed (lastopened)
  34   4. bookmarks
  35   5. general purpose session info in the form of key/value pairs
  36  */
  37 namespace lyx {
  38
  39 /** base class for all sections in the session file
  40 */
  41 class SessionSection : boost::noncopyable {
  42
  43 public:
  44         ///
  45         virtual ~SessionSection() {}
  46
  47         /// read section from std::istream
  48         virtual void read(std::istream & is) = 0;
  49
  50         /// write to std::ostream
  51         virtual void write(std::ostream & os) const = 0;
  52 };
  53
  54
  55 class LastFilesSection : SessionSection
  56 {
  57 public:
  58         ///
  59         typedef std::deque<support::FileName> LastFiles;
  60
  61 public:
  62         ///
  63         explicit LastFilesSection(unsigned int num = 4);
  64
  65         ///
  66         void read(std::istream & is);
  67
  68         ///
  69         void write(std::ostream & os) const;
  70
  71         /// Return lastfiles container (deque)
  72         LastFiles const lastFiles() const { return lastfiles; }
  73
  74         /** Insert #file# into the lastfile dequeue.
  75             This funtion inserts #file# into the last files list. If the file
  76             already exists it is moved to the top of the list, else exist it
  77             is placed on the top of the list. If the list is full the last
  78             file in the list is popped from the end.
  79             @param file the file to insert in the lastfile list.
  80         */
  81         void add(support::FileName const & file);
  82
  83 private:
  84         /// Default number of lastfiles.
  85         unsigned int const default_num_last_files;
  86
  87         /// Max number of lastfiles.
  88         unsigned int const absolute_max_last_files;
  89
  90         /// a list of lastfiles
  91         LastFiles lastfiles;
  92
  93         /// number of files in the lastfiles list.
  94         unsigned int num_lastfiles;
  95
  96         /** Used by the constructor to set the number of stored last files.
  97             @param num the number of lastfiles to set.
  98         */
  99         void setNumberOfLastFiles(unsigned int num);
 100 };
 101
 102
 103 class LastOpenedSection : SessionSection
 104 {
 105 public:
 106         ///
 107         typedef std::vector<support::FileName> LastOpened;
 108
 109 public:
 110         ///
 111         void read(std::istream & is);
 112
 113         ///
 114         void write(std::ostream & os) const;
 115
 116         /// Return lastopened container (vector)
 117         LastOpened const getfiles() const { return lastopened; }
 118
 119         /** add file to lastopened file list
 120             @param file filename to add
 121         */
 122         void add(support::FileName const & file);
 123
 124         /** clear lastopened file list
 125          */
 126         void clear();
 127
 128 private:
 129         /// a list of lastopened files
 130         LastOpened lastopened;
 131 };
 132
 133
 134 class LastFilePosSection : SessionSection
 135 {
 136 public:
 137         ///
 138         typedef boost::tuple<pit_type, pos_type> FilePos;
 139
 140         ///
 141         typedef std::map<support::FileName, FilePos> FilePosMap;
 142
 143 public:
 144         ///
 145         LastFilePosSection() : num_lastfilepos(100) {}
 146
 147         ///
 148         void read(std::istream & is);
 149
 150         ///
 151         void write(std::ostream & os) const;
 152
 153         /** add cursor position to the fname entry in the filepos map
 154             @param fname file entry for which to save position information
 155             @param pos position of the cursor when the file is closed.
 156         */
 157         void save(support::FileName const & fname, FilePos pos);
 158
 159         /** load saved cursor position from the fname entry in the filepos map
 160             @param fname file entry for which to load position information
 161         */
 162         FilePos load(support::FileName const & fname) const;
 163
 164 private:
 165         /// default number of lastfilepos to save */
 166         unsigned int const num_lastfilepos;
 167
 168
 169         /// a map of file positions
 170         FilePosMap lastfilepos;
 171 };
 172
 173
 174 class BookmarksSection : SessionSection
 175 {
 176 public:
 177         /// bookmarks
 178         class Bookmark {
 179         public:
 180                 /// Filename
 181                 support::FileName filename;
 182                 /// Cursor pit, will be saved/restored by .lyx/session
 183                 pit_type par_pit;
 184                 /// Cursor paragraph Id, used to lcoate bookmarks for opened files
 185                 int par_id;
 186                 /// Cursor position within a paragraph
 187                 pos_type par_pos;
 188                 ///
 189                 Bookmark() : par_id(0), par_pos(0) {}
 190                 ///
 191                 Bookmark(support::FileName const & f, pit_type pit, int id, pos_type pos)
 192                         : filename(f), par_pit(pit), par_id(id), par_pos(pos) {}
 193                 /// set bookmark par_id, this is because newly loaded bookmark
 194                 /// may have zero par_id and par_pit can change during editing, see bug 3092
 195                 void setPos(pit_type pit, int id) {
 196                         par_pit = pit;
 197                         par_id = id;
 198                 }
 199         };
 200
 201         ///
 202         typedef std::deque<Bookmark> BookmarkList;
 203
 204 public:
 205         /// constructor, set max_bookmarks
 206         /// allow 20 regular bookmarks
 207         BookmarksSection() : bookmarks(0), max_bookmarks(20) {}
 208
 209         /// Save the current position as bookmark
 210         /// if save==false, save to temp_bookmark
 211         void save(support::FileName const & fname, pit_type pit, int par_id, pos_type par_pos, bool persistent);
 212
 213         /// return bookmark, return temp_bookmark if i==0
 214         Bookmark const & bookmark(unsigned int i) const;
 215
 216         /// does the given bookmark have a saved position ?
 217         bool isValid(unsigned int i) const;
 218
 219         ///
 220         unsigned int size() const { return bookmarks.size(); }
 221
 222         /// clear all bookmarks
 223         void clear() { bookmarks.clear(); }
 224
 225         ///
 226         void read(std::istream & is);
 227
 228         ///
 229         void write(std::ostream & os) const;
 230
 231         /** return bookmark list. Non-const container is used since
 232                 bookmarks will be cleaned after use.
 233         */
 234         BookmarkList & load() { return bookmarks; }
 235
 236 private:
 237         /// temp bookmark (previously saved_positions[0]), this is really ugly
 238         /// c.f. ./frontends/controllers/ControlRef.C
 239         /// FIXME: a separate LFUN may be a better solution
 240         Bookmark temp_bookmark;
 241
 242         /// a list of bookmarks
 243         BookmarkList bookmarks;
 244
 245         ///
 246         unsigned int const max_bookmarks;
 247 };
 248
 249
 250 class ToolbarSection : SessionSection
 251 {
 252 public:
 253         /// information about a toolbar, not all information can be
 254         /// saved/restored by all frontends, but this class provides
 255         /// a superset of things that can be managed by session.
 256         class ToolbarInfo
 257         {
 258         public:
 259                 ///
 260                 ToolbarInfo() :
 261                         state(ON), location(NOTSET), posx(0), posy(0) { }
 262                 ///
 263                 ToolbarInfo(int s, int loc, int x=0, int y=0) :
 264                         state(static_cast<State>(s)),
 265                         location(static_cast<Location>(loc)),
 266                         posx(x),
 267                         posy(y)
 268                         { }
 269
 270         public:
 271                 enum State {
 272                         ON,
 273                         OFF,
 274                         AUTO
 275                 };
 276
 277                 /// on/off/auto
 278                 State state;
 279
 280                 /// location: this can be intepreted differently.
 281                 enum Location {
 282                         TOP,
 283                         BOTTOM,
 284                         LEFT,
 285                         RIGHT,
 286                         NOTSET
 287                 };
 288
 289                 Location location;
 290
 291                 /// x-position of the toolbar
 292                 int posx;
 293
 294                 /// y-position of the toolbar
 295                 int posy;
 296
 297                 /// potentially, icons
 298         };
 299
 300         typedef boost::tuple<std::string, ToolbarInfo> ToolbarItem;
 301
 302         /// info for each toolbar
 303         typedef std::vector<ToolbarItem> ToolbarList;
 304
 305
 306 public:
 307         ///
 308         void read(std::istream & is);
 309
 310         ///
 311         void write(std::ostream & os) const;
 312
 313         /// return reference to toolbar info, create a new one if needed
 314         ToolbarInfo & load(std::string const & name);
 315
 316         /// toolbar begin
 317         ToolbarList::const_iterator begin() { return toolbars.begin(); }
 318
 319         /// toolbar end
 320         ToolbarList::const_iterator end() { return toolbars.end(); }
 321
 322 private:
 323         /// toolbar information
 324         ToolbarList toolbars;
 325 };
 326
 327 /// comparison operator to sort toolbars, the rules are:
 328 ///         ON before OFF
 329 ///     TOP < BOTTOM < LEFT < RIGHT
 330 ///     Line at each side
 331 ///     order in each line
 332 bool operator< (ToolbarSection::ToolbarItem const & a, ToolbarSection::ToolbarItem const & b);
 333
 334
 335 class SessionInfoSection : SessionSection
 336 {
 337 public:
 338         ///
 339         typedef std::map<std::string, std::string> MiscInfo;
 340
 341 public:
 342         ///
 343         void read(std::istream & is);
 344
 345         ///
 346         void write(std::ostream & os) const;
 347
 348         /** set session info
 349                 @param key key of the value to store
 350                 @param value value, a string without newline ('\n')
 351         */
 352         void save(std::string const & key, std::string const & value);
 353
 354         /** load session info
 355                 @param key a key to extract value from the session file
 356                 @param release whether or not clear the value. Default to true
 357                         since most of such values are supposed to be used only once.
 358         */
 359         std::string const load(std::string const & key, bool release = true);
 360
 361 private:
 362         /// a map to save session info
 363         MiscInfo sessioninfo;
 364 };
 365
 366
 367 class Session : boost::noncopyable {
 368
 369 public:
 370         /** Read the session file.
 371             @param num length of lastfiles
 372         */
 373         explicit Session(unsigned int num = 4);
 374
 375         /** Write the session file.
 376         */
 377         void writeFile() const;
 378
 379         ///
 380         LastFilesSection & lastFiles() { return last_files; }
 381
 382         ///
 383         LastFilesSection const & lastFiles() const { return last_files; }
 384
 385         ///
 386         LastOpenedSection & lastOpened() { return last_opened; }
 387
 388         ///
 389         LastOpenedSection const & lastOpened() const { return last_opened; }
 390
 391         ///
 392         LastFilePosSection & lastFilePos() { return last_file_pos; }
 393
 394         ///
 395         LastFilePosSection const & lastFilePos() const { return last_file_pos; }
 396
 397         ///
 398         BookmarksSection & bookmarks() { return bookmarks_; }
 399
 400         ///
 401         BookmarksSection const & bookmarks() const { return bookmarks_; }
 402
 403         ///
 404         ToolbarSection & toolbars() { return toolbars_; }
 405
 406         ///
 407         ToolbarSection const & toolbars() const { return toolbars_; }
 408
 409         ///
 410         SessionInfoSection & sessionInfo() { return session_info; }
 411
 412         ///
 413         SessionInfoSection const & sessionInfo() const { return session_info; }
 414
 415 private:
 416         /// file to save session, determined in the constructor.
 417         support::FileName session_file;
 418
 419         /** Read the session file.
 420             Reads the #.lyx/session# at the beginning of the LyX session.
 421             This will read the session file (usually #.lyx/session#).
 422             @param file the file containing the session.
 423         */
 424         void readFile();
 425
 426         ///
 427         LastFilesSection last_files;
 428
 429         ///
 430         LastOpenedSection last_opened;
 431
 432         ///
 433         LastFilePosSection last_file_pos;
 434
 435         ///
 436         BookmarksSection bookmarks_;
 437
 438         ///
 439         ToolbarSection toolbars_;
 440
 441         ///
 442         SessionInfoSection session_info;
 443 };
 444
 445 }
 446
 447 #endif