src/TortoiseShell/ShellCache.h

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