src/TortoiseShell/ShellCache.h

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2008 - Stefan Kueng
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 #pragma once
  20 #include "registry.h"
  21 #include "Globals.h"
  22 #include "GitAdminDir.h"
  23 #include "Git.h"
  24
  25 #define REGISTRYTIMEOUT 2000
  26 #define EXCLUDELISTTIMEOUT 5000
  27 #define ADMINDIRTIMEOUT 10000
  28 #define DRIVETYPETIMEOUT 300000         // 5 min
  29 #define NUMBERFMTTIMEOUT 300000
  30 #define MENUTIMEOUT 100
  31
  32 typedef CComCritSecLock<CComCriticalSection> Locker;
  33
  34 /**
  35  * \ingroup TortoiseShell
  36  * Helper class which caches access to the registry. Also provides helper methods
  37  * for checks against the settings stored in the registry.
  38  */
  39 class ShellCache
  40 {
  41 public:
  42         enum CacheType
  43         {
  44                 none,
  45                 exe,
  46                 dll,
  47                 dllFull,// same as dll except it uses commandline git tool with all status modes supported
  48         };
  49         ShellCache()
  50         {
  51                 cachetype = CRegStdWORD(_T("Software\\TortoiseGit\\CacheType"), GetSystemMetrics(SM_REMOTESESSION) ? dll : exe);
  52                 showrecursive = CRegStdWORD(_T("Software\\TortoiseGit\\RecursiveOverlay"), TRUE);
  53                 folderoverlay = CRegStdWORD(_T("Software\\TortoiseGit\\FolderOverlay"), TRUE);
  54                 driveremote = CRegStdWORD(_T("Software\\TortoiseGit\\DriveMaskRemote"));
  55                 drivefixed = CRegStdWORD(_T("Software\\TortoiseGit\\DriveMaskFixed"), TRUE);
  56                 drivecdrom = CRegStdWORD(_T("Software\\TortoiseGit\\DriveMaskCDROM"));
  57                 driveremove = CRegStdWORD(_T("Software\\TortoiseGit\\DriveMaskRemovable"));
  58                 drivefloppy = CRegStdWORD(_T("Software\\TortoiseGit\\DriveMaskFloppy"));
  59                 driveram = CRegStdWORD(_T("Software\\TortoiseGit\\DriveMaskRAM"));
  60                 driveunknown = CRegStdWORD(_T("Software\\TortoiseGit\\DriveMaskUnknown"));
  61                 excludelist = CRegStdString(_T("Software\\TortoiseGit\\OverlayExcludeList"));
  62                 includelist = CRegStdString(_T("Software\\TortoiseGit\\OverlayIncludeList"));
  63                 simplecontext = CRegStdWORD(_T("Software\\TortoiseGit\\SimpleContext"), FALSE);
  64                 unversionedasmodified = CRegStdWORD(_T("Software\\TortoiseGit\\UnversionedAsModified"), FALSE);
  65                 showunversionedoverlay = CRegStdWORD(_T("Software\\TortoiseGit\\ShowUnversionedOverlay"), TRUE);
  66                 showignoredoverlay = CRegStdWORD(_T("Software\\TortoiseGit\\ShowIgnoredOverlay"), TRUE);
  67                 getlocktop = CRegStdWORD(_T("Software\\TortoiseGit\\GetLockTop"), TRUE);
  68                 excludedasnormal = CRegStdWORD(_T("Software\\TortoiseGit\\ShowExcludedAsNormal"), TRUE);
  69                 cachetypeticker = GetTickCount();
  70                 recursiveticker = cachetypeticker;
  71                 folderoverlayticker = cachetypeticker;
  72                 driveticker = cachetypeticker;
  73                 drivetypeticker = cachetypeticker;
  74                 langticker = cachetypeticker;
  75                 columnrevformatticker = cachetypeticker;
  76                 excludelistticker = cachetypeticker;
  77                 includelistticker = cachetypeticker;
  78                 simplecontextticker = cachetypeticker;
  79                 unversionedasmodifiedticker = cachetypeticker;
  80                 showunversionedoverlayticker = cachetypeticker;
  81                 showignoredoverlayticker = cachetypeticker;
  82                 admindirticker = cachetypeticker;
  83                 columnseverywhereticker = cachetypeticker;
  84                 getlocktopticker = cachetypeticker;
  85                 excludedasnormalticker = cachetypeticker;
  86                 excontextticker = cachetypeticker;
  87                 menulayoutlow = CRegStdWORD(_T("Software\\TortoiseGit\\ContextMenuEntries"),              MENUCREATEREPOS|MENUCLONE|MENUCOMMIT);
  88                 menulayouthigh = CRegStdWORD(_T("Software\\TortoiseGit\\ContextMenuEntrieshigh"), (MENUCREATEREPOS|MENUCLONE|MENUCOMMIT)>>32);
  89                 menumasklow_lm = CRegStdWORD(_T("Software\\TortoiseGit\\ContextMenuEntriesMaskLow"), 0, FALSE, HKEY_LOCAL_MACHINE);
  90                 menumaskhigh_lm = CRegStdWORD(_T("Software\\TortoiseGit\\ContextMenuEntriesMaskHigh"), 0, FALSE, HKEY_LOCAL_MACHINE);
  91                 menumasklow_cu = CRegStdWORD(_T("Software\\TortoiseGit\\ContextMenuEntriesMaskLow"), 0);
  92                 menumaskhigh_cu = CRegStdWORD(_T("Software\\TortoiseGit\\ContextMenuEntriesMaskHigh"), 0);
  93                 langid = CRegStdWORD(_T("Software\\TortoiseGit\\LanguageID"), 1033);
  94                 blockstatus = CRegStdWORD(_T("Software\\TortoiseGit\\BlockStatus"), 0);
  95                 columnseverywhere = CRegStdWORD(_T("Software\\TortoiseGit\\ColumnsEveryWhere"), FALSE);
  96                 for (int i=0; i<27; i++)
  97                 {
  98                         drivetypecache[i] = (UINT)-1;
  99                 }
 100                 // A: and B: are floppy disks
 101                 drivetypecache[0] = DRIVE_REMOVABLE;
 102                 drivetypecache[1] = DRIVE_REMOVABLE;
 103                 TCHAR szBuffer[5];
 104                 columnrevformatticker = GetTickCount();
 105                 SecureZeroMemory(&columnrevformat, sizeof(NUMBERFMT));
 106                 GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, &szDecSep[0], sizeof(szDecSep));
 107                 GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, &szThousandsSep[0], sizeof(szThousandsSep));
 108                 columnrevformat.lpDecimalSep = szDecSep;
 109                 columnrevformat.lpThousandSep = szThousandsSep;
 110                 GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SGROUPING, &szBuffer[0], sizeof(szBuffer));
 111                 columnrevformat.Grouping = _ttoi(szBuffer);
 112                 GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_INEGNUMBER, &szBuffer[0], sizeof(szBuffer));
 113                 columnrevformat.NegativeOrder = _ttoi(szBuffer);
 114                 sAdminDirCacheKey.reserve(MAX_PATH);            // MAX_PATH as buffer reservation ok.
 115                 nocontextpaths = CRegStdString(_T("Software\\TortoiseGit\\NoContextPaths"), _T(""));
 116                 m_critSec.Init();
 117         }
 118         void ForceRefresh()
 119         {
 120                 cachetype.read();
 121                 showrecursive.read();
 122                 folderoverlay.read();
 123                 driveremote.read();
 124                 drivefixed.read();
 125                 drivecdrom.read();
 126                 driveremove.read();
 127                 drivefloppy.read();
 128                 driveram.read();
 129                 driveunknown.read();
 130                 excludelist.read();
 131                 includelist.read();
 132                 simplecontext.read();
 133                 unversionedasmodified.read();
 134                 showunversionedoverlay.read();
 135                 showignoredoverlay.read();
 136                 excludedasnormal.read();
 137                 menulayoutlow.read();
 138                 menulayouthigh.read();
 139                 langid.read();
 140                 blockstatus.read();
 141                 columnseverywhere.read();
 142                 getlocktop.read();
 143                 menumasklow_lm.read();
 144                 menumaskhigh_lm.read();
 145                 menumasklow_cu.read();
 146                 menumaskhigh_cu.read();
 147                 nocontextpaths.read();
 148         }
 149         CacheType GetCacheType()
 150         {
 151                 if ((GetTickCount() - REGISTRYTIMEOUT) > cachetypeticker)
 152                 {
 153                         cachetypeticker = GetTickCount();
 154                         cachetype.read();
 155                 }
 156                 return CacheType(DWORD((cachetype)));
 157         }
 158         DWORD BlockStatus()
 159         {
 160                 if ((GetTickCount() - REGISTRYTIMEOUT) > blockstatusticker)
 161                 {
 162                         blockstatusticker = GetTickCount();
 163                         blockstatus.read();
 164                 }
 165                 return (blockstatus);
 166         }
 167         unsigned __int64 GetMenuLayout()
 168         {
 169                 if ((GetTickCount() - REGISTRYTIMEOUT) > layoutticker)
 170                 {
 171                         layoutticker = GetTickCount();
 172                         menulayoutlow.read();
 173                         menulayouthigh.read();
 174                 }
 175                 unsigned __int64 temp = unsigned __int64(DWORD(menulayouthigh))<<32;
 176                 temp |= unsigned __int64(DWORD(menulayoutlow));
 177                 return temp;
 178         }
 179         unsigned __int64 GetMenuMask()
 180         {
 181                 if ((GetTickCount() - REGISTRYTIMEOUT) > menumaskticker)
 182                 {
 183                         menumaskticker = GetTickCount();
 184                         menumasklow_lm.read();
 185                         menumaskhigh_lm.read();
 186                         menumasklow_cu.read();
 187                         menumaskhigh_cu.read();
 188                 }
 189                 DWORD low = (DWORD)menumasklow_lm | (DWORD)menumasklow_cu;
 190                 DWORD high = (DWORD)menumaskhigh_lm | (DWORD)menumaskhigh_cu;
 191                 unsigned __int64 temp = unsigned __int64(high)<<32;
 192                 temp |= unsigned __int64(low);
 193                 return temp;
 194         }
 195         BOOL IsRecursive()
 196         {
 197                 if ((GetTickCount() - REGISTRYTIMEOUT)>recursiveticker)
 198                 {
 199                         recursiveticker = GetTickCount();
 200                         showrecursive.read();
 201                 }
 202                 return (showrecursive);
 203         }
 204         BOOL IsFolderOverlay()
 205         {
 206                 if ((GetTickCount() - REGISTRYTIMEOUT)>folderoverlayticker)
 207                 {
 208                         folderoverlayticker = GetTickCount();
 209                         folderoverlay.read();
 210                 }
 211                 return (folderoverlay);
 212         }
 213         BOOL IsSimpleContext()
 214         {
 215                 if ((GetTickCount() - REGISTRYTIMEOUT)>simplecontextticker)
 216                 {
 217                         simplecontextticker = GetTickCount();
 218                         simplecontext.read();
 219                 }
 220                 return (simplecontext!=0);
 221         }
 222         BOOL IsUnversionedAsModified()
 223         {
 224                 if ((GetTickCount() - REGISTRYTIMEOUT)>unversionedasmodifiedticker)
 225                 {
 226                         unversionedasmodifiedticker = GetTickCount();
 227                         unversionedasmodified.read();
 228                 }
 229                 return (unversionedasmodified);
 230         }
 231         BOOL ShowUnversionedOverlay()
 232         {
 233                 if ((GetTickCount() - REGISTRYTIMEOUT)>showunversionedoverlayticker)
 234                 {
 235                         showunversionedoverlayticker = GetTickCount();
 236                         showunversionedoverlay.read();
 237                 }
 238                 return (showunversionedoverlay);
 239         }
 240         BOOL ShowIgnoredOverlay()
 241         {
 242                 if ((GetTickCount() - REGISTRYTIMEOUT)>showignoredoverlayticker)
 243                 {
 244                         showignoredoverlayticker = GetTickCount();
 245                         showignoredoverlay.read();
 246                 }
 247                 return (showignoredoverlay);
 248         }
 249         BOOL IsGetLockTop()
 250         {
 251                 if ((GetTickCount() - REGISTRYTIMEOUT)>getlocktopticker)
 252                 {
 253                         getlocktopticker = GetTickCount();
 254                         getlocktop.read();
 255                 }
 256                 return (getlocktop);
 257         }
 258         BOOL ShowExcludedAsNormal()
 259         {
 260                 if ((GetTickCount() - REGISTRYTIMEOUT)>excludedasnormalticker)
 261                 {
 262                         excludedasnormalticker = GetTickCount();
 263                         excludedasnormal.read();
 264                 }
 265                 return (excludedasnormal);
 266         }
 267         BOOL IsRemote()
 268         {
 269                 DriveValid();
 270                 return (driveremote);
 271         }
 272         BOOL IsFixed()
 273         {
 274                 DriveValid();
 275                 return (drivefixed);
 276         }
 277         BOOL IsCDRom()
 278         {
 279                 DriveValid();
 280                 return (drivecdrom);
 281         }
 282         BOOL IsRemovable()
 283         {
 284                 DriveValid();
 285                 return (driveremove);
 286         }
 287         BOOL IsRAM()
 288         {
 289                 DriveValid();
 290                 return (driveram);
 291         }
 292         BOOL IsUnknown()
 293         {
 294                 DriveValid();
 295                 return (driveunknown);
 296         }
 297         BOOL IsContextPathAllowed(LPCTSTR path)
 298         {
 299                 Locker lock(m_critSec);
 300                 ExcludeContextValid();
 301                 for (std::vector<stdstring>::iterator I = excontextvector.begin(); I != excontextvector.end(); ++I)
 302                 {
 303                         if (I->empty())
 304                                 continue;
 305                         if (I->size() && I->at(I->size()-1)=='*')
 306                         {
 307                                 stdstring str = I->substr(0, I->size()-1);
 308                                 if (_tcsnicmp(str.c_str(), path, str.size())==0)
 309                                         return FALSE;
 310                         }
 311                         else if (_tcsicmp(I->c_str(), path)==0)
 312                                 return FALSE;
 313                 }
 314                 return TRUE;
 315         }
 316         BOOL IsPathAllowed(LPCTSTR path)
 317         {
 318                 Locker lock(m_critSec);
 319                 IncludeListValid();
 320                 for (std::vector<stdstring>::iterator I = invector.begin(); I != invector.end(); ++I)
 321                 {
 322                         if (I->empty())
 323                                 continue;
 324                         if (I->at(I->size()-1)=='*')
 325                         {
 326                                 stdstring str = I->substr(0, I->size()-1);
 327                                 if (_tcsnicmp(str.c_str(), path, str.size())==0)
 328                                         return TRUE;
 329                                 if (str.size() && (str.at(str.size()-1) == '\\') && (_tcsnicmp(str.c_str(), path, str.size()-1)==0))
 330                                         return TRUE;
 331                         }
 332                         else if (_tcsicmp(I->c_str(), path)==0)
 333                                 return TRUE;
 334                         else if ((I->at(I->size()-1) == '\\') &&
 335                                 ((_tcsnicmp(I->c_str(), path, I->size())==0) || (_tcsicmp(I->c_str(), path)==0)) )
 336                                 return TRUE;
 337
 338                 }
 339                 UINT drivetype = 0;
 340                 int drivenumber = PathGetDriveNumber(path);
 341                 if ((drivenumber >=0)&&(drivenumber < 25))
 342                 {
 343                         drivetype = drivetypecache[drivenumber];
 344                         if ((drivetype == -1)||((GetTickCount() - DRIVETYPETIMEOUT)>drivetypeticker))
 345                         {
 346                                 if ((drivenumber == 0)||(drivenumber == 1))
 347                                         drivetypecache[drivenumber] = DRIVE_REMOVABLE;
 348                                 else
 349                                 {
 350                                         drivetypeticker = GetTickCount();
 351                                         TCHAR pathbuf[MAX_PATH+4];              // MAX_PATH ok here. PathStripToRoot works with partial paths too.
 352                                         _tcsncpy_s(pathbuf, MAX_PATH+4, path, MAX_PATH+3);
 353                                         PathStripToRoot(pathbuf);
 354                                         PathAddBackslash(pathbuf);
 355                                         ATLTRACE2(_T("GetDriveType for %s, Drive %d\n"), pathbuf, drivenumber);
 356                                         drivetype = GetDriveType(pathbuf);
 357                                         drivetypecache[drivenumber] = drivetype;
 358                                 }
 359                         }
 360                 }
 361                 else
 362                 {
 363                         TCHAR pathbuf[MAX_PATH+4];              // MAX_PATH ok here. PathIsUNCServer works with partial paths too.
 364                         _tcsncpy_s(pathbuf, MAX_PATH+4, path, MAX_PATH+3);
 365                         if (PathIsUNCServer(pathbuf))
 366                                 drivetype = DRIVE_REMOTE;
 367                         else
 368                         {
 369                                 PathStripToRoot(pathbuf);
 370                                 PathAddBackslash(pathbuf);
 371                                 if (_tcsncmp(pathbuf, drivetypepathcache, MAX_PATH-1)==0)               // MAX_PATH ok.
 372                                         drivetype = drivetypecache[26];
 373                                 else
 374                                 {
 375                                         ATLTRACE2(_T("GetDriveType for %s\n"), pathbuf);
 376                                         drivetype = GetDriveType(pathbuf);
 377                                         drivetypecache[26] = drivetype;
 378                                         _tcsncpy_s(drivetypepathcache, MAX_PATH, pathbuf, MAX_PATH);                    // MAX_PATH ok.
 379                                 }
 380                         }
 381                 }
 382                 if ((drivetype == DRIVE_REMOVABLE)&&(!IsRemovable()))
 383                         return FALSE;
 384                 if ((drivetype == DRIVE_REMOVABLE)&&(drivefloppy == 0)&&((drivenumber==0)||(drivenumber==1)))
 385                         return FALSE;
 386                 if ((drivetype == DRIVE_FIXED)&&(!IsFixed()))
 387                         return FALSE;
 388                 if (((drivetype == DRIVE_REMOTE)||(drivetype == DRIVE_NO_ROOT_DIR))&&(!IsRemote()))
 389                         return FALSE;
 390                 if ((drivetype == DRIVE_CDROM)&&(!IsCDRom()))
 391                         return FALSE;
 392                 if ((drivetype == DRIVE_RAMDISK)&&(!IsRAM()))
 393                         return FALSE;
 394                 if ((drivetype == DRIVE_UNKNOWN)&&(IsUnknown()))
 395                         return FALSE;
 396
 397                 ExcludeListValid();
 398                 for (std::vector<stdstring>::iterator I = exvector.begin(); I != exvector.end(); ++I)
 399                 {
 400                         if (I->empty())
 401                                 continue;
 402                         if (I->size() && I->at(I->size()-1)=='*')
 403                         {
 404                                 stdstring str = I->substr(0, I->size()-1);
 405                                 if (_tcsnicmp(str.c_str(), path, str.size())==0)
 406                                         return FALSE;
 407                         }
 408                         else if (_tcsicmp(I->c_str(), path)==0)
 409                                 return FALSE;
 410                 }
 411                 return TRUE;
 412         }
 413         DWORD GetLangID()
 414         {
 415                 if ((GetTickCount() - REGISTRYTIMEOUT) > langticker)
 416                 {
 417                         langticker = GetTickCount();
 418                         langid.read();
 419                 }
 420                 return (langid);
 421         }
 422         NUMBERFMT * GetNumberFmt()
 423         {
 424                 if ((GetTickCount() - NUMBERFMTTIMEOUT) > columnrevformatticker)
 425                 {
 426                         TCHAR szBuffer[5];
 427                         columnrevformatticker = GetTickCount();
 428                         SecureZeroMemory(&columnrevformat, sizeof(NUMBERFMT));
 429                         GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, &szDecSep[0], sizeof(szDecSep));
 430                         GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, &szThousandsSep[0], sizeof(szThousandsSep));
 431                         columnrevformat.lpDecimalSep = szDecSep;
 432                         columnrevformat.lpThousandSep = szThousandsSep;
 433                         GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SGROUPING, &szBuffer[0], sizeof(szBuffer));
 434                         columnrevformat.Grouping = _ttoi(szBuffer);
 435                         GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_INEGNUMBER, &szBuffer[0], sizeof(szBuffer));
 436                         columnrevformat.NegativeOrder = _ttoi(szBuffer);
 437                 }
 438                 return &columnrevformat;
 439         }
 440         BOOL HasSVNAdminDir(LPCTSTR path, BOOL bIsDir, CString *ProjectTopDir = NULL)
 441         {
 442                 size_t len = _tcslen(path);
 443                 TCHAR * buf = new TCHAR[len+1];
 444                 _tcscpy_s(buf, len+1, path);
 445                 if (! bIsDir)
 446                 {
 447                         TCHAR * ptr = _tcsrchr(buf, '\\');
 448                         if (ptr != 0)
 449                         {
 450                                 *ptr = 0;
 451                         }
 452                 }
 453                 if ((GetTickCount() - ADMINDIRTIMEOUT) < admindirticker)
 454                 {
 455                         std::map<stdstring, AdminDir_s>::iterator iter;
 456                         sAdminDirCacheKey.assign(buf);
 457                         if ((iter = admindircache.find(sAdminDirCacheKey)) != admindircache.end())
 458                         {
 459                                 delete [] buf;
 460                                 if (ProjectTopDir && iter->second.bHasAdminDir)
 461                                         *ProjectTopDir = iter->second.sProjectRoot.c_str();
 462                                 return iter->second.bHasAdminDir;
 463                         }
 464                 }
 465                 CString sProjectRoot;
 466                 BOOL hasAdminDir = g_GitAdminDir.HasAdminDir(buf, true, &sProjectRoot);
 467                 admindirticker = GetTickCount();
 468                 Locker lock(m_critSec);
 469
 470                 AdminDir_s &ad = admindircache[buf];
 471                 ad.bHasAdminDir = hasAdminDir;
 472                 if (hasAdminDir)
 473                 {
 474                         ad.sProjectRoot.assign(sProjectRoot);
 475
 476                         if (ProjectTopDir)
 477                                 *ProjectTopDir = sProjectRoot;
 478                 }
 479
 480                 delete [] buf;
 481                 return hasAdminDir;
 482         }
 483         bool IsColumnsEveryWhere()
 484         {
 485                 if ((GetTickCount() - REGISTRYTIMEOUT) > columnseverywhereticker)
 486                 {
 487                         columnseverywhereticker = GetTickCount();
 488                         columnseverywhere.read();
 489                 }
 490                 return !!(DWORD)columnseverywhere;
 491         }
 492 private:
 493         void DriveValid()
 494         {
 495                 if ((GetTickCount() - REGISTRYTIMEOUT)>driveticker)
 496                 {
 497                         driveticker = GetTickCount();
 498                         driveremote.read();
 499                         drivefixed.read();
 500                         drivecdrom.read();
 501                         driveremove.read();
 502                         drivefloppy.read();
 503                 }
 504         }
 505         void ExcludeContextValid()
 506         {
 507                 if ((GetTickCount() - EXCLUDELISTTIMEOUT)>excontextticker)
 508                 {
 509                         Locker lock(m_critSec);
 510                         excontextticker = GetTickCount();
 511                         nocontextpaths.read();
 512                         if (excludecontextstr.compare((stdstring)nocontextpaths)==0)
 513                                 return;
 514                         excludecontextstr = (stdstring)nocontextpaths;
 515                         excontextvector.clear();
 516                         size_t pos = 0, pos_ant = 0;
 517                         pos = excludecontextstr.find(_T("\n"), pos_ant);
 518                         while (pos != stdstring::npos)
 519                         {
 520                                 stdstring token = excludecontextstr.substr(pos_ant, pos-pos_ant);
 521                                 excontextvector.push_back(token);
 522                                 pos_ant = pos+1;
 523                                 pos = excludecontextstr.find(_T("\n"), pos_ant);
 524                         }
 525                         if (!excludecontextstr.empty())
 526                         {
 527                                 excontextvector.push_back(excludecontextstr.substr(pos_ant, excludecontextstr.size()-1));
 528                         }
 529                         excludecontextstr = (stdstring)nocontextpaths;
 530                 }
 531         }
 532         void ExcludeListValid()
 533         {
 534                 if ((GetTickCount() - EXCLUDELISTTIMEOUT)>excludelistticker)
 535                 {
 536                         Locker lock(m_critSec);
 537                         excludelistticker = GetTickCount();
 538                         excludelist.read();
 539                         if (excludeliststr.compare((stdstring)excludelist)==0)
 540                                 return;
 541                         excludeliststr = (stdstring)excludelist;
 542                         exvector.clear();
 543                         size_t pos = 0, pos_ant = 0;
 544                         pos = excludeliststr.find(_T("\n"), pos_ant);
 545                         while (pos != stdstring::npos)
 546                         {
 547                                 stdstring token = excludeliststr.substr(pos_ant, pos-pos_ant);
 548                                 exvector.push_back(token);
 549                                 pos_ant = pos+1;
 550                                 pos = excludeliststr.find(_T("\n"), pos_ant);
 551                         }
 552                         if (!excludeliststr.empty())
 553                         {
 554                                 exvector.push_back(excludeliststr.substr(pos_ant, excludeliststr.size()-1));
 555                         }
 556                         excludeliststr = (stdstring)excludelist;
 557                 }
 558         }
 559         void IncludeListValid()
 560         {
 561                 if ((GetTickCount() - EXCLUDELISTTIMEOUT)>includelistticker)
 562                 {
 563                         Locker lock(m_critSec);
 564                         includelistticker = GetTickCount();
 565                         includelist.read();
 566                         if (includeliststr.compare((stdstring)includelist)==0)
 567                                 return;
 568                         includeliststr = (stdstring)includelist;
 569                         invector.clear();
 570                         size_t pos = 0, pos_ant = 0;
 571                         pos = includeliststr.find(_T("\n"), pos_ant);
 572                         while (pos != stdstring::npos)
 573                         {
 574                                 stdstring token = includeliststr.substr(pos_ant, pos-pos_ant);
 575                                 invector.push_back(token);
 576                                 pos_ant = pos+1;
 577                                 pos = includeliststr.find(_T("\n"), pos_ant);
 578                         }
 579                         if (!includeliststr.empty())
 580                         {
 581                                 invector.push_back(includeliststr.substr(pos_ant, includeliststr.size()-1));
 582                         }
 583                         includeliststr = (stdstring)includelist;
 584                 }
 585         }
 586
 587         struct AdminDir_s
 588         {
 589                 BOOL bHasAdminDir;
 590                 stdstring sProjectRoot;
 591         };
 592
 593         CRegStdWORD cachetype;
 594         CRegStdWORD blockstatus;
 595         CRegStdWORD langid;
 596         CRegStdWORD showrecursive;
 597         CRegStdWORD folderoverlay;
 598         CRegStdWORD getlocktop;
 599         CRegStdWORD driveremote;
 600         CRegStdWORD drivefixed;
 601         CRegStdWORD drivecdrom;
 602         CRegStdWORD driveremove;
 603         CRegStdWORD drivefloppy;
 604         CRegStdWORD driveram;
 605         CRegStdWORD driveunknown;
 606         CRegStdWORD menulayoutlow;
 607         CRegStdWORD menulayouthigh;
 608         CRegStdWORD simplecontext;
 609         CRegStdWORD menumasklow_lm;
 610         CRegStdWORD menumaskhigh_lm;
 611         CRegStdWORD menumasklow_cu;
 612         CRegStdWORD menumaskhigh_cu;
 613         CRegStdWORD unversionedasmodified;
 614         CRegStdWORD showunversionedoverlay;
 615         CRegStdWORD showignoredoverlay;
 616         CRegStdWORD excludedasnormal;
 617         CRegStdString excludelist;
 618         CRegStdWORD columnseverywhere;
 619         stdstring excludeliststr;
 620         std::vector<stdstring> exvector;
 621         CRegStdString includelist;
 622         stdstring includeliststr;
 623         std::vector<stdstring> invector;
 624         DWORD cachetypeticker;
 625         DWORD recursiveticker;
 626         DWORD folderoverlayticker;
 627         DWORD getlocktopticker;
 628         DWORD driveticker;
 629         DWORD drivetypeticker;
 630         DWORD layoutticker;
 631         DWORD menumaskticker;
 632         DWORD langticker;
 633         DWORD blockstatusticker;
 634         DWORD columnrevformatticker;
 635         DWORD excludelistticker;
 636         DWORD includelistticker;
 637         DWORD simplecontextticker;
 638         DWORD unversionedasmodifiedticker;
 639         DWORD showunversionedoverlayticker;
 640         DWORD showignoredoverlayticker;
 641         DWORD excludedasnormalticker;
 642         DWORD columnseverywhereticker;
 643         UINT  drivetypecache[27];
 644         TCHAR drivetypepathcache[MAX_PATH];             // MAX_PATH ok.
 645         NUMBERFMT columnrevformat;
 646         TCHAR szDecSep[5];
 647         TCHAR szThousandsSep[5];
 648         std::map<stdstring, AdminDir_s> admindircache;
 649         stdstring sAdminDirCacheKey;
 650         CRegStdString nocontextpaths;
 651         stdstring excludecontextstr;
 652         std::vector<stdstring> excontextvector;
 653         DWORD excontextticker;
 654         DWORD admindirticker;
 655         CComCriticalSection m_critSec;
 656 };