← Back to branch summary

~ubuntu-branches/debian/sid/filezilla/sid

« back to all changes in this revision

Viewing changes to src/interface/queue.h

  • Committer: Bazaar Package Importer
  • Author(s): Adam Cécile (Le_Vert)
  • Date: 2008-07-05 21:00:24 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080705210024-mvzp21zlyheschi6
Tags: 3.0.11.1-1
* wxWidgets 2.8 just entered unstable ! Upload to unstable.
* New upstream release.
* Bump Standards-Version to 3.8.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/interface/queue.h
 
1
#ifndef __QUEUE_H__
 
2
#define __QUEUE_H__
 
3
 
 
4
#include "aui_notebook_ex.h"
 
5
#include "listctrlex.h"
 
6
#include "edithandler.h"
 
7
 
 
8
#define PRIORITY_COUNT 5
 
9
enum QueuePriority
 
10
{
 
11
        priority_lowest = 0,
 
12
        priority_low = 1,
 
13
        priority_normal = 2,
 
14
        priority_high = 3,
 
15
        priority_highest = 4
 
16
};
 
17
 
 
18
enum QueueItemType
 
19
{
 
20
        QueueItemType_Server,
 
21
        QueueItemType_File,
 
22
        QueueItemType_Folder,
 
23
        QueueItemType_FolderScan,
 
24
        QueueItemType_Status
 
25
};
 
26
 
 
27
enum TransferDirection
 
28
{
 
29
        both,
 
30
        download,
 
31
        upload
 
32
};
 
33
 
 
34
class TiXmlElement;
 
35
class CQueueItem
 
36
{
 
37
public:
 
38
        virtual ~CQueueItem();
 
39
 
 
40
        virtual void SetPriority(enum QueuePriority priority);
 
41
 
 
42
        virtual void AddChild(CQueueItem* pItem);
 
43
        unsigned int GetChildrenCount(bool recursive);
 
44
        CQueueItem* GetChild(unsigned int item, bool recursive = true);
 
45
        CQueueItem* GetParent() { return m_parent; }
 
46
        const CQueueItem* GetParent() const { return m_parent; }
 
47
        void SetParent(CQueueItem* parent) { m_parent = parent; }
 
48
        virtual bool RemoveChild(CQueueItem* pItem, bool destroy = true); // Removes a child item with is somewhere in the tree of children.
 
49
        virtual bool TryRemoveAll(); // Removes a inactive childrens, queues active children for removal.
 
50
                                                                 // Returns true if item can be removed itself
 
51
        CQueueItem* GetTopLevelItem();
 
52
        const CQueueItem* GetTopLevelItem() const;
 
53
        int GetItemIndex() const; // Return the visible item index relative to the topmost parent item.
 
54
        virtual void SaveItem(TiXmlElement* pElement) const { }
 
55
 
 
56
        virtual enum QueueItemType GetType() const = 0;
 
57
 
 
58
protected:
 
59
        CQueueItem();
 
60
        wxString GetIndent();
 
61
 
 
62
        CQueueItem* m_parent;
 
63
 
 
64
        std::vector<CQueueItem*> m_children;
 
65
        int m_visibleOffspring; // Visible offspring over all sublevels
 
66
        wxString m_indent;
 
67
 
 
68
        int m_maxCachedIndex;
 
69
 
 
70
        struct t_cacheItem
 
71
        {
 
72
                int index;
 
73
                int child;
 
74
        };
 
75
        std::vector<t_cacheItem> m_lookupCache;
 
76
 
 
77
        friend class CServerItem;
 
78
};
 
79
 
 
80
class CFileItem;
 
81
class CServerItem : public CQueueItem
 
82
{
 
83
public:
 
84
        CServerItem(const CServer& server);
 
85
        virtual ~CServerItem();
 
86
        virtual enum QueueItemType GetType() const { return QueueItemType_Server; }
 
87
 
 
88
        const CServer& GetServer() const;
 
89
        wxString GetName() const;
 
90
 
 
91
        virtual void AddChild(CQueueItem* pItem);
 
92
 
 
93
        CFileItem* GetIdleChild(bool immadiateOnly, enum TransferDirection direction);
 
94
        virtual bool RemoveChild(CQueueItem* pItem, bool destroy = true); // Removes a child item with is somewhere in the tree of children
 
95
        wxLongLong GetTotalSize(int& filesWithUnknownSize, int& queuedFiles, int& folderScanCount) const;
 
96
 
 
97
        void QueueImmediateFiles();
 
98
        void QueueImmediateFile(CFileItem* pItem);
 
99
 
 
100
        virtual void SaveItem(TiXmlElement* pElement) const;
 
101
 
 
102
        void SetDefaultFileExistsAction(int action, const enum TransferDirection direction);
 
103
 
 
104
        int m_activeCount;
 
105
 
 
106
        virtual bool TryRemoveAll();
 
107
 
 
108
        void DetachChildren();
 
109
 
 
110
        virtual void SetPriority(enum QueuePriority priority);
 
111
 
 
112
        void SetChildPriority(CFileItem* pItem, enum QueuePriority oldPriority, enum QueuePriority newPriority);
 
113
 
 
114
protected:
 
115
        void AddFileItemToList(CFileItem* pItem);
 
116
        void RemoveFileItemFromList(CFileItem* pItem);
 
117
 
 
118
        CServer m_server;
 
119
 
 
120
        // array of item lists, sorted by priority. Used by scheduler to find
 
121
        // next file to transfer
 
122
        // First index specifies whether the item is queued (0) or immediate (1)
 
123
        std::list<CFileItem*> m_fileList[2][PRIORITY_COUNT];
 
124
};
 
125
 
 
126
struct t_EngineData;
 
127
 
 
128
class CFileItem : public CQueueItem
 
129
{
 
130
public:
 
131
        CFileItem(CServerItem* parent, bool queued, bool download, const wxString& localFile,
 
132
                        const wxString& remoteFile, const CServerPath& remotePath, wxLongLong size);
 
133
        virtual ~CFileItem();
 
134
 
 
135
        virtual void SetPriority(enum QueuePriority priority);
 
136
        void SetPriorityRaw(enum QueuePriority priority);
 
137
        enum QueuePriority GetPriority() const;
 
138
 
 
139
        wxString GetLocalFile() const { return m_localFile; }
 
140
        wxString GetRemoteFile() const { return m_remoteFile; }
 
141
        CServerPath GetRemotePath() const { return m_remotePath; }
 
142
        wxLongLong GetSize() const { return m_size; }
 
143
        void SetSize(wxLongLong size) { m_size = size; }
 
144
        bool Download() const { return m_download; }
 
145
        bool Queued() const { return m_queued; }
 
146
 
 
147
        wxString GetIndent() { return m_indent; }
 
148
 
 
149
        virtual enum QueueItemType GetType() const { return QueueItemType_File; }
 
150
 
 
151
        bool IsActive() const { return m_active; }
 
152
        virtual void SetActive(bool active);
 
153
        
 
154
        virtual void SaveItem(TiXmlElement* pElement) const;
 
155
 
 
156
        virtual bool TryRemoveAll(); // Removes a inactive childrens, queues active children for removal.
 
157
                                                                 // Returns true if item can be removed itself
 
158
 
 
159
        bool m_queued;
 
160
        int m_errorCount;
 
161
        bool m_remove;
 
162
        CEditHandler::fileType m_edit;
 
163
 
 
164
        wxString m_statusMessage;
 
165
 
 
166
        CFileTransferCommand::t_transferSettings m_transferSettings;
 
167
 
 
168
        t_EngineData* m_pEngineData;
 
169
 
 
170
        int m_defaultFileExistsAction;
 
171
 
 
172
        bool m_madeProgress;
 
173
        bool m_autoResume;
 
174
 
 
175
protected:
 
176
        enum QueuePriority m_priority;
 
177
 
 
178
        bool m_download;
 
179
        wxString m_localFile;
 
180
        wxString m_remoteFile;
 
181
        CServerPath m_remotePath;
 
182
        wxLongLong m_size;
 
183
        bool m_active;
 
184
};
 
185
 
 
186
class CFolderItem : public CFileItem
 
187
{
 
188
public:
 
189
        CFolderItem(CServerItem* parent, bool queued, const wxString& localFile);
 
190
        CFolderItem(CServerItem* parent, bool queued, const CServerPath& remotePath, const wxString& remoteFile);
 
191
        
 
192
        virtual enum QueueItemType GetType() const { return QueueItemType_Folder; }
 
193
 
 
194
        virtual void SaveItem(TiXmlElement* pElement) const;
 
195
 
 
196
        virtual void SetActive(bool active);
 
197
};
 
198
 
 
199
class CFolderScanItem : public CQueueItem
 
200
{
 
201
public:
 
202
        CFolderScanItem(CServerItem* parent, bool queued, bool download, const wxString& localPath, const CServerPath& remotePath);
 
203
        virtual ~CFolderScanItem() { }
 
204
 
 
205
        virtual enum QueueItemType GetType() const { return QueueItemType_FolderScan; }
 
206
        wxString GetLocalPath() const { return m_localPath; }
 
207
        CServerPath GetRemotePath() const { return m_remotePath; }
 
208
        bool Download() const { return m_download; }
 
209
        bool Queued() const { return m_queued; }
 
210
        int GetCount() const { return m_count; }
 
211
        virtual bool TryRemoveAll();
 
212
 
 
213
        wxString m_statusMessage;
 
214
 
 
215
        bool m_queued;
 
216
        volatile bool m_remove;
 
217
        bool m_active;
 
218
 
 
219
        int m_count;
 
220
 
 
221
        struct t_dirPair
 
222
        {
 
223
                wxString localPath;
 
224
                CServerPath remotePath;
 
225
        };
 
226
        std::list<t_dirPair> m_dirsToCheck;
 
227
 
 
228
        int m_defaultFileExistsAction;
 
229
 
 
230
protected:
 
231
        wxString m_localPath;
 
232
        CServerPath m_remotePath;
 
233
        bool m_download;
 
234
};
 
235
 
 
236
class CStatusItem : public CQueueItem
 
237
{
 
238
public:
 
239
        CStatusItem() {}
 
240
        virtual ~CStatusItem() {}
 
241
 
 
242
        virtual enum QueueItemType GetType() const { return QueueItemType_Status; }
 
243
};
 
244
 
 
245
class CQueue;
 
246
class CQueueViewBase : public wxListCtrlEx
 
247
{
 
248
public:
 
249
        CQueueViewBase(CQueue* parent, int index, const wxString& title);
 
250
        virtual ~CQueueViewBase();
 
251
 
 
252
        void CreateColumns(const wxString& lastColumnName = _T(""));
 
253
 
 
254
        // Gets item for given server or creates new if it doesn't exist
 
255
        CServerItem* CreateServerItem(const CServer& server);
 
256
 
 
257
        virtual void InsertItem(CServerItem* pServerItem, CQueueItem* pItem);
 
258
        virtual bool RemoveItem(CQueueItem* pItem, bool destroy, bool updateItemCount = true, bool updateSelections = true);
 
259
 
 
260
        // Has to be called after adding or removing items. Also updates
 
261
        // item count and selections.
 
262
        virtual void CommitChanges();
 
263
 
 
264
        wxString GetTitle() const { return m_title; }
 
265
 
 
266
protected:
 
267
 
 
268
        // Gets item for given server
 
269
        CServerItem* GetServerItem(const CServer& server);
 
270
 
 
271
        // Gets item with given index
 
272
        CQueueItem* GetQueueItem(unsigned int item);
 
273
 
 
274
        // Get index for given queue item
 
275
        int GetItemIndex(const CQueueItem* item);
 
276
 
 
277
        virtual wxString OnGetItemText(long item, long column) const;
 
278
        virtual int OnGetItemImage(long item) const;
 
279
 
 
280
        void RefreshItem(const CQueueItem* pItem);
 
281
 
 
282
        void DisplayNumberQueuedFiles();
 
283
 
 
284
        // Position at which insertions start and number of insertions
 
285
        int m_insertionStart;
 
286
        unsigned int m_insertionCount;
 
287
 
 
288
        int m_fileCount;
 
289
        int m_folderScanCount;
 
290
        bool m_fileCountChanged;
 
291
        bool m_folderScanCountChanged;
 
292
 
 
293
        // Selection management.
 
294
        void UpdateSelections_ItemAdded(int added);
 
295
        void UpdateSelections_ItemRangeAdded(int added, int count);
 
296
        void UpdateSelections_ItemRemoved(int removed);
 
297
        void UpdateSelections_ItemRangeRemoved(int removed, int count);
 
298
 
 
299
        int m_itemCount;
 
300
        bool m_allowBackgroundErase;
 
301
 
 
302
        std::vector<CServerItem*> m_serverList;
 
303
 
 
304
        CQueue* m_pQueue;
 
305
 
 
306
        const int m_pageIndex;
 
307
 
 
308
        const wxString m_title;
 
309
 
 
310
        DECLARE_EVENT_TABLE();
 
311
        void OnEraseBackground(wxEraseEvent& event);
 
312
        void OnNavigationKey(wxNavigationKeyEvent& event);
 
313
        void OnChar(wxKeyEvent& event);
 
314
        void OnEndColumnDrag(wxListEvent& event);
 
315
};
 
316
 
 
317
class CQueueView;
 
318
class CQueueViewFailed;
 
319
class CQueueViewSuccessful;
 
320
 
 
321
class CMainFrame;
 
322
class CAsyncRequestQueue;
 
323
class CQueue : public wxAuiNotebookEx
 
324
{
 
325
public:
 
326
        CQueue(wxWindow* parent, CMainFrame* pMainFrame, CAsyncRequestQueue* pAsyncRequestQueue);
 
327
        virtual ~CQueue() {}
 
328
 
 
329
        inline CQueueView* GetQueueView() { return m_pQueueView; }
 
330
        inline CQueueViewFailed* GetQueueView_Failed() { return m_pQueueView_Failed; }
 
331
        inline CQueueViewSuccessful* GetQueueView_Successful() { return m_pQueueView_Successful; }
 
332
 
 
333
        virtual void SetFocus();
 
334
protected:
 
335
 
 
336
        CQueueView* m_pQueueView;
 
337
        CQueueViewFailed* m_pQueueView_Failed;
 
338
        CQueueViewSuccessful* m_pQueueView_Successful;
 
339
};
 
340
 
 
341
#include "QueueView.h"
 
342
 
 
343
#endif //__QUEUE_H__