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         /// info for each toolbar
 301         typedef std::map<std::string, ToolbarInfo> ToolbarMap;
 302
 303 public:
 304         ///
 305         void read(std::istream & is);
 306
 307         ///
 308         void write(std::ostream & os) const;
 309
 310         /// return reference to toolbar info, create a new one if needed
 311         ToolbarInfo & load(std::string const & name);
 312
 313 private:
 314         /// toolbar information
 315         ToolbarMap toolbars;
 316 };
 317
 318
 319 class SessionInfoSection : SessionSection
 320 {
 321 public:
 322         ///
 323         typedef std::map<std::string, std::string> MiscInfo;
 324
 325 public:
 326         ///
 327         void read(std::istream & is);
 328
 329         ///
 330         void write(std::ostream & os) const;
 331
 332         /** set session info
 333                 @param key key of the value to store
 334                 @param value value, a string without newline ('\n')
 335         */
 336         void save(std::string const & key, std::string const & value);
 337
 338         /** load session info
 339                 @param key a key to extract value from the session file
 340                 @param release whether or not clear the value. Default to true
 341                         since most of such values are supposed to be used only once.
 342         */
 343         std::string const load(std::string const & key, bool release = true);
 344
 345 private:
 346         /// a map to save session info
 347         MiscInfo sessioninfo;
 348 };
 349
 350
 351 class Session : boost::noncopyable {
 352
 353 public:
 354         /** Read the session file.
 355             @param num length of lastfiles
 356         */
 357         explicit Session(unsigned int num = 4);
 358
 359         /** Write the session file.
 360         */
 361         void writeFile() const;
 362
 363         ///
 364         LastFilesSection & lastFiles() { return last_files; }
 365
 366         ///
 367         LastFilesSection const & lastFiles() const { return last_files; }
 368
 369         ///
 370         LastOpenedSection & lastOpened() { return last_opened; }
 371
 372         ///
 373         LastOpenedSection const & lastOpened() const { return last_opened; }
 374
 375         ///
 376         LastFilePosSection & lastFilePos() { return last_file_pos; }
 377
 378         ///
 379         LastFilePosSection const & lastFilePos() const { return last_file_pos; }
 380
 381         ///
 382         BookmarksSection & bookmarks() { return bookmarks_; }
 383
 384         ///
 385         BookmarksSection const & bookmarks() const { return bookmarks_; }
 386
 387         ///
 388         ToolbarSection & toolbars() { return toolbars_; }
 389
 390         ///
 391         ToolbarSection const & toolbars() const { return toolbars_; }
 392
 393         ///
 394         SessionInfoSection & sessionInfo() { return session_info; }
 395
 396         ///
 397         SessionInfoSection const & sessionInfo() const { return session_info; }
 398
 399 private:
 400         /// file to save session, determined in the constructor.
 401         support::FileName session_file;
 402
 403         /** Read the session file.
 404             Reads the #.lyx/session# at the beginning of the LyX session.
 405             This will read the session file (usually #.lyx/session#).
 406             @param file the file containing the session.
 407         */
 408         void readFile();
 409
 410         ///
 411         LastFilesSection last_files;
 412
 413         ///
 414         LastOpenedSection last_opened;
 415
 416         ///
 417         LastFilePosSection last_file_pos;
 418
 419         ///
 420         BookmarksSection bookmarks_;
 421
 422         ///
 423         ToolbarSection toolbars_;
 424
 425         ///
 426         SessionInfoSection session_info;
 427 };
 428
 429 }
 430
 431 #endif