source: filezilla/trunk/fuentes/src/interface/queue.h @ 3185

Last change on this file since 3185 was 3185, checked in by jrpelegrina, 3 years ago

Update new version: 3.15.02

File size: 11.9 KB
Line 
1#ifndef __QUEUE_H__
2#define __QUEUE_H__
3
4#include "aui_notebook_ex.h"
5#include "listctrlex.h"
6#include "edithandler.h"
7#include "optional.h"
8
9enum class QueuePriority : char {
10        lowest,
11        low,
12        normal,
13        high,
14        highest,
15
16        count
17};
18
19enum class QueueItemType {
20        Server,
21        File,
22        Folder,
23        FolderScan,
24        Status
25};
26
27enum class TransferDirection
28{
29        both,
30        download,
31        upload
32};
33
34namespace pugi { class xml_node; }
35class CQueueItem
36{
37public:
38        virtual ~CQueueItem();
39
40        virtual void SetPriority(QueuePriority priority);
41
42        virtual void AddChild(CQueueItem* pItem);
43        virtual unsigned int GetChildrenCount(bool recursive) const;
44        virtual 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
49        virtual bool RemoveChild(CQueueItem* pItem, bool destroy = true, bool forward = true); // Removes a child item with is somewhere in the tree of children.
50        virtual bool TryRemoveAll() = 0; // Removes a inactive childrens, queues active children for removal. Returns true if item itself can be removed
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(pugi::xml_node&) const {}
55
56        virtual QueueItemType GetType() const = 0;
57
58        fz::datetime GetTime() const { return m_time; }
59        void UpdateTime() { m_time = fz::datetime::now(); }
60
61        int GetRemovedAtFront() const { return m_removed_at_front; }
62
63protected:
64        CQueueItem(CQueueItem* parent = 0);
65
66        CQueueItem* m_parent;
67
68        friend class CServerItem;
69
70        fz::datetime m_time;
71
72private:
73        std::vector<CQueueItem*> m_children;
74
75        // Number of items removed at front of list
76        // Increased instead of calling slow m_children.erase(0),
77        // resetted on insert.
78        int m_removed_at_front{};
79};
80
81class CFileItem;
82class CServerItem : public CQueueItem
83{
84public:
85        CServerItem(const CServer& server);
86        virtual ~CServerItem();
87        virtual QueueItemType GetType() const { return QueueItemType::Server; }
88
89        const CServer& GetServer() const;
90        wxString GetName() const;
91
92        virtual void AddChild(CQueueItem* pItem);
93        virtual unsigned int GetChildrenCount(bool recursive) const;
94        virtual CQueueItem* GetChild(unsigned int item, bool recursive = true);
95
96        CFileItem* GetIdleChild(bool immadiateOnly, TransferDirection direction);
97
98        virtual bool RemoveChild(CQueueItem* pItem, bool destroy = true, bool forward = true); // Removes a child item with is somewhere in the tree of children
99        virtual bool TryRemoveAll();
100
101        int64_t GetTotalSize(int& filesWithUnknownSize, int& queuedFiles, int& folderScanCount) const;
102
103        void QueueImmediateFiles();
104        void QueueImmediateFile(CFileItem* pItem);
105
106        virtual void SaveItem(pugi::xml_node& element) const;
107
108        void SetDefaultFileExistsAction(CFileExistsNotification::OverwriteAction action, const TransferDirection direction);
109
110        void DetachChildren();
111
112        virtual void SetPriority(QueuePriority priority);
113
114        void SetChildPriority(CFileItem* pItem, QueuePriority oldPriority, QueuePriority newPriority);
115
116        int m_activeCount;
117
118        const std::vector<CQueueItem*>& GetChildren() const { return m_children; }
119
120protected:
121        void AddFileItemToList(CFileItem* pItem);
122        void RemoveFileItemFromList(CFileItem* pItem, bool forward);
123
124        CServer m_server;
125
126        // array of item lists, sorted by priority. Used by scheduler to find
127        // next file to transfer
128        // First index specifies whether the item is queued (0) or immediate (1)
129        std::deque<CFileItem*> m_fileList[2][static_cast<int>(QueuePriority::count)];
130
131        friend class CQueueItem;
132
133        int m_visibleOffspring{}; // Visible offspring over all sublevels
134        int m_maxCachedIndex{-1};
135
136        struct t_cacheItem
137        {
138                int index;
139                int child;
140        };
141        std::vector<t_cacheItem> m_lookupCache;
142};
143
144struct t_EngineData;
145
146class CFileItem : public CQueueItem
147{
148public:
149        CFileItem(CServerItem* parent, bool queued, bool download,
150                const wxString& sourceFile, const wxString& targetFile,
151                const CLocalPath& localPath, const CServerPath& remotePath, int64_t size);
152
153        virtual ~CFileItem();
154
155        virtual void SetPriority(QueuePriority priority);
156        void SetPriorityRaw(QueuePriority priority);
157        QueuePriority GetPriority() const;
158
159        std::wstring const& GetLocalFile() const { return !Download() ? GetSourceFile() : (m_targetFile ? *m_targetFile : m_sourceFile); }
160        std::wstring const& GetRemoteFile() const { return Download() ? GetSourceFile() : (m_targetFile ? *m_targetFile : m_sourceFile); }
161        std::wstring const& GetSourceFile() const { return m_sourceFile; }
162        CSparseOptional<std::wstring> const& GetTargetFile() const { return m_targetFile; }
163        CLocalPath const& GetLocalPath() const { return m_localPath; }
164        CServerPath const& GetRemotePath() const { return m_remotePath; }
165        int64_t GetSize() const { return m_size; }
166        void SetSize(int64_t size) { m_size = size; }
167        inline bool Download() const { return flags & flag_download; }
168
169        inline bool queued() const { return (flags & flag_queued) != 0; }
170        inline void set_queued(bool q)
171        {
172                if (q)
173                        flags |= flag_queued;
174                else
175                        flags &= ~flag_queued;
176        }
177
178        inline bool pending_remove() const { return (flags & flag_remove) != 0; }
179        inline void set_pending_remove(bool remove)
180        {
181                if (remove)
182                        flags |= flag_remove;
183                else
184                        flags &= ~flag_remove;
185        }
186
187        virtual QueueItemType GetType() const { return QueueItemType::File; }
188
189        bool IsActive() const { return (flags & flag_active) != 0; }
190        virtual void SetActive(bool active);
191
192        virtual void SaveItem(pugi::xml_node& element) const;
193
194        virtual bool TryRemoveAll(); // Removes inactive children, queues active children for removal.
195                                                                 // Returns true if item can be removed itself
196
197        void SetTargetFile(wxString const& file);
198
199        enum Status : char {
200                none,
201                incorrect_password,
202                timeout,
203                disconnecting,
204                disconnected,
205                connecting,
206                connection_failed,
207                interrupted,
208                wait_browsing,
209                wait_password,
210                local_file_unwriteable,
211                could_not_start,
212                transferring,
213                creating_dir
214        };
215
216        wxString const& GetStatusMessage() const;
217        void SetStatusMessage(Status status);
218
219        unsigned char m_errorCount{};
220        CEditHandler::fileType m_edit{CEditHandler::none};
221        CFileExistsNotification::OverwriteAction m_defaultFileExistsAction{CFileExistsNotification::unknown};
222        CFileExistsNotification::OverwriteAction m_onetime_action{CFileExistsNotification::unknown};
223        QueuePriority m_priority{QueuePriority::normal};
224
225protected:
226        enum : unsigned char
227        {
228                flag_download = 0x01,
229                flag_active = 0x02,
230                flag_made_progress = 0x04,
231                flag_queued = 0x08,
232                flag_remove = 0x10,
233                flag_ascii = 0x20
234        };
235        unsigned char flags{};
236        Status m_status{};
237
238public:
239        t_EngineData* m_pEngineData{};
240
241
242        inline bool made_progress() const { return (flags & flag_made_progress) != 0; }
243        inline void set_made_progress(bool made_progress)
244        {
245                if (made_progress)
246                        flags |= flag_made_progress;
247                else
248                        flags &= ~flag_made_progress;
249        }
250
251        bool Ascii() const { return (flags & flag_ascii) != 0; }
252
253        void SetAscii(bool ascii)
254        {
255                if (ascii) {
256                        flags |= flag_ascii;
257                }
258                else {
259                        flags &= ~flag_ascii;
260                }
261        }
262
263protected:
264        std::wstring const m_sourceFile;
265        CSparseOptional<std::wstring> m_targetFile;
266        CLocalPath const m_localPath;
267        CServerPath const m_remotePath;
268        int64_t m_size{};
269};
270
271class CFolderItem : public CFileItem
272{
273public:
274        CFolderItem(CServerItem* parent, bool queued, const CLocalPath& localPath);
275        CFolderItem(CServerItem* parent, bool queued, const CServerPath& remotePath, const wxString& remoteFile);
276
277        virtual QueueItemType GetType() const { return QueueItemType::Folder; }
278
279        virtual void SaveItem(pugi::xml_node& element) const;
280
281        virtual void SetActive(bool active);
282
283        virtual bool TryRemoveAll() { return true; }
284};
285
286class CFolderScanItem : public CQueueItem
287{
288public:
289        CFolderScanItem(CServerItem* parent, bool queued, bool download, const CLocalPath& localPath, const CServerPath& remotePath);
290        virtual ~CFolderScanItem() {}
291
292        virtual QueueItemType GetType() const { return QueueItemType::FolderScan; }
293        CLocalPath GetLocalPath() const { return m_localPath; }
294        CServerPath GetRemotePath() const { return m_remotePath; }
295        bool Download() const { return m_download; }
296        int GetCount() const { return m_count; }
297        virtual bool TryRemoveAll();
298
299        bool queued() const { return m_queued; }
300        void set_queued(bool q) { m_queued = q; }
301
302        wxString m_statusMessage;
303
304        volatile bool m_remove{};
305        bool m_active{};
306
307        int m_count{};
308
309        CFileExistsNotification::OverwriteAction m_defaultFileExistsAction{CFileExistsNotification::unknown};
310
311        bool m_dir_is_empty{};
312        CLocalPath m_current_local_path;
313        CServerPath m_current_remote_path;
314
315protected:
316        bool m_queued;
317        CLocalPath m_localPath;
318        CServerPath m_remotePath;
319        bool m_download;
320};
321
322class CStatusItem : public CQueueItem
323{
324public:
325        CStatusItem() {}
326        virtual ~CStatusItem() {}
327
328        virtual QueueItemType GetType() const { return QueueItemType::Status; }
329
330        virtual bool TryRemoveAll() { return true; }
331};
332
333class CQueue;
334class CQueueViewBase : public wxListCtrlEx
335{
336public:
337
338        enum ColumnId
339        {
340                colLocalName,
341                colDirection,
342                colRemoteName,
343                colSize,
344                colPriority,
345                colTime,
346                colTransferStatus,
347                colErrorReason
348        };
349
350        CQueueViewBase(CQueue* parent, int index, const wxString& title);
351        virtual ~CQueueViewBase();
352
353        // Gets item for given server or creates new if it doesn't exist
354        CServerItem* CreateServerItem(const CServer& server);
355
356        virtual void InsertItem(CServerItem* pServerItem, CQueueItem* pItem);
357        virtual bool RemoveItem(CQueueItem* pItem, bool destroy, bool updateItemCount = true, bool updateSelections = true, bool forward = true);
358
359        // Has to be called after adding or removing items. Also updates
360        // item count and selections.
361        virtual void CommitChanges();
362
363        wxString GetTitle() const { return m_title; }
364
365        int GetFileCount() const { return m_fileCount; }
366
367        void WriteToFile(pugi::xml_node element) const;
368
369protected:
370
371        void CreateColumns(std::list<ColumnId> const& extraColumns = std::list<ColumnId>());
372        void AddQueueColumn(ColumnId id);
373
374        // Gets item for given server
375        CServerItem* GetServerItem(const CServer& server);
376
377        // Gets item with given index
378        CQueueItem* GetQueueItem(unsigned int item) const;
379
380        // Get index for given queue item
381        int GetItemIndex(const CQueueItem* item);
382
383        virtual wxString OnGetItemText(long item, long column) const;
384        virtual wxString OnGetItemText(CQueueItem* pItem, ColumnId column) const;
385        virtual int OnGetItemImage(long item) const;
386
387        void RefreshItem(const CQueueItem* pItem);
388
389        void DisplayNumberQueuedFiles();
390
391        // Position at which insertions start and number of insertions
392        int m_insertionStart;
393        unsigned int m_insertionCount;
394
395        int m_fileCount;
396        int m_folderScanCount;
397        bool m_fileCountChanged;
398        bool m_folderScanCountChanged;
399
400        // Selection management.
401        void UpdateSelections_ItemAdded(int added);
402        void UpdateSelections_ItemRangeAdded(int added, int count);
403        void UpdateSelections_ItemRemoved(int removed);
404        void UpdateSelections_ItemRangeRemoved(int removed, int count);
405
406        int m_itemCount;
407        bool m_allowBackgroundErase;
408
409        std::vector<CServerItem*> m_serverList;
410
411        CQueue* m_pQueue;
412
413        const int m_pageIndex;
414
415        const wxString m_title;
416
417        wxTimer m_filecount_delay_timer;
418
419        std::vector<ColumnId> m_columns;
420
421        DECLARE_EVENT_TABLE()
422        void OnEraseBackground(wxEraseEvent& event);
423        void OnChar(wxKeyEvent& event);
424        void OnEndColumnDrag(wxListEvent& event);
425        void OnTimer(wxTimerEvent& event);
426        void OnKeyDown(wxKeyEvent& event);
427        void OnExport(wxCommandEvent&);
428};
429
430class CQueueView;
431class CQueueViewFailed;
432class CQueueViewSuccessful;
433
434class CMainFrame;
435class CAsyncRequestQueue;
436class CQueue : public wxAuiNotebookEx
437{
438public:
439        CQueue(wxWindow* parent, CMainFrame* pMainFrame, CAsyncRequestQueue* pAsyncRequestQueue);
440        virtual ~CQueue() {}
441
442        inline CQueueView* GetQueueView() { return m_pQueueView; }
443        inline CQueueViewFailed* GetQueueView_Failed() { return m_pQueueView_Failed; }
444        inline CQueueViewSuccessful* GetQueueView_Successful() { return m_pQueueView_Successful; }
445
446        virtual void SetFocus();
447protected:
448
449        CQueueView* m_pQueueView;
450        CQueueViewFailed* m_pQueueView_Failed;
451        CQueueViewSuccessful* m_pQueueView_Successful;
452};
453
454#include "QueueView.h"
455
456#endif //__QUEUE_H__
Note: See TracBrowser for help on using the repository browser.