src/TortoiseShell/ShellCache.h

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