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

#include <wx/string.h>
#include <set>
#include <vector>
#include "library/fileHandling.h"
#include "library/zstring.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

        //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
    };


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

        enum ObjectType
        {
            TYPE_NOTHING,
            TYPE_DIRECTORY,
            TYPE_FILE
        };

        Zstring fullName;  // == directory + relativeName
        Zstring directory; //directory to be synced + separator
        Zsubstr 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)!
        wxLongLong lastWriteTimeRaw; //number of seconds since Jan. 1st 1970 UTC, same semantics like time_t (== signed long)
        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!!!
        bool operator < (const FileDescrLine& b) const
        {
            //quick check based on string length: we are not interested in a lexicographical order!
            const size_t aLength = relativeName.length();
            const size_t bLength = b.relativeName.length();
            if (aLength != bLength)
                return aLength < bLength;
#ifdef FFS_WIN //Windows does NOT distinguish between upper/lower-case
            return FreeFileSync::compareStringsWin32(relativeName.c_str(), b.relativeName.c_str()) < 0;  //implementing a (reverse) comparison manually is a lot slower!
#elif defined FFS_LINUX //Linux DOES distinguish between upper/lower-case
            return defaultCompare(relativeName.c_str(), b.relativeName.c_str()) < 0;
#endif
        }
    };
    typedef std::vector<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 std::vector<FileCompareLine> FileCompareResult;


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


    struct FolderPair
    {
        Zstring leftDirectory;
        Zstring rightDirectory;
    };


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

    const wxString LAST_CONFIG_FILE = wxT("LastRun.ffs_gui");
    const wxString GLOBAL_CONFIG_FILE = wxT("GlobalSettings.xml");
}

#endif // FREEFILESYNC_H_INCLUDED
bgstack15