← Back to branch summary

~ubuntu-branches/ubuntu/saucy/filezilla/saucy-proposed

« back to all changes in this revision

Viewing changes to src/interface/queue.cpp

  • Committer: Package Import Robot
  • Author(s): Adrien Cunin
  • Date: 2012-12-07 17:17:17 UTC
  • mfrom: (1.1.31)
  • Revision ID: package-import@ubuntu.com-20121207171717-nt6as62u4pa1uv11
Tags: 3.6.0.2-1ubuntu1
* Merge from Debian experimental. Remaining Ubuntu change:
   - Added debian/patches/11_use-decimal-si-by-default.patch in order to
     comply with UnitsPolicy

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/interface/queue.cpp
7
7
#include "timeformatting.h"
8
8
#include "themeprovider.h"
9
9
 
10
 
CQueueItem::CQueueItem()
 
10
CQueueItem::CQueueItem(CQueueItem* parent)
 
11
        : m_parent(parent)
 
12
        , m_visibleOffspring(0)
 
13
        , m_indent(0)
 
14
        , m_maxCachedIndex(-1)
 
15
        , m_removed_at_front(0)
11
16
{
12
 
        m_visibleOffspring = 0;
13
 
        m_parent = 0;
14
 
        m_maxCachedIndex = -1;
15
 
 
16
 
        m_removed_at_front = 0;
17
 
        m_indent = 0;
18
17
}
19
18
 
20
19
CQueueItem::~CQueueItem()
21
20
{
22
21
        std::vector<CQueueItem*>::iterator iter;
23
 
        for (iter = m_children.begin() + m_removed_at_front; iter != m_children.end(); iter++)
 
22
        for (iter = m_children.begin() + m_removed_at_front; iter != m_children.end(); ++iter)
24
23
                delete *iter;
25
24
}
26
25
 
27
26
void CQueueItem::SetPriority(enum QueuePriority priority)
28
27
{
29
28
        std::vector<CQueueItem*>::iterator iter;
30
 
        for (iter = m_children.begin() + m_removed_at_front; iter != m_children.end(); iter++)
 
29
        for (iter = m_children.begin() + m_removed_at_front; iter != m_children.end(); ++iter)
31
30
                (*iter)->SetPriority(priority);
32
31
}
33
32
 
93
92
                child = m_lookupCache[m_maxCachedIndex].child + 1;
94
93
        }
95
94
 
96
 
        for (; iter != m_children.end(); iter++, child++)
 
95
        for (; iter != m_children.end(); ++iter, ++child)
97
96
        {
98
97
                if (!item)
99
98
                        return *iter;
132
131
        int oldVisibleOffspring = m_visibleOffspring;
133
132
        std::vector<CQueueItem*>::iterator iter;
134
133
        bool deleted = false;
135
 
        for (iter = m_children.begin() + m_removed_at_front; iter != m_children.end(); iter++)
 
134
        for (iter = m_children.begin() + m_removed_at_front; iter != m_children.end(); ++iter)
136
135
        {
137
136
                if (*iter == pItem)
138
137
                {
204
203
        std::vector<CQueueItem*>::iterator iter;
205
204
        std::vector<CQueueItem*> keepChildren;
206
205
        m_visibleOffspring = 0;
207
 
        for (iter = m_children.begin() + m_removed_at_front; iter != m_children.end(); iter++)
 
206
        for (iter = m_children.begin() + m_removed_at_front; iter != m_children.end(); ++iter)
208
207
        {
209
208
                CQueueItem* pItem = *iter;
210
209
                if (pItem->TryRemoveAll())
270
269
                return 0;
271
270
 
272
271
        int index = 1;
273
 
        for (std::vector<CQueueItem*>::const_iterator iter = pParent->m_children.begin() + pParent->m_removed_at_front; iter != pParent->m_children.end(); iter++)
 
272
        for (std::vector<CQueueItem*>::const_iterator iter = pParent->m_children.begin() + pParent->m_removed_at_front; iter != pParent->m_children.end(); ++iter)
274
273
        {
275
274
                if (*iter == this)
276
275
                        break;
282
281
}
283
282
 
284
283
const wxString& CQueueItem::GetIndent() const
285
 
{ 
 
284
{
286
285
        wxASSERT(m_indent < 5);
287
 
        static const wxString indents[5] = 
288
 
        { 
 
286
        static const wxString indents[5] =
 
287
        {
289
288
                _T(""),
290
289
                _T("  "),
291
290
                _T("    "),
298
297
CFileItem::CFileItem(CServerItem* parent, bool queued, bool download,
299
298
                                         const wxString& sourceFile, const wxString& targetFile,
300
299
                                         const CLocalPath& localPath, const CServerPath& remotePath, wxLongLong size)
301
 
        : m_sourceFile(sourceFile), m_targetFile(targetFile)
302
 
        , m_localPath(localPath), m_remotePath(remotePath)
 
300
        : CQueueItem(parent)
 
301
        , m_errorCount(0)
 
302
        , m_edit(CEditHandler::none)
 
303
        , m_pEngineData(0)
 
304
        , m_defaultFileExistsAction(CFileExistsNotification::unknown)
 
305
        , m_onetime_action(CFileExistsNotification::unknown)
 
306
        , flags(0)
 
307
        , m_priority(priority_normal)
 
308
        , m_sourceFile(sourceFile)
 
309
        , m_targetFile(targetFile)
 
310
        , m_localPath(localPath)
 
311
        , m_remotePath(remotePath)
303
312
        , m_size(size)
304
313
{
305
 
        m_parent = parent;
306
 
        m_priority = priority_normal;
307
 
 
308
 
        flags = 0;
309
314
        if (download)
310
315
                flags |= flag_download;
311
316
        if (queued)
312
317
                flags |= flag_queued;
313
 
        m_errorCount = 0;
314
 
        m_pEngineData = 0;
315
 
        m_defaultFileExistsAction = CFileExistsNotification::unknown;
316
 
        m_edit = CEditHandler::none;
317
 
        m_onetime_action = CFileExistsNotification::unknown;
318
318
}
319
319
 
320
320
CFileItem::~CFileItem()
431
431
}
432
432
 
433
433
CServerItem::CServerItem(const CServer& server)
 
434
        : m_activeCount(0)
 
435
        , m_server(server)
434
436
{
435
 
        m_server = server;
436
 
        m_activeCount = 0;
437
437
}
438
438
 
439
439
CServerItem::~CServerItem()
469
469
void CServerItem::RemoveFileItemFromList(CFileItem* pItem)
470
470
{
471
471
        std::list<CFileItem*>& fileList = m_fileList[pItem->queued() ? 0 : 1][pItem->GetPriority()];
472
 
        for (std::list<CFileItem*>::iterator iter = fileList.begin(); iter != fileList.end(); iter++)
 
472
        for (std::list<CFileItem*>::iterator iter = fileList.begin(); iter != fileList.end(); ++iter)
473
473
        {
474
474
                if (*iter == pItem)
475
475
                {
482
482
 
483
483
void CServerItem::SetDefaultFileExistsAction(enum CFileExistsNotification::OverwriteAction action, const enum TransferDirection direction)
484
484
{
485
 
        for (std::vector<CQueueItem*>::iterator iter = m_children.begin() + m_removed_at_front; iter != m_children.end(); iter++)
 
485
        for (std::vector<CQueueItem*>::iterator iter = m_children.begin() + m_removed_at_front; iter != m_children.end(); ++iter)
486
486
        {
487
487
                CQueueItem *pItem = *iter;
488
488
                if (pItem->GetType() == QueueItemType_File)
509
509
        for (i = (PRIORITY_COUNT - 1); i >= 0; i--)
510
510
        {
511
511
                std::list<CFileItem*>& fileList = m_fileList[1][i];
512
 
                for (std::list<CFileItem*>::iterator iter = fileList.begin(); iter != fileList.end(); iter++)
 
512
                for (std::list<CFileItem*>::iterator iter = fileList.begin(); iter != fileList.end(); ++iter)
513
513
                {
514
514
                        CFileItem* item = *iter;
515
515
                        if (item->IsActive())
533
533
        for (i = (PRIORITY_COUNT - 1); i >= 0; i--)
534
534
        {
535
535
                std::list<CFileItem*>& fileList = m_fileList[0][i];
536
 
                for (std::list<CFileItem*>::iterator iter = fileList.begin(); iter != fileList.end(); iter++)
 
536
                for (std::list<CFileItem*>::iterator iter = fileList.begin(); iter != fileList.end(); ++iter)
537
537
                {
538
538
                        CFileItem* item = *iter;
539
539
                        if (item->IsActive())
575
575
        {
576
576
                std::list<CFileItem*> activeList;
577
577
                std::list<CFileItem*>& fileList = m_fileList[1][i];
578
 
                for (std::list<CFileItem*>::reverse_iterator iter = fileList.rbegin(); iter != fileList.rend(); iter++)
 
578
                for (std::list<CFileItem*>::reverse_iterator iter = fileList.rbegin(); iter != fileList.rend(); ++iter)
579
579
                {
580
580
                        CFileItem* item = *iter;
581
581
                        wxASSERT(!item->queued());
597
597
                return;
598
598
 
599
599
        std::list<CFileItem*>& fileList = m_fileList[1][pItem->GetPriority()];
600
 
        for (std::list<CFileItem*>::iterator iter = fileList.begin(); iter != fileList.end(); iter++)
 
600
        for (std::list<CFileItem*>::iterator iter = fileList.begin(); iter != fileList.end(); ++iter)
601
601
        {
602
602
                if (*iter != pItem)
603
603
                        continue;
615
615
        TiXmlElement *server = new TiXmlElement("Server");
616
616
        SetServer(server, m_server);
617
617
 
618
 
        for (std::vector<CQueueItem*>::const_iterator iter = m_children.begin() + m_removed_at_front; iter != m_children.end(); iter++)
 
618
        for (std::vector<CQueueItem*>::const_iterator iter = m_children.begin() + m_removed_at_front; iter != m_children.end(); ++iter)
619
619
                (*iter)->SaveItem(server);
620
620
 
621
621
        pElement->LinkEndChild(server);
629
629
                for (int j = 0; j < 2; j++)
630
630
                {
631
631
                        const std::list<CFileItem*>& fileList = m_fileList[j][i];
632
 
                        for (std::list<CFileItem*>::const_iterator iter = fileList.begin(); iter != fileList.end(); iter++)
 
632
                        for (std::list<CFileItem*>::const_iterator iter = fileList.begin(); iter != fileList.end(); ++iter)
633
633
                        {
634
634
                                const CFileItem* item = *iter;
635
635
                                wxLongLong size = item->GetSize();
641
641
                }
642
642
        }
643
643
 
644
 
        for (std::vector<CQueueItem*>::const_iterator iter = m_children.begin() + m_removed_at_front; iter != m_children.end(); iter++)
 
644
        for (std::vector<CQueueItem*>::const_iterator iter = m_children.begin() + m_removed_at_front; iter != m_children.end(); ++iter)
645
645
        {
646
646
                if ((*iter)->GetType() == QueueItemType_File ||
647
647
                        (*iter)->GetType() == QueueItemType_Folder)
659
659
        std::vector<CQueueItem*>::iterator iter;
660
660
        std::vector<CQueueItem*> keepChildren;
661
661
        m_visibleOffspring = 0;
662
 
        for (iter = m_children.begin() + m_removed_at_front; iter != m_children.end(); iter++)
 
662
        for (iter = m_children.begin() + m_removed_at_front; iter != m_children.end(); ++iter)
663
663
        {
664
664
                CQueueItem* pItem = *iter;
665
665
                if (pItem->TryRemoveAll())
708
708
void CServerItem::SetPriority(enum QueuePriority priority)
709
709
{
710
710
        std::vector<CQueueItem*>::iterator iter;
711
 
        for (iter = m_children.begin() + m_removed_at_front; iter != m_children.end(); iter++)
 
711
        for (iter = m_children.begin() + m_removed_at_front; iter != m_children.end(); ++iter)
712
712
        {
713
713
                if ((*iter)->GetType() == QueueItemType_File)
714
714
                        ((CFileItem*)(*iter))->SetPriorityRaw(priority);
726
726
{
727
727
        int i = pItem->queued() ? 0 : 1;
728
728
 
729
 
        for (std::list<CFileItem*>::iterator iter = m_fileList[i][oldPriority].begin(); iter != m_fileList[i][oldPriority].end(); iter++)
 
729
        for (std::list<CFileItem*>::iterator iter = m_fileList[i][oldPriority].begin(); iter != m_fileList[i][oldPriority].end(); ++iter)
730
730
        {
731
731
                if (*iter != pItem)
732
732
                        continue;
740
740
}
741
741
 
742
742
CFolderScanItem::CFolderScanItem(CServerItem* parent, bool queued, bool download, const CLocalPath& localPath, const CServerPath& remotePath)
 
743
        : CQueueItem(parent)
 
744
        , m_remove(false)
 
745
        , m_active(false)
 
746
        , m_count(0)
 
747
        , m_defaultFileExistsAction(CFileExistsNotification::unknown)
 
748
        , m_dir_is_empty(false)
 
749
        , m_queued(queued)
 
750
        , m_localPath(localPath)
 
751
        , m_remotePath(remotePath)
 
752
        , m_download(download)
743
753
{
744
 
        m_parent = parent;
745
 
 
746
 
        m_download = download;
747
 
        m_localPath = localPath;
748
 
        m_remotePath = remotePath;
749
 
        m_queued = queued;
750
 
        m_remove = false;
751
 
        m_active = false;
752
 
        m_count = 0;
753
 
        m_dir_is_empty = false;
754
 
 
755
 
        m_defaultFileExistsAction = CFileExistsNotification::unknown;
756
754
}
757
755
 
758
756
bool CFolderScanItem::TryRemoveAll()
778
776
END_EVENT_TABLE()
779
777
 
780
778
CQueueViewBase::CQueueViewBase(CQueue* parent, int index, const wxString& title)
781
 
        : wxListCtrlEx(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxCLIP_CHILDREN | wxLC_REPORT | wxLC_VIRTUAL | wxSUNKEN_BORDER | wxTAB_TRAVERSAL),
782
 
          m_pageIndex(index), m_title(title)
 
779
        : wxListCtrlEx(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxCLIP_CHILDREN | wxLC_REPORT | wxLC_VIRTUAL | wxSUNKEN_BORDER | wxTAB_TRAVERSAL)
 
780
        , m_pageIndex(index)
 
781
        , m_title(title)
783
782
{
784
783
        m_pQueue = parent;
785
784
        m_insertionStart = -1;
808
807
 
809
808
CQueueViewBase::~CQueueViewBase()
810
809
{
811
 
        for (std::vector<CServerItem*>::iterator iter = m_serverList.begin(); iter != m_serverList.end(); iter++)
 
810
        for (std::vector<CServerItem*>::iterator iter = m_serverList.begin(); iter != m_serverList.end(); ++iter)
812
811
                delete *iter;
813
812
}
814
813
 
815
814
CQueueItem* CQueueViewBase::GetQueueItem(unsigned int item)
816
815
{
817
816
        std::vector<CServerItem*>::iterator iter;
818
 
        for (iter = m_serverList.begin(); iter != m_serverList.end(); iter++)
 
817
        for (iter = m_serverList.begin(); iter != m_serverList.end(); ++iter)
819
818
        {
820
819
                if (!item)
821
820
                        return *iter;
837
836
        const CQueueItem* pTopLevelItem = item->GetTopLevelItem();
838
837
 
839
838
        int index = 0;
840
 
        for (std::vector<CServerItem*>::const_iterator iter = m_serverList.begin(); iter != m_serverList.end(); iter++)
 
839
        for (std::vector<CServerItem*>::const_iterator iter = m_serverList.begin(); iter != m_serverList.end(); ++iter)
841
840
        {
842
841
                if (pTopLevelItem == *iter)
843
842
                        break;
1131
1130
 
1132
1131
                item = GetNextItem(item, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
1133
1132
        }
1134
 
        for (std::list<int>::const_iterator iter = itemsToSelect.begin(); iter != itemsToSelect.end(); iter++)
 
1133
        for (std::list<int>::const_iterator iter = itemsToSelect.begin(); iter != itemsToSelect.end(); ++iter)
1135
1134
                SetItemState(*iter, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
1136
1135
}
1137
1136
 
1212
1211
 
1213
1212
                item = GetNextItem(item, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
1214
1213
        }
1215
 
        for (std::list<int>::const_iterator iter = itemsToUnselect.begin(); iter != itemsToUnselect.end(); iter++)
 
1214
        for (std::list<int>::const_iterator iter = itemsToUnselect.begin(); iter != itemsToUnselect.end(); ++iter)
1216
1215
                SetItemState(*iter, 0, wxLIST_STATE_SELECTED);
1217
1216
}
1218
1217
 
1242
1241
 
1243
1242
CServerItem* CQueueViewBase::GetServerItem(const CServer& server)
1244
1243
{
1245
 
        for (std::vector<CServerItem*>::iterator iter = m_serverList.begin(); iter != m_serverList.end(); iter++)
 
1244
        for (std::vector<CServerItem*>::iterator iter = m_serverList.begin(); iter != m_serverList.end(); ++iter)
1246
1245
        {
1247
1246
                if ((*iter)->GetServer() == server)
1248
1247
                        return *iter;
1375
1374
        if (!topLevelItem->GetChild(0))
1376
1375
        {
1377
1376
                std::vector<CServerItem*>::iterator iter;
1378
 
                for (iter = m_serverList.begin(); iter != m_serverList.end(); iter++)
 
1377
                for (iter = m_serverList.begin(); iter != m_serverList.end(); ++iter)
1379
1378
                {
1380
1379
                        if (*iter == topLevelItem)
1381
1380
                                break;