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