summaryrefslogtreecommitdiffstats
path: root/kate/app/katesession.h
blob: fa267e91f022b97e1d72b7b910143c5eafd828cf (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
/* This file is part of the KDE project
   Copyright (C) 2005 Christoph Cullmann <cullmann@kde.org>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/

#ifndef __KATE_SESSION_H__
#define __KATE_SESSION_H__

#include "katemain.h"

#include <kdialogbase.h>
#include <ksimpleconfig.h>
#include <ksharedptr.h>
#include <tdeaction.h>

#include <tqobject.h>
#include <tqptrlist.h>
#include <tqvaluelist.h>
#include <tqstringlist.h>
#include <tdelistview.h>

class KateViewSpace;
class KDirWatch;
class KPushButton;
class TDEListView;
class TQCheckBox;
class KateSessionManager;


//BEGIN KateSession
/**
 * An object representing a Kate's session.
 */
class KateSession
{
	public:

		/**
		 * create a new session and read the config from fileName if it exists
		 * @param manager the session manager handling this session
		 * @param sessionName session name
		 * @param fileName file where session config is saved to/restored from
		 */
		KateSession(const KateSessionManager &manager, const TQString &sessionName, const TQString &fileName);

		/**
		 * duplicate an existing session into a new one with the given new name.
		 * If the existing session is read-only, the new one will *not* be read-only by default
		 * @param session the existing session 
		 * @param newSessionName the name of the new session
		 */
		KateSession(const KateSession &session, const TQString &newSessionName);

		/**
		 * Destructor
		 */
		~KateSession();

		/**
		* @return the session name
		*/
		const TQString& getSessionName() const { return m_sessionName; }

		/**
		* Set the new session name
		* @param sessionName the new session name
		*/
		void setSessionName(const TQString &sessionName);

		/**
		* @return whether the session is read only or not
		*/
		bool isReadOnly() const { return m_readOnly; }

		/**
		* Set session read only status
		* @param readOnly if true, the session status can not be modified
		*/
		void setReadOnly(bool readOnly) { m_readOnly = readOnly; }

		/**
		* @return the session filename if available, otherwise the null string
		*/
		const TQString& getSessionFilename() const { return m_filename; }

		/**
		* @return whether the session is still volatile, i.e. it has never
		*         been saved and never been named
		*/
		bool isStillVolatile() const;
		
		/**
		* @return the number of documents in the session
		*/
		int getDocCount() const { return m_documents.count(); }

		/**
		 * Load session info from the saved file
		 * @param includeGUIInfo if true, also load the information about the GUI elements
		 */
		void load(bool includeGUIInfo);
		
		/**
		 * Save session info
		 * @param saveGUIInfo if true, save also the information about the GUI elements
		 * @param setReadOnly necessary to save a session that has to be turned to read only
		 */
		void save(bool saveGUIInfo, bool setReadOnly = false);

		/**
		 * Activate the session
		 */
		void activate();


	private:

		friend class KateViewSpace;

		/**
		* @return the session config object
		*/
		TDEConfig* getConfig() const { return m_config; }
    
 		/**
		* create a new filename for a session object
		*/
		void createFilename();

    const KateSessionManager &m_manager;  // The session manager that handles this session
		TQString       m_sessionName;
		TQString       m_filename;
		bool           m_readOnly;
		TQStringList   m_documents;           // document URLs
		KSimpleConfig *m_config;              // session config

};
//END KateSession


//BEGIN KateSessionManager
//FIXME (advanced - multiple main windows or multiple Kate instances)
//There should be only one session manager regardless of how many main windows of Kate are open.
//Changes should propagate to all session panels. Different Kate main windows should run different
//sessions. If the user switches to a session already opened in another Kate window, the other window
//should be brought up to the screen (eventually ask user confirmation first).
//This would allow a safe use of multiple Kate main windows/instances without overwriting session information
//among them. Currently the last instance/main window to be closed will overwrite the information previously
//saved by other Kate instances.
/**
 * The Kate session manager. It takes care of storing and retrieving each session object
 * as well as providing methods to operate on them.
 *
 * @note The Kate session manager takes ownership of each session object it handles.
 */
//FIXME update the sessions.list file when switching to another session or to a new session
//
//FIXME create new unnamed session, choose 'save' as session switch option. Exit Kate. 
//      Session is saved without asking for a name
//FIXME improve getStartupOption/getSwitchOption/setSwitchOption using new signal
//      KateApp::optionsChanged()
//FIXME add kdDebug statement to ease debugging
class KateSessionManager : public TQObject
{
  TQ_OBJECT

	public:

    enum
    {
      INVALID_SESSION = -1
    };

    // Session options on Kate startup
    enum 
    {
      STARTUP_NEW = 0,    // New session
      STARTUP_LAST,       // Use last session
      STARTUP_MANUAL      // Manually choose a session
    };
		
    // Session options on session switch or Kate shutdown
    enum 
    {
      SWITCH_DISCARD = 0, // Don't save current session
      SWITCH_SAVE,        // Save current session
      SWITCH_ASK          // Ask user what to do
    };
		
		/**
		 * get a pointer to the unique KateSessionManager instance.
		 * If the manager does not exist yet, create it.
		 */
		static KateSessionManager* self();

		/**
		 * Destructor
		 */
		~KateSessionManager();

		/**
		 * Save session manager info
		 * @param saveSessions true  = sessions info will be saved
		 *                     false = all sessions will be discarded
		 */
		void saveConfig(bool saveSessions);
		
		/**
		 * @return the session startup option
		 * The function checks the config file to see if there was any value update 
		 */
		const int getStartupOption();
		
		/**
		 * @return the session switch option
		 * The function checks the config file to see if there was any value update 
		 */
		const int getSwitchOption();
		
		/**
		 * Set the new session switch preference
		 * @param option the new option value. Defaults to SWITCH_ASK if the value is invalid.
		 * @emit switchOptionChanged
		 */
		void setSwitchOption(int option);
		
		/**
		 * @return the session files folder name
		 */
		const TQString& getBaseDir() const { return m_baseDir; }
		
		/**
		 * @return the number of existing sessions
		 */
		int getSessionCount() const { return m_sessions.count(); }
		
		/**
		 * @return the active session id
		 */
		int getActiveSessionId() const { return m_activeSessionId; }

		/**
		 * @return the active session name
		 */
		const TQString& getActiveSessionName() /*FIXME const*/ { return m_sessions[m_activeSessionId]->getSessionName(); }

		/**
		 * @param sessionId the id of the session of interest
		 * @return the name of the specified session
		 */
		const TQString& getSessionName(int sessionId) /*FIXME const*/;

		/**
		 * @return a reference to the active session
		 */
		KateSession* getActiveSession() { return m_sessions[m_activeSessionId]; }

		/**
		 * @param sessionId the id of the session to return
		 * @return a reference to the specified session
		 */
		KateSession* getSessionFromId(int sessionId);

    /**
     * Return the session id of the first session whose name matches the
     * provided one. In case multiple sessions share the same name,
     * the id of the first one found will be returned.
     * @param name the session name to look for
     * @return the session id of the matching session if it is found,
     *         otherwise KateSessionManager::INVALID_SESSION.
     */
    int getSessionIdFromName(const TQString &name);

		/**
		 * @return a reference to the sessions list
		 */
		TQPtrList<KateSession>& getSessionsList() { return m_sessions; }

		/**
		 * Activate the selected session.
		 * @param sessionId the id of the session to activate
		 * @param saveCurr if true, save the current session before activating the new one
		 * @return whether the session was activated or not
		 * @emit sessionActivated
		 */
		bool activateSession(int sessionId, bool saveCurr = true);

		/**
		 * Create a new session and activate it
		 * @param sessionName new session name
		 * @param saveCurr if true, save the current session before activating the new one
		 * @return the id of the newly created session
		 * @emit sessionCreated
     * @emit sessionDeleted  (only when leaving an unstored and unnamed session)
		 */
		int newSession(const TQString &sessionName = TQString::null, bool saveCurr = true);

		/**
		 * Create a new session and activate it if required
		 * @param sessionId the id of the session to clone
		 * @param sessionName the new session name
		 * @param activate if true, activate the new session after creation
		 * @param deleteCurr if true, delete the current session after switching
		 * @return the id of the newly created session
		 * @emit sessionCreated
		 */
		int cloneSession(int sessionId, const TQString &sessionName = TQString::null, 
		                 bool activate = true, bool deleteCurr = false);

		/**
		 * Restore the current active session to the last saved state
		 */
		void reloadActiveSession() { m_sessions[m_activeSessionId]->load(true); }

    /**
     * Restore the last saved session. Can only be used before
     * any other session has been activated, i.e. on Kate's startup
     * @return whether the session was activated or not
     */
    bool restoreLastSession();

		/**
		 * Saves the active session
     * @emit sessionSaved (through invoked "void saveSession(int)" method)
		 */
		void saveActiveSession() { saveSession(m_activeSessionId); }

		/**
		 * Save the specified session
		 * @param sessionId the id of the session to save
     * @emit sessionSaved
     */
		void saveSession(int sessionId) { saveSession(sessionId, sessionId == m_activeSessionId); }

		/**
		 * Delete the specified session
		 * @param sessionId the id of the session to delete
		 * @param actSessId the id of the next session to activate.
		 *        If INVALID_SESSION or invalid, create a new empty session.
		 *        This is only meaningful when deleting the current active session.
     * @return whether the session has been deleted or not
     * @emit sessionDeleted
		 */
		bool deleteSession(int sessionId, int actSessId);

		/**
		 * Move the specified session forward in the session list (by one position)
		 * @param sessionId the id of the session to move
     */
		void moveSessionForward(int sessionId);

		/**
		 * Move the specified session backward in the session list (by one position)
		 * @param sessionId the id of the session to move
     */
		void moveSessionBackward(int sessionId);

		/**
		 * Rename the specified session
		 * @param sessionId the id of the session to rename
		 * @param newSessionName the new session name
     * @emit sessionRenamed
     */
		void renameSession(int sessionId, const TQString &newSessionName);

		/**
		 * Set the read only status of the specified session
		 * @param sessionId the id of the session to modify
		 * @param readOnly the new read only status
		 */
		void setSessionReadOnlyStatus(int sessionId, bool readOnly);

  signals:
		/**
		 * Emitted when the session switch option has been set/changed
		 */
		void switchOptionChanged();
		
		/**
		 * Emitted once a session has been activated
		 * @param newSessionId the id of the previous active session
		 * @param oldSessionId the id of the new active session
		 */
		void sessionActivated(int newSessionId, int oldSessionId);

		/**
		 * Emitted once a session has been created
		 * @param sessionId the id of the new session
		 */
		void sessionCreated(int sessionId);

		/**
		 * Emitted once a session has been saved
		 * @param sessionId the id of the saved session
		 */
		void sessionSaved(int sessionId);

		/**
		 * Emitted once a session has been deleted
		 * @param sessionId the id of the deleted session
		 */
		void sessionDeleted(int sessionId);

		/**
		 * Emitted once the position of the two sessions have been swapped
		 * @param sessionIdMin the smallest id of the session couple
		 * @param sessionIdMax the biggest id of the session couple
		 */
		void sessionsSwapped(int sessionIdMin, int sessionIdMax);

		/**
		 * Emitted once a session has been renamed
		 * @param sessionId the id of the new session
		 */
		void sessionRenamed(int sessionId);


	protected:
		KateSessionManager();

    // Session options on Kate startup
    enum 
    {
      SO_STARTUP = 0,     // session startup option only
      SO_SWITCH,          // session switch option only
      SO_ALL,             // session startup and switch options
    };
		
		/**
		 * Updated the session startup and switch options
		 * @param optionType specifies which options needs to be updated
     */
		void updateSessionOptions(int optionType);
		
		/**
		 * Save the session startup and switch options to the config file
		 * @param optionType specifies which options needs to be saved
     */
		void saveSessionOptions(int optionType);
		
		/**
		 * Swap the position of the two specified sessions in the session list
		 * @param sessionId1 the id of the first session
		 * @param sessionId2 the id of the second session
		 * @emit sessionsSwapped
		 */
		void swapSessionsPosition(int sessionId1, int sessionId2);

		/**
		 * Save the specified session
		 * @param sessionId the id of the session to save
		 * @param saveGUIInfo if true, save also the information about the GUI elements
		 * @param setReadOnly necessary to save a session that has to be turned to read only
     * @emit sessionSaved
     */
		void saveSession(int sessionId, bool saveGUIInfo, bool setReadOnly = false);


		TQString m_baseDir;       					// folder where session files are stored
		TQString m_configFile;     					// file where the session list config is stored
		int m_activeSessionId;              // id of the active session
    int m_lastSessionId;                // id of the last active session before closing Kate
		TQPtrList<KateSession> m_sessions;  // session list
		KSimpleConfig *m_config;        		// session manager config
		int m_startupOption;                // session option on Kate startup
		int m_switchOption;                 // session option on session switch or Kate shutdown
		
		static KateSessionManager *ksm_instance;  // the only KateSessionManager instance
};
//END KateSessionManager


//BEGIN KateSessionChooserItem
class KateSessionChooserItem : public TDEListViewItem
{
  public:
    KateSessionChooserItem(TQListView *listview, const TQString &sessionName, const TQString &nDoc, int sessionId)
      : TDEListViewItem(listview, sessionName, nDoc), m_sessionId(sessionId) {}

		int  getSessionId() { return m_sessionId; }
		void setSessionId(int sessionId) { m_sessionId = sessionId; }

	protected:
    int m_sessionId;
};
//END KateSessionChooserItem


//BEGIN KateSessionChooser
//FIXME create one single KateSessionChooser and reuse it all the time
class KateSessionChooser : public KDialogBase
{
	TQ_OBJECT

	public:
		enum Result
		{
			RESULT_NO_OP = TQDialog::Rejected,
			RESULT_OPEN_EXISTING,
			RESULT_OPEN_NEW,
			RESULT_QUIT_KATE
		};

		KateSessionChooser(TQWidget *parent);
	 ~KateSessionChooser() {}

		int getSelectedSessionId();  // return the session id of the selected session

	protected slots:

		void slotUser1();   // open existing session
		void slotUser2();   // open new session
		void slotUser3();   // quit kate
		void slotSelectionChanged();  // list selection has changed

	protected:
		TDEListView *m_listview;
};
//END KateSessionChooser

#endif