summaryrefslogtreecommitdiff
path: root/FreeFileSync.h
blob: 92d90189a5695e7e62cc49c0241667b2a633910f (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
#ifndef FREEFILESYNC_H_INCLUDED
#define FREEFILESYNC_H_INCLUDED

#include <wx/string.h>
#include <set>
#include <vector>
#include "library/statusHandler.h"
#include "library/fileHandling.h"


namespace FreeFileSync
{
    enum CompareVariant
    {
        CMP_BY_CONTENT,
        CMP_BY_TIME_SIZE
    };


    struct SyncConfiguration
    {
        SyncConfiguration() :
                exLeftSideOnly(SYNC_DIR_RIGHT),
                exRightSideOnly(SYNC_DIR_RIGHT),
                leftNewer(SYNC_DIR_RIGHT),
                rightNewer(SYNC_DIR_RIGHT),
                different(SYNC_DIR_RIGHT) {}

        enum Direction
        {
            SYNC_DIR_LEFT,
            SYNC_DIR_RIGHT,
            SYNC_DIR_NONE
        };

        Direction exLeftSideOnly;
        Direction exRightSideOnly;
        Direction leftNewer;
        Direction rightNewer;
        Direction different;
    };


    struct MainConfiguration
    {
        MainConfiguration() :
                compareVar(CMP_BY_TIME_SIZE),
                filterIsActive(false),        //do not filter by default
                includeFilter(wxT("*")),      //include all files/folders
                excludeFilter(wxEmptyString), //exclude nothing
                useRecycleBin(FreeFileSync::recycleBinExists()), //enable if OS supports it; else user will have to activate first and then get an error message
                ignoreErrors(false) {}

        //Compare setting
        CompareVariant compareVar;

        //Synchronisation settings
        SyncConfiguration syncConfiguration;

        //Filter setting
        bool filterIsActive;
        wxString includeFilter;
        wxString excludeFilter;


        //misc options
        bool useRecycleBin; //use Recycle bin when deleting or overwriting files while synchronizing
        bool ignoreErrors;  //hides error messages during synchronization
    };


    struct FileDescrLine
    {
        FileDescrLine() : objType(TYPE_NOTHING) {}

        enum ObjectType
        {
            TYPE_NOTHING,
            TYPE_DIRECTORY,
            TYPE_FILE
        };

        wxString fullName;  // == directory + relativeName
        wxString directory; //directory to be synced + separator
        wxString relativeName; //fullName without directory that is being synchronized
        //Note on performance: Keep redundant information "directory" and "relativeName"!
        //Extracting info from "fullName" instead would result in noticeable performance loss, with only limited memory reduction (note ref. counting strings)!
        wxString lastWriteTime;
        wxULongLong lastWriteTimeRaw;
        wxULongLong fileSize;
        ObjectType objType; //is it a file or directory or initial?

        //the following operators are needed by template class "set"
        //DO NOT CHANGE THESE RELATIONS!!!
#ifdef FFS_WIN
        //Windows does NOT distinguish between upper/lower-case
        bool operator>(const FileDescrLine& b ) const
        {
            return (relativeName.CmpNoCase(b.relativeName) > 0);
        }
        bool operator<(const FileDescrLine& b) const
        {
            return (relativeName.CmpNoCase(b.relativeName) < 0);
        }
        bool operator==(const FileDescrLine& b) const
        {
            return (relativeName.CmpNoCase(b.relativeName) == 0);
        }

#elif defined FFS_LINUX
        //Linux DOES distinguish between upper/lower-case
        bool operator>(const FileDescrLine& b ) const
        {
            return (relativeName.Cmp(b.relativeName) > 0);
        }
        bool operator<(const FileDescrLine& b) const
        {
            return (relativeName.Cmp(b.relativeName) < 0);
        }
        bool operator==(const FileDescrLine& b) const
        {
            return (relativeName.Cmp(b.relativeName) == 0);
        }
#else
        adapt this
#endif
    };
    typedef set<FileDescrLine> DirectoryDescrType;


    enum CompareFilesResult
    {
        FILE_LEFT_SIDE_ONLY,
        FILE_RIGHT_SIDE_ONLY,
        FILE_LEFT_NEWER,
        FILE_RIGHT_NEWER,
        FILE_DIFFERENT,
        FILE_EQUAL,

        FILE_UNDEFINED
    };


    struct FileCompareLine
    {
        FileCompareLine() : selectedForSynchronization(true) {}

        FileDescrLine fileDescrLeft;
        FileDescrLine fileDescrRight;

        CompareFilesResult cmpResult;
        bool selectedForSynchronization;
    };
    typedef vector<FileCompareLine> FileCompareResult;


    typedef int GridViewLine;
    typedef vector<GridViewLine> GridView;  //vector of references to lines in FileCompareResult


    struct FolderPair
    {
        wxString leftDirectory;
        wxString rightDirectory;
    };


    class AbortThisProcess  //Exception class used to abort the "compare" and "sync" process
    {
    public:
        AbortThisProcess() {}
        ~AbortThisProcess() {}
    };

    const int FILE_TIME_PRECISION = 2; //file times have precision of 2 seconds due to FAT/FAT32 file systems
    const wxString LAST_CONFIG_FILE = wxT("LastRun.ffs_gui");
    const wxString GLOBAL_CONFIG_FILE = wxT("GlobalSettings.xml");
}

#endif // FREEFILESYNC_H_INCLUDED
bgstack15