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
|
// **************************************************************************
// * This file is part of the FreeFileSync project. It is distributed under *
// * GNU General Public License: http://www.gnu.org/licenses/gpl.html *
// * Copyright (C) Zenju (zenju AT gmx DOT de) - All Rights Reserved *
// **************************************************************************
#ifndef GRIDVIEW_H_INCLUDED
#define GRIDVIEW_H_INCLUDED
#include <set>
#include "column_attr.h"
#include "../file_hierarchy.h"
namespace zen
{
//grid view of FolderComparison
class GridView
{
public:
GridView() : folderPairCount(0) {}
//direct data access via row number
const FileSystemObject* getObject(size_t row) const; //returns nullptr if object is not found; complexity: constant!
/**/
FileSystemObject* getObject(size_t row); //
size_t rowsOnView() const { return viewRef .size(); } //only visible elements
size_t rowsTotal () const { return sortedRef.size(); } //total rows available
//get references to FileSystemObject: no nullptr-check needed! Everything's bound.
std::vector<FileSystemObject*> getAllFileRef(const std::set<size_t>& rows);
struct StatusCmpResult
{
StatusCmpResult();
bool existsLeftOnly;
bool existsRightOnly;
bool existsLeftNewer;
bool existsRightNewer;
bool existsDifferent;
bool existsEqual;
bool existsConflict;
unsigned int filesOnLeftView;
unsigned int foldersOnLeftView;
unsigned int filesOnRightView;
unsigned int foldersOnRightView;
zen::UInt64 filesizeLeftView;
zen::UInt64 filesizeRightView;
};
//comparison results view
StatusCmpResult updateCmpResult(bool hideFiltered,
bool leftOnlyFilesActive,
bool rightOnlyFilesActive,
bool leftNewerFilesActive,
bool rightNewerFilesActive,
bool differentFilesActive,
bool equalFilesActive,
bool conflictFilesActive);
struct StatusSyncPreview
{
StatusSyncPreview();
bool existsSyncCreateLeft;
bool existsSyncCreateRight;
bool existsSyncDeleteLeft;
bool existsSyncDeleteRight;
bool existsSyncDirLeft;
bool existsSyncDirRight;
bool existsSyncDirNone;
bool existsSyncEqual;
bool existsConflict;
unsigned int filesOnLeftView;
unsigned int foldersOnLeftView;
unsigned int filesOnRightView;
unsigned int foldersOnRightView;
zen::UInt64 filesizeLeftView;
zen::UInt64 filesizeRightView;
};
//synchronization preview
StatusSyncPreview updateSyncPreview(bool hideFiltered,
bool syncCreateLeftActive,
bool syncCreateRightActive,
bool syncDeleteLeftActive,
bool syncDeleteRightActive,
bool syncDirOverwLeftActive,
bool syncDirOverwRightActive,
bool syncDirNoneActive,
bool syncEqualActive,
bool conflictFilesActive);
void setData(FolderComparison& newData);
void removeInvalidRows(); //remove rows that have been deleted meanwhile: call after manual deletion and synchronization!
//sorting...
bool static getDefaultSortDirection(zen::ColumnTypeRim type); //true: ascending; false: descending
void sortView(zen::ColumnTypeRim type, bool onLeft, bool ascending); //always call this method for sorting, never sort externally!
struct SortInfo
{
SortInfo(zen::ColumnTypeRim type, bool onLeft, bool ascending) : type_(type), onLeft_(onLeft), ascending_(ascending) {}
zen::ColumnTypeRim type_;
bool onLeft_;
bool ascending_;
};
const SortInfo* getSortInfo() const { return currentSort.get(); } //return nullptr if currently not sorted
ptrdiff_t findRowDirect(FileSystemObject::ObjectIdConst objId) const; // find an object's row position on view list directly, return < 0 if not found
ptrdiff_t findRowFirstChild(const HierarchyObject* hierObj) const; // find first child of DirMapping or BaseDirMapping *on sorted sub view*
//"hierObj" may be invalid, it is NOT dereferenced, return < 0 if not found
size_t getFolderPairCount() const { return folderPairCount; } //count non-empty pairs to distinguish single/multiple folder pair cases
private:
struct RefIndex
{
RefIndex(size_t folderInd, FileSystemObject::ObjectId id) :
folderIndex(static_cast<unsigned int>(folderInd)),
objId(id) {}
unsigned int folderIndex;
FileSystemObject::ObjectId objId;
};
template <class Predicate> void updateView(Predicate pred);
zen::hash_map<FileSystemObject::ObjectIdConst, size_t> rowPositions; //find row positions on sortedRef directly
zen::hash_map<const void*, size_t> rowPositionsFirstChild; //find first child on sortedRef of a hierarchy object
//void* instead of HierarchyObject*: these are weak pointers and should *never be dereferenced*!
std::vector<FileSystemObject::ObjectId> viewRef; //partial view on sortedRef
/* /|\
| (update...)
| */
std::vector<RefIndex> sortedRef; //flat view of weak pointers on folderCmp; may be sorted
/* /|\
| (setData...)
| */
//std::shared_ptr<FolderComparison> folderCmp; //actual comparison data: owned by GridView!
size_t folderPairCount; //number of non-empty folder pairs
class SerializeHierarchy;
//sorting classes
template <bool ascending>
class LessRelativeName;
template <bool ascending, SelectedSide side>
class LessShortFileName;
template <bool ascending, SelectedSide side>
class LessFilesize;
template <bool ascending, SelectedSide side>
class LessFiletime;
template <bool ascending, SelectedSide side>
class LessExtension;
template <bool ascending>
class LessCmpResult;
template <bool ascending>
class LessSyncDirection;
std::unique_ptr<SortInfo> currentSort;
};
//##################### implementation #########################################
inline
const FileSystemObject* GridView::getObject(size_t row) const
{
return row < viewRef.size() ?
FileSystemObject::retrieve(viewRef[row]) : nullptr;
}
inline
FileSystemObject* GridView::getObject(size_t row)
{
//code re-use of const method: see Meyers Effective C++
return const_cast<FileSystemObject*>(static_cast<const GridView&>(*this).getObject(row));
}
}
#endif // GRIDVIEW_H_INCLUDED
|
