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::vector<Bookmark> BookmarkList;
 203
 204 public:
 205         /// constructor, set max_bookmarks
 206         /// allow 9 regular bookmarks, bookmark 0 is temporary
 207         BookmarksSection() : bookmarks(10), max_bookmarks(9) {}
 208
 209         /// Save the current position as bookmark
 210         void save(support::FileName const & fname, pit_type pit, int par_id, pos_type par_pos, unsigned int idx);
 211
 212         /// return bookmark 0-9, bookmark 0 is the temporary bookmark
 213         Bookmark const & bookmark(unsigned int i) const;
 214
 215         /// does the given bookmark have a saved position ?
 216         bool isValid(unsigned int i) const;
 217
 218         ///
 219         unsigned int size() const { return max_bookmarks; }
 220
 221         /// clear all bookmarks
 222         void clear();
 223
 224         ///
 225         void read(std::istream & is);
 226
 227         ///
 228         void write(std::ostream & os) const;
 229
 230         /** return bookmark list. Non-const container is used since
 231                 bookmarks will be cleaned after use.
 232         */
 233         BookmarkList & load() { return bookmarks; }
 234
 235 private:
 236
 237         /// a list of bookmarks
 238         BookmarkList bookmarks;
 239
 240         ///
 241         unsigned int const max_bookmarks;
 242 };
 243
 244
 245 class ToolbarSection : SessionSection
 246 {
 247 public:
 248         /// information about a toolbar, not all information can be
 249         /// saved/restored by all frontends, but this class provides
 250         /// a superset of things that can be managed by session.
 251         class ToolbarInfo
 252         {
 253         public:
 254                 ///
 255                 ToolbarInfo() :
 256                         state(ON), location(NOTSET), posx(0), posy(0) { }
 257                 ///
 258                 ToolbarInfo(int s, int loc, int x=0, int y=0) :
 259                         state(static_cast<State>(s)),
 260                         location(static_cast<Location>(loc)),
 261                         posx(x),
 262                         posy(y)
 263                         { }
 264
 265         public:
 266                 enum State {
 267                         ON,
 268                         OFF,
 269                         AUTO
 270                 };
 271
 272                 /// on/off/auto
 273                 State state;
 274
 275                 /// location: this can be intepreted differently.
 276                 enum Location {
 277                         TOP,
 278                         BOTTOM,
 279                         LEFT,
 280                         RIGHT,
 281                         NOTSET
 282                 };
 283
 284                 Location location;
 285
 286                 /// x-position of the toolbar
 287                 int posx;
 288
 289                 /// y-position of the toolbar
 290                 int posy;
 291
 292                 /// potentially, icons
 293         };
 294
 295         typedef boost::tuple<std::string, ToolbarInfo> ToolbarItem;
 296
 297         /// info for each toolbar
 298         typedef std::vector<ToolbarItem> ToolbarList;
 299
 300
 301 public:
 302         ///
 303         void read(std::istream & is);
 304
 305         ///
 306         void write(std::ostream & os) const;
 307
 308         /// return reference to toolbar info, create a new one if needed
 309         ToolbarInfo & load(std::string const & name);
 310
 311         /// toolbar begin
 312         ToolbarList::const_iterator begin() { return toolbars.begin(); }
 313
 314         /// toolbar end
 315         ToolbarList::const_iterator end() { return toolbars.end(); }
 316
 317 private:
 318         /// toolbar information
 319         ToolbarList toolbars;
 320 };
 321
 322 /// comparison operator to sort toolbars, the rules are:
 323 ///         ON before OFF
 324 ///     TOP < BOTTOM < LEFT < RIGHT
 325 ///     Line at each side
 326 ///     order in each line
 327 bool operator< (ToolbarSection::ToolbarItem const & a, ToolbarSection::ToolbarItem const & b);
 328
 329
 330 class SessionInfoSection : SessionSection
 331 {
 332 public:
 333         ///
 334         typedef std::map<std::string, std::string> MiscInfo;
 335
 336 public:
 337         ///
 338         void read(std::istream & is);
 339
 340         ///
 341         void write(std::ostream & os) const;
 342
 343         /** set session info
 344                 @param key key of the value to store
 345                 @param value value, a string without newline ('\n')
 346         */
 347         void save(std::string const & key, std::string const & value);
 348
 349         /** load session info
 350                 @param key a key to extract value from the session file
 351                 @param release whether or not clear the value. Default to true
 352                         since most of such values are supposed to be used only once.
 353         */
 354         std::string const load(std::string const & key, bool release = true);
 355
 356 private:
 357         /// a map to save session info
 358         MiscInfo sessioninfo;
 359 };
 360
 361
 362 class Session : boost::noncopyable {
 363
 364 public:
 365         /** Read the session file.
 366             @param num length of lastfiles
 367         */
 368         explicit Session(unsigned int num = 4);
 369
 370         /** Write the session file.
 371         */
 372         void writeFile() const;
 373
 374         ///
 375         LastFilesSection & lastFiles() { return last_files; }
 376
 377         ///
 378         LastFilesSection const & lastFiles() const { return last_files; }
 379
 380         ///
 381         LastOpenedSection & lastOpened() { return last_opened; }
 382
 383         ///
 384         LastOpenedSection const & lastOpened() const { return last_opened; }
 385
 386         ///
 387         LastFilePosSection & lastFilePos() { return last_file_pos; }
 388
 389         ///
 390         LastFilePosSection const & lastFilePos() const { return last_file_pos; }
 391
 392         ///
 393         BookmarksSection & bookmarks() { return bookmarks_; }
 394
 395         ///
 396         BookmarksSection const & bookmarks() const { return bookmarks_; }
 397
 398         ///
 399         ToolbarSection & toolbars() { return toolbars_; }
 400
 401         ///
 402         ToolbarSection const & toolbars() const { return toolbars_; }
 403
 404         ///
 405         SessionInfoSection & sessionInfo() { return session_info; }
 406
 407         ///
 408         SessionInfoSection const & sessionInfo() const { return session_info; }
 409
 410 private:
 411         /// file to save session, determined in the constructor.
 412         support::FileName session_file;
 413
 414         /** Read the session file.
 415             Reads the #.lyx/session# at the beginning of the LyX session.
 416             This will read the session file (usually #.lyx/session#).
 417             @param file the file containing the session.
 418         */
 419         void readFile();
 420
 421         ///
 422         LastFilesSection last_files;
 423
 424         ///
 425         LastOpenedSection last_opened;
 426
 427         ///
 428         LastFilePosSection last_file_pos;
 429
 430         ///
 431         BookmarksSection bookmarks_;
 432
 433         ///
 434         ToolbarSection toolbars_;
 435
 436         ///
 437         SessionInfoSection session_info;
 438 };
 439
 440 }
 441
 442 #endif