← Back to branch summary

~ubuntu-branches/ubuntu/precise/p7zip/precise-updates

« back to all changes in this revision

Viewing changes to CPP/7zip/UI/FileManager/ViewSettings.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Mohammed Adnène Trojette
  • Date: 2009-02-14 20:12:27 UTC
  • mfrom: (1.1.11 upstream) (2.1.3 sid)
  • Revision ID: james.westby@ubuntu.com-20090214201227-go63qxm9ozfdma60
Tags: 4.65~dfsg.1-1
* New upstream release.
* Remove wx2.8 Build-Depends added by mistakes (7zG is not yet
  intended to be built).
* Use dh_clean without -k.

Show diffs side-by-side

added added

removed removed

Lines of Context:
CPP/7zip/UI/FileManager/ViewSettings.cpp
 
1
// ViewSettings.h
 
2
 
 
3
#include "StdAfx.h"
 
4
 
 
5
#include "Common/IntToString.h"
 
6
#include "Common/StringConvert.h"
 
7
 
 
8
#include "ViewSettings.h"
 
9
#include "Windows/Registry.h"
 
10
#include "Windows/Synchronization.h"
 
11
 
 
12
using namespace NWindows;
 
13
using namespace NRegistry;
 
14
 
 
15
#define REG_PATH_FM TEXT("Software") TEXT(STRING_PATH_SEPARATOR) TEXT("7-ZIP") TEXT(STRING_PATH_SEPARATOR) TEXT("FM")
 
16
 
 
17
static const TCHAR *kCUBasePath = REG_PATH_FM;
 
18
static const TCHAR *kCulumnsKeyName = REG_PATH_FM TEXT(STRING_PATH_SEPARATOR) TEXT("Columns");
 
19
 
 
20
static const TCHAR *kPositionValueName = TEXT("Position");
 
21
static const TCHAR *kPanelsInfoValueName = TEXT("Panels");
 
22
static const TCHAR *kToolbars = TEXT("Toolbars");
 
23
 
 
24
static const WCHAR *kPanelPathValueName = L"PanelPath";
 
25
static const TCHAR *kListMode = TEXT("ListMode");
 
26
static const TCHAR *kFolderHistoryValueName = TEXT("FolderHistory");
 
27
static const TCHAR *kFastFoldersValueName = TEXT("FolderShortcuts");
 
28
static const TCHAR *kCopyHistoryValueName = TEXT("CopyHistory");
 
29
 
 
30
/*
 
31
class CColumnInfoSpec
 
32
{
 
33
  UInt32 PropID;
 
34
  Byte IsVisible;
 
35
  UInt32 Width;
 
36
};
 
37
 
 
38
struct CColumnHeader
 
39
{
 
40
  UInt32 Version;
 
41
  UInt32 SortID;
 
42
  Byte Ascending;
 
43
};
 
44
*/
 
45
 
 
46
static const UInt32 kColumnInfoSpecHeader = 12;
 
47
static const UInt32 kColumnHeaderSize = 12;
 
48
 
 
49
static const UInt32 kColumnInfoVersion = 1;
 
50
 
 
51
static NSynchronization::CCriticalSection g_RegistryOperationsCriticalSection;
 
52
 
 
53
class CTempOutBufferSpec
 
54
{
 
55
  CByteBuffer Buffer;
 
56
  UInt32 Size;
 
57
  UInt32 Pos;
 
58
public:
 
59
  operator const Byte *() const { return (const Byte *)Buffer; }
 
60
  void Init(UInt32 dataSize)
 
61
  {
 
62
    Buffer.SetCapacity(dataSize);
 
63
    Size = dataSize;
 
64
    Pos = 0;
 
65
  }
 
66
  void WriteByte(Byte value)
 
67
  {
 
68
    if (Pos >= Size)
 
69
      throw "overflow";
 
70
    ((Byte *)Buffer)[Pos++] = value;
 
71
  }
 
72
  void WriteUInt32(UInt32 value)
 
73
  {
 
74
    for (int i = 0; i < 4; i++)
 
75
    {
 
76
      WriteByte((Byte)value);
 
77
      value >>= 8;
 
78
    }
 
79
  }
 
80
  void WriteBool(bool value)
 
81
  {
 
82
    WriteUInt32(value ? 1 : 0);
 
83
  }
 
84
};
 
85
 
 
86
class CTempInBufferSpec
 
87
{
 
88
public:
 
89
  Byte *Buffer;
 
90
  UInt32 Size;
 
91
  UInt32 Pos;
 
92
  Byte ReadByte()
 
93
  {
 
94
    if (Pos >= Size)
 
95
      throw "overflow";
 
96
    return Buffer[Pos++];
 
97
  }
 
98
  UInt32 ReadUInt32()
 
99
  {
 
100
    UInt32 value = 0;
 
101
    for (int i = 0; i < 4; i++)
 
102
      value |= (((UInt32)ReadByte()) << (8 * i));
 
103
    return value;
 
104
  }
 
105
  bool ReadBool()
 
106
  {
 
107
    return (ReadUInt32() != 0);
 
108
  }
 
109
};
 
110
 
 
111
void SaveListViewInfo(const UString &id, const CListViewInfo &viewInfo)
 
112
{
 
113
  const CObjectVector<CColumnInfo> &columns = viewInfo.Columns;
 
114
  CTempOutBufferSpec buffer;
 
115
  UInt32 dataSize = kColumnHeaderSize + kColumnInfoSpecHeader * columns.Size();
 
116
  buffer.Init(dataSize);
 
117
 
 
118
  buffer.WriteUInt32(kColumnInfoVersion);
 
119
  buffer.WriteUInt32(viewInfo.SortID);
 
120
  buffer.WriteBool(viewInfo.Ascending);
 
121
  for(int i = 0; i < columns.Size(); i++)
 
122
  {
 
123
    const CColumnInfo &column = columns[i];
 
124
    buffer.WriteUInt32(column.PropID);
 
125
    buffer.WriteBool(column.IsVisible);
 
126
    buffer.WriteUInt32(column.Width);
 
127
  }
 
128
  {
 
129
    NSynchronization::CCriticalSectionLock lock(g_RegistryOperationsCriticalSection);
 
130
    CKey key;
 
131
    key.Create(HKEY_CURRENT_USER, kCulumnsKeyName);
 
132
    key.SetValue(GetSystemString(id), (const Byte *)buffer, dataSize);
 
133
  }
 
134
}
 
135
 
 
136
void ReadListViewInfo(const UString &id, CListViewInfo &viewInfo)
 
137
{
 
138
  viewInfo.Clear();
 
139
  CObjectVector<CColumnInfo> &columns = viewInfo.Columns;
 
140
  CByteBuffer buffer;
 
141
  UInt32 size;
 
142
  {
 
143
    NSynchronization::CCriticalSectionLock lock(g_RegistryOperationsCriticalSection);
 
144
    CKey key;
 
145
    if(key.Open(HKEY_CURRENT_USER, kCulumnsKeyName, KEY_READ) != ERROR_SUCCESS)
 
146
      return;
 
147
    if (key.QueryValue(GetSystemString(id), buffer, size) != ERROR_SUCCESS)
 
148
      return;
 
149
  }
 
150
  if (size < kColumnHeaderSize)
 
151
    return;
 
152
  CTempInBufferSpec inBuffer;
 
153
  inBuffer.Size = size;
 
154
  inBuffer.Buffer = (Byte *)buffer;
 
155
  inBuffer.Pos = 0;
 
156
 
 
157
 
 
158
  UInt32 version = inBuffer.ReadUInt32();
 
159
  if (version != kColumnInfoVersion)
 
160
    return;
 
161
  viewInfo.SortID = inBuffer.ReadUInt32();
 
162
  viewInfo.Ascending = inBuffer.ReadBool();
 
163
 
 
164
  size -= kColumnHeaderSize;
 
165
  if (size % kColumnInfoSpecHeader != 0)
 
166
    return;
 
167
  int numItems = size / kColumnInfoSpecHeader;
 
168
  columns.Reserve(numItems);
 
169
  for(int i = 0; i < numItems; i++)
 
170
  {
 
171
    CColumnInfo columnInfo;
 
172
    columnInfo.PropID = inBuffer.ReadUInt32();
 
173
    columnInfo.IsVisible = inBuffer.ReadBool();
 
174
    columnInfo.Width = inBuffer.ReadUInt32();
 
175
    columns.Add(columnInfo);
 
176
  }
 
177
}
 
178
 
 
179
static const UInt32 kWindowPositionHeaderSize = 5 * 4;
 
180
static const UInt32 kPanelsInfoHeaderSize = 3 * 4;
 
181
 
 
182
/*
 
183
struct CWindowPosition
 
184
{
 
185
  RECT Rect;
 
186
  UInt32 Maximized;
 
187
};
 
188
 
 
189
struct CPanelsInfo
 
190
{
 
191
  UInt32 NumPanels;
 
192
  UInt32 CurrentPanel;
 
193
  UInt32 SplitterPos;
 
194
};
 
195
*/
 
196
 
 
197
#ifdef _WIN32
 
198
void SaveWindowSize(const RECT &rect, bool maximized)
 
199
{
 
200
  CSysString keyName = kCUBasePath;
 
201
  CKey key;
 
202
  NSynchronization::CCriticalSectionLock lock(g_RegistryOperationsCriticalSection);
 
203
  key.Create(HKEY_CURRENT_USER, keyName);
 
204
  // CWindowPosition position;
 
205
  CTempOutBufferSpec buffer;
 
206
  buffer.Init(kWindowPositionHeaderSize);
 
207
  buffer.WriteUInt32(rect.left);
 
208
  buffer.WriteUInt32(rect.top);
 
209
  buffer.WriteUInt32(rect.right);
 
210
  buffer.WriteUInt32(rect.bottom);
 
211
  buffer.WriteBool(maximized);
 
212
  key.SetValue(kPositionValueName, (const Byte *)buffer, kWindowPositionHeaderSize);
 
213
}
 
214
 
 
215
bool ReadWindowSize(RECT &rect, bool &maximized)
 
216
{
 
217
  CSysString keyName = kCUBasePath;
 
218
  CKey key;
 
219
  NSynchronization::CCriticalSectionLock lock(g_RegistryOperationsCriticalSection);
 
220
  if(key.Open(HKEY_CURRENT_USER, keyName, KEY_READ) != ERROR_SUCCESS)
 
221
    return false;
 
222
  CByteBuffer buffer;
 
223
  UInt32 size;
 
224
  if (key.QueryValue(kPositionValueName, buffer, size) != ERROR_SUCCESS)
 
225
    return false;
 
226
  if (size != kWindowPositionHeaderSize)
 
227
    return false;
 
228
  CTempInBufferSpec inBuffer;
 
229
  inBuffer.Size = size;
 
230
  inBuffer.Buffer = (Byte *)buffer;
 
231
  inBuffer.Pos = 0;
 
232
  rect.left = inBuffer.ReadUInt32();
 
233
  rect.top = inBuffer.ReadUInt32();
 
234
  rect.right = inBuffer.ReadUInt32();
 
235
  rect.bottom = inBuffer.ReadUInt32();
 
236
  maximized = inBuffer.ReadBool();
 
237
  return true;
 
238
}
 
239
#endif
 
240
 
 
241
void SavePanelsInfo(UInt32 numPanels, UInt32 currentPanel, UInt32 splitterPos)
 
242
{
 
243
  CSysString keyName = kCUBasePath;
 
244
  CKey key;
 
245
  NSynchronization::CCriticalSectionLock lock(g_RegistryOperationsCriticalSection);
 
246
  key.Create(HKEY_CURRENT_USER, keyName);
 
247
 
 
248
  CTempOutBufferSpec buffer;
 
249
  buffer.Init(kPanelsInfoHeaderSize);
 
250
  buffer.WriteUInt32(numPanels);
 
251
  buffer.WriteUInt32(currentPanel);
 
252
  buffer.WriteUInt32(splitterPos);
 
253
  key.SetValue(kPanelsInfoValueName, (const Byte *)buffer, kPanelsInfoHeaderSize);
 
254
}
 
255
 
 
256
bool ReadPanelsInfo(UInt32 &numPanels, UInt32 &currentPanel, UInt32 &splitterPos)
 
257
{
 
258
  CSysString keyName = kCUBasePath;
 
259
  CKey key;
 
260
  NSynchronization::CCriticalSectionLock lock(g_RegistryOperationsCriticalSection);
 
261
  if(key.Open(HKEY_CURRENT_USER, keyName, KEY_READ) != ERROR_SUCCESS)
 
262
    return false;
 
263
  CByteBuffer buffer;
 
264
  UInt32 size;
 
265
  if (key.QueryValue(kPanelsInfoValueName, buffer, size) != ERROR_SUCCESS)
 
266
    return false;
 
267
  if (size != kPanelsInfoHeaderSize)
 
268
    return false;
 
269
  CTempInBufferSpec inBuffer;
 
270
  inBuffer.Size = size;
 
271
  inBuffer.Buffer = (Byte *)buffer;
 
272
  inBuffer.Pos = 0;
 
273
  numPanels = inBuffer.ReadUInt32();
 
274
  currentPanel = inBuffer.ReadUInt32();
 
275
  splitterPos = inBuffer.ReadUInt32();
 
276
  return true;
 
277
}
 
278
 
 
279
void SaveToolbarsMask(UInt32 toolbarMask)
 
280
{
 
281
  CKey key;
 
282
  key.Create(HKEY_CURRENT_USER, kCUBasePath);
 
283
  key.SetValue(kToolbars, toolbarMask);
 
284
}
 
285
 
 
286
static const UInt32 kDefaultToolbarMask = 8 | 4 | 1;
 
287
 
 
288
UInt32 ReadToolbarsMask()
 
289
{
 
290
  CKey key;
 
291
  if(key.Open(HKEY_CURRENT_USER, kCUBasePath, KEY_READ) != ERROR_SUCCESS)
 
292
    return kDefaultToolbarMask;
 
293
  UInt32 mask;
 
294
  if (key.QueryValue(kToolbars, mask) != ERROR_SUCCESS)
 
295
    return kDefaultToolbarMask;
 
296
  return mask;
 
297
}
 
298
 
 
299
 
 
300
static UString GetPanelPathName(UInt32 panelIndex)
 
301
{
 
302
  WCHAR panelString[32];
 
303
  ConvertUInt64ToString(panelIndex, panelString);
 
304
  return UString(kPanelPathValueName) + panelString;
 
305
}
 
306
 
 
307
 
 
308
void SavePanelPath(UInt32 panel, const UString &path)
 
309
{
 
310
  CKey key;
 
311
  NSynchronization::CCriticalSectionLock lock(g_RegistryOperationsCriticalSection);
 
312
  key.Create(HKEY_CURRENT_USER, kCUBasePath);
 
313
  key.SetValue(GetPanelPathName(panel), path);
 
314
}
 
315
 
 
316
bool ReadPanelPath(UInt32 panel, UString &path)
 
317
{
 
318
  CKey key;
 
319
  NSynchronization::CCriticalSectionLock lock(g_RegistryOperationsCriticalSection);
 
320
  if(key.Open(HKEY_CURRENT_USER, kCUBasePath, KEY_READ) != ERROR_SUCCESS)
 
321
    return false;
 
322
  return (key.QueryValue(GetPanelPathName(panel), path) == ERROR_SUCCESS);
 
323
}
 
324
 
 
325
void SaveListMode(const CListMode &listMode)
 
326
{
 
327
  CKey key;
 
328
  key.Create(HKEY_CURRENT_USER, kCUBasePath);
 
329
  UInt32 t = 0;
 
330
  for (int i = 0; i < 2; i++)
 
331
    t |= ((listMode.Panels[i]) & 0xFF) << (i * 8);
 
332
  key.SetValue(kListMode, t);
 
333
}
 
334
 
 
335
void ReadListMode(CListMode &listMode)
 
336
{
 
337
  CKey key;
 
338
  listMode.Init();
 
339
  if(key.Open(HKEY_CURRENT_USER, kCUBasePath, KEY_READ) != ERROR_SUCCESS)
 
340
    return;
 
341
  UInt32 t;
 
342
  if (key.QueryValue(kListMode, t) != ERROR_SUCCESS)
 
343
    return;
 
344
  for (int i = 0; i < 2; i++)
 
345
  {
 
346
    listMode.Panels[i] = (t & 0xFF);
 
347
    t >>= 8;
 
348
  }
 
349
}
 
350
 
 
351
 
 
352
void SaveStringList(LPCTSTR valueName, const UStringVector &folders)
 
353
{
 
354
  UInt32 sizeInChars = 0;
 
355
  int i;
 
356
  for (i = 0; i < folders.Size(); i++)
 
357
    sizeInChars += folders[i].Length() + 1;
 
358
  CBuffer<wchar_t> buffer;
 
359
  buffer.SetCapacity(sizeInChars);
 
360
  int pos = 0;
 
361
  for (i = 0; i < folders.Size(); i++)
 
362
  {
 
363
    MyStringCopy((wchar_t *)buffer + pos, (const wchar_t *)folders[i]);
 
364
    pos += folders[i].Length() + 1;
 
365
  }
 
366
  CKey key;
 
367
  NSynchronization::CCriticalSectionLock lock(g_RegistryOperationsCriticalSection);
 
368
  key.Create(HKEY_CURRENT_USER, kCUBasePath);
 
369
  key.SetValue(valueName, buffer, sizeInChars * sizeof(wchar_t));
 
370
}
 
371
 
 
372
void ReadStringList(LPCTSTR valueName, UStringVector &folders)
 
373
{
 
374
  folders.Clear();
 
375
  CKey key;
 
376
  NSynchronization::CCriticalSectionLock lock(g_RegistryOperationsCriticalSection);
 
377
  if(key.Open(HKEY_CURRENT_USER, kCUBasePath, KEY_READ) != ERROR_SUCCESS)
 
378
    return;
 
379
  CByteBuffer buffer;
 
380
  UInt32 dataSize;
 
381
  if (key.QueryValue(valueName, buffer, dataSize) != ERROR_SUCCESS)
 
382
    return;
 
383
  if (dataSize % sizeof(wchar_t) != 0)
 
384
    return;
 
385
  const wchar_t *data = (const wchar_t *)(const Byte  *)buffer;
 
386
  int sizeInChars = dataSize / sizeof(wchar_t);
 
387
  UString string;
 
388
  for (int i = 0; i < sizeInChars; i++)
 
389
  {
 
390
    wchar_t c = data[i];
 
391
    if (c == L'\0')
 
392
    {
 
393
      folders.Add(string);
 
394
      string.Empty();
 
395
    }
 
396
    else
 
397
      string += c;
 
398
  }
 
399
}
 
400
 
 
401
void SaveFolderHistory(const UStringVector &folders)
 
402
  { SaveStringList(kFolderHistoryValueName, folders); }
 
403
void ReadFolderHistory(UStringVector &folders)
 
404
  { ReadStringList(kFolderHistoryValueName, folders); }
 
405
 
 
406
void SaveFastFolders(const UStringVector &folders)
 
407
  { SaveStringList(kFastFoldersValueName, folders); }
 
408
void ReadFastFolders(UStringVector &folders)
 
409
  { ReadStringList(kFastFoldersValueName, folders); }
 
410
 
 
411
void SaveCopyHistory(const UStringVector &folders)
 
412
  { SaveStringList(kCopyHistoryValueName, folders); }
 
413
void ReadCopyHistory(UStringVector &folders)
 
414
  { ReadStringList(kCopyHistoryValueName, folders); }
 
415
 
 
416
void AddUniqueStringToHeadOfList(UStringVector &list,
 
417
    const UString &string)
 
418
{
 
419
  for(int i = 0; i < list.Size();)
 
420
    if (string.CompareNoCase(list[i]) == 0)
 
421
      list.Delete(i);
 
422
    else
 
423
      i++;
 
424
  list.Insert(0, string);
 
425
}
 
426