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 paragraph Id
 183                 int par_id;
 184                 /// Cursor position
 185                 pos_type par_pos;
 186                 ///
 187                 Bookmark() : par_id(0), par_pos(0) {}
 188                 ///
 189                 Bookmark(support::FileName const & f, int id, pos_type pos)
 190                         : filename(f), par_id(id), par_pos(pos) {}
 191         };
 192
 193         ///
 194         typedef std::deque<Bookmark> BookmarkList;
 195
 196 public:
 197         /// constructor, set max_bookmarks
 198         /// allow 20 regular bookmarks
 199         BookmarksSection() : bookmarks(0), max_bookmarks(20) {}
 200
 201         /// Save the current position as bookmark
 202         /// if save==false, save to temp_bookmark
 203         void save(support::FileName const & fname, int par_id, pos_type par_pos, bool persistent);
 204
 205         /// return bookmark, return temp_bookmark if i==0
 206         Bookmark const & bookmark(unsigned int i) const;
 207
 208         /// does the given bookmark have a saved position ?
 209         bool isValid(unsigned int i) const;
 210
 211         ///
 212         unsigned int size() const { return bookmarks.size(); }
 213
 214         /// clear all bookmarks
 215         void clear() { bookmarks.clear(); }
 216
 217         ///
 218         void read(std::istream & is);
 219
 220         ///
 221         void write(std::ostream & os) const;
 222
 223         /** return bookmark list. Non-const container is used since
 224                 bookmarks will be cleaned after use.
 225         */
 226         BookmarkList & load() { return bookmarks; }
 227
 228 private:
 229         /// temp bookmark (previously saved_positions[0]), this is really ugly
 230         /// c.f. ./frontends/controllers/ControlRef.C
 231         /// FIXME: a separate LFUN may be a better solution
 232         Bookmark temp_bookmark;
 233
 234         /// a list of bookmarks
 235         BookmarkList bookmarks;
 236
 237         ///
 238         unsigned int const max_bookmarks;
 239 };
 240
 241
 242 class ToolbarSection : SessionSection
 243 {
 244 public:
 245         /// information about a toolbar, not all information can be
 246         /// saved/restored by all frontends, but this class provides
 247         /// a superset of things that can be managed by session.
 248         class ToolbarInfo
 249         {
 250         public:
 251                 ///
 252                 ToolbarInfo() :
 253                         state(ON), location(NOTSET) { }
 254                 ///
 255                 ToolbarInfo(int s, int loc) :
 256                         state(static_cast<State>(s)), location(static_cast<Location>(loc)) { }
 257
 258         public:
 259                 enum State {
 260                         ON,
 261                         OFF,
 262                         AUTO
 263                 };
 264
 265                 /// on/off/auto
 266                 State state;
 267
 268                 /// location: this can be intepreted differently.
 269                 enum Location {
 270                         TOP,
 271                         BOTTOM,
 272                         LEFT,
 273                         RIGHT,
 274                         NOTSET
 275                 };
 276
 277                 Location location;
 278
 279                 /// potentially, icons
 280         };
 281
 282         /// info for each toolbar
 283         typedef std::map<std::string, ToolbarInfo> ToolbarMap;
 284
 285 public:
 286         ///
 287         void read(std::istream & is);
 288
 289         ///
 290         void write(std::ostream & os) const;
 291
 292         /// return reference to toolbar info, create a new one if needed
 293         ToolbarInfo & load(std::string const & name);
 294
 295 private:
 296         /// toolbar information
 297         ToolbarMap toolbars;
 298 };
 299
 300
 301 class SessionInfoSection : SessionSection
 302 {
 303 public:
 304         ///
 305         typedef std::map<std::string, std::string> MiscInfo;
 306
 307 public:
 308         ///
 309         void read(std::istream & is);
 310
 311         ///
 312         void write(std::ostream & os) const;
 313
 314         /** set session info
 315                 @param key key of the value to store
 316                 @param value value, a string without newline ('\n')
 317         */
 318         void save(std::string const & key, std::string const & value);
 319
 320         /** load session info
 321                 @param key a key to extract value from the session file
 322                 @param release whether or not clear the value. Default to true
 323                         since most of such values are supposed to be used only once.
 324         */
 325         std::string const load(std::string const & key, bool release = true);
 326
 327 private:
 328         /// a map to save session info
 329         MiscInfo sessioninfo;
 330 };
 331
 332
 333 class Session : boost::noncopyable {
 334
 335 public:
 336         /** Read the session file.
 337             @param num length of lastfiles
 338         */
 339         explicit Session(unsigned int num = 4);
 340
 341         /** Write the session file.
 342         */
 343         void writeFile() const;
 344
 345         ///
 346         LastFilesSection & lastFiles() { return last_files; }
 347
 348         ///
 349         LastFilesSection const & lastFiles() const { return last_files; }
 350
 351         ///
 352         LastOpenedSection & lastOpened() { return last_opened; }
 353
 354         ///
 355         LastOpenedSection const & lastOpened() const { return last_opened; }
 356
 357         ///
 358         LastFilePosSection & lastFilePos() { return last_file_pos; }
 359
 360         ///
 361         LastFilePosSection const & lastFilePos() const { return last_file_pos; }
 362
 363         ///
 364         BookmarksSection & bookmarks() { return bookmarks_; }
 365
 366         ///
 367         BookmarksSection const & bookmarks() const { return bookmarks_; }
 368
 369         ///
 370         ToolbarSection & toolbars() { return toolbars_; }
 371
 372         ///
 373         ToolbarSection const & toolbars() const { return toolbars_; }
 374
 375         ///
 376         SessionInfoSection & sessionInfo() { return session_info; }
 377
 378         ///
 379         SessionInfoSection const & sessionInfo() const { return session_info; }
 380
 381 private:
 382         /// file to save session, determined in the constructor.
 383         support::FileName session_file;
 384
 385         /** Read the session file.
 386             Reads the #.lyx/session# at the beginning of the LyX session.
 387             This will read the session file (usually #.lyx/session#).
 388             @param file the file containing the session.
 389         */
 390         void readFile();
 391
 392         ///
 393         LastFilesSection last_files;
 394
 395         ///
 396         LastOpenedSection last_opened;
 397
 398         ///
 399         LastFilePosSection last_file_pos;
 400
 401         ///
 402         BookmarksSection bookmarks_;
 403
 404         ///
 405         ToolbarSection toolbars_;
 406
 407         ///
 408         SessionInfoSection session_info;
 409 };
 410
 411 }
 412
 413 #endif