← Back to branch summary

~ted/ubuntu/lucid/tomboy/with-patch

« back to all changes in this revision

Viewing changes to Mono.Addins/Mono.Addins/Mono.Addins.Database/AddinScanFolderInfo.cs

Tags: upstream-0.9.8
Import upstream version 0.9.8

Show diffs side-by-side

added added

removed removed

Lines of Context:
Mono.Addins/Mono.Addins/Mono.Addins.Database/AddinScanFolderInfo.cs
39
39
                Hashtable files = new Hashtable ();
40
40
                string folder;
41
41
                string fileName;
 
42
                string domain;
 
43
                bool sharedFolder = true;
42
44
                
43
45
                static BinaryXmlTypeMap typeMap = new BinaryXmlTypeMap (
44
46
                        typeof(AddinScanFolderInfo),
69
71
                public static AddinScanFolderInfo Read (FileDatabase filedb, string basePath, string folderPath)
70
72
                {
71
73
                        string fileName;
72
 
                        AddinScanFolderInfo finfo = (AddinScanFolderInfo) filedb.ReadSharedObject (basePath, GetFolderId (folderPath), ".data", Util.GetFullPath (folderPath), typeMap, out fileName);
 
74
                        AddinScanFolderInfo finfo = (AddinScanFolderInfo) filedb.ReadSharedObject (basePath, GetDomain (folderPath), ".data", Util.GetFullPath (folderPath), typeMap, out fileName);
73
75
                        if (finfo != null)
74
76
                                finfo.fileName = fileName;
75
77
                        return finfo;
76
78
                }
77
79
                
78
 
                static string GetFolderId (string path)
 
80
                static string GetDomain (string path)
79
81
                {
80
82
                        path = Util.GetFullPath (path);
81
83
                        string s = path.Replace (Path.DirectorySeparatorChar, '_');
89
91
                
90
92
                public void Write (FileDatabase filedb, string basePath)
91
93
                {
92
 
                        filedb.WriteSharedObject (basePath, GetFolderId (folder), ".data", Util.GetFullPath (folder), fileName, typeMap, this);
 
94
                        filedb.WriteSharedObject (basePath, GetDomain (folder), ".data", Util.GetFullPath (folder), fileName, typeMap, this);
 
95
                }
 
96
                
 
97
                public string GetExistingLocalDomain ()
 
98
                {
 
99
                        foreach (AddinFileInfo info in files.Values) {
 
100
                                if (info.Domain != null && info.Domain != AddinDatabase.GlobalDomain)
 
101
                                        return info.Domain;
 
102
                        }
 
103
                        return AddinDatabase.GlobalDomain;
93
104
                }
94
105
                
95
106
                public string Folder {
96
107
                        get { return folder; }
97
108
                }
 
109
 
 
110
                public string Domain {
 
111
                        get {
 
112
                                if (sharedFolder)
 
113
                                        return AddinDatabase.GlobalDomain;
 
114
                                else
 
115
                                        return domain;
 
116
                        }
 
117
                        set {
 
118
                                domain = value;
 
119
                                sharedFolder = true;
 
120
                        }
 
121
                }
 
122
                
 
123
                public string RootsDomain {
 
124
                        get {
 
125
                                return domain;
 
126
                        }
 
127
                        set {
 
128
                                domain = value;
 
129
                        }
 
130
                }
 
131
                
 
132
                public string GetDomain (bool isRoot)
 
133
                {
 
134
                        if (isRoot)
 
135
                                return RootsDomain;
 
136
                        else
 
137
                                return Domain;
 
138
                }
 
139
                
 
140
                public bool SharedFolder {
 
141
                        get {
 
142
                                return sharedFolder;
 
143
                        }
 
144
                        set {
 
145
                                sharedFolder = value;
 
146
                        }
 
147
                }
98
148
                
99
149
                public DateTime GetLastScanTime (string file)
100
150
                {
122
172
                        info.AddinId = addinId;
123
173
                        info.IsRoot = isRoot;
124
174
                        info.ScanError = scanError;
 
175
                        if (addinId != null)
 
176
                                info.Domain = GetDomain (isRoot);
 
177
                        else
 
178
                                info.Domain = null;
125
179
                }
126
180
                
127
181
                public ArrayList GetMissingAddins ()
131
185
                        if (!Directory.Exists (folder)) {
132
186
                                // All deleted
133
187
                                foreach (AddinFileInfo info in files.Values) {
134
 
                                        if (info.AddinId != null && info.AddinId.Length > 0)
 
188
                                        if (info.IsAddin)
135
189
                                                missing.Add (info);
136
190
                                }
137
191
                                files.Clear ();
140
194
                        ArrayList toDelete = new ArrayList ();
141
195
                        foreach (AddinFileInfo info in files.Values) {
142
196
                                if (!File.Exists (info.File)) {
143
 
                                        if (info.AddinId != null && info.AddinId.Length > 0)
 
197
                                        if (info.IsAddin)
144
198
                                                missing.Add (info);
145
199
                                        toDelete.Add (info.File);
146
200
                                }
 
201
                                else if (info.IsAddin && info.Domain != GetDomain (info.IsRoot)) {
 
202
                                        missing.Add (info);
 
203
                                }
147
204
                        }
148
205
                        foreach (string file in toDelete)
149
206
                                files.Remove (file);
153
210
                
154
211
                void IBinaryXmlElement.Write (BinaryXmlWriter writer)
155
212
                {
 
213
                        if (files.Count == 0) {
 
214
                                domain = null;
 
215
                                sharedFolder = true;
 
216
                        }
156
217
                        writer.WriteValue ("folder", folder);
157
218
                        writer.WriteValue ("files", files);
 
219
                        writer.WriteValue ("domain", domain);
 
220
                        writer.WriteValue ("sharedFolder", sharedFolder);
158
221
                }
159
222
                
160
223
                void IBinaryXmlElement.Read (BinaryXmlReader reader)
161
224
                {
162
225
                        folder = reader.ReadStringValue ("folder");
163
226
                        reader.ReadValue ("files", files);
 
227
                        domain = reader.ReadStringValue ("domain");
 
228
                        sharedFolder = reader.ReadBooleanValue ("sharedFolder");
164
229
                }
165
230
        }
166
231
        
172
237
                public string AddinId;
173
238
                public bool IsRoot;
174
239
                public bool ScanError;
 
240
                public string Domain;
 
241
                
 
242
                public bool IsAddin {
 
243
                        get { return AddinId != null && AddinId.Length != 0; }
 
244
                }
175
245
                
176
246
                void IBinaryXmlElement.Write (BinaryXmlWriter writer)
177
247
                {
180
250
                        writer.WriteValue ("AddinId", AddinId);
181
251
                        writer.WriteValue ("IsRoot", IsRoot);
182
252
                        writer.WriteValue ("ScanError", ScanError);
 
253
                        writer.WriteValue ("Domain", Domain);
183
254
                }
184
255
                
185
256
                void IBinaryXmlElement.Read (BinaryXmlReader reader)
189
260
                        AddinId = reader.ReadStringValue ("AddinId");
190
261
                        IsRoot = reader.ReadBooleanValue ("IsRoot");
191
262
                        ScanError = reader.ReadBooleanValue ("ScanError");
 
263
                        Domain = reader.ReadStringValue ("Domain");
192
264
                }
193
265
        }
194
266
}