src/TortoiseShell/IconOverlay.cpp

   1 // TortoiseSVN - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2008 - TortoiseSVN
   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 #include "stdafx.h"
  20 #include "ShellExt.h"
  21 #include "Guids.h"
  22 #include "PreserveChdir.h"
  23 #include "UnicodeUtils.h"
  24 #include "GitStatus.h"
  25 #include "..\TGitCache\CacheInterface.h"
  26
  27 // "The Shell calls IShellIconOverlayIdentifier::GetOverlayInfo to request the
  28 //  location of the handler's icon overlay. The icon overlay handler returns
  29 //  the name of the file containing the overlay image, and its index within
  30 //  that file. The Shell then adds the icon overlay to the system image list."
  31
  32 STDMETHODIMP CShellExt::GetOverlayInfo(LPWSTR /*pwszIconFile*/, int /*cchMax*/, int * /*pIndex*/, DWORD * /*pdwFlags*/)
  33 {
  34         PreserveChdir preserveChdir;
  35
  36         // Now here's where we can find out if due to lack of enough overlay
  37         // slots some of our overlays won't be shown.
  38         // To do that we have to mark every overlay handler that's successfully
  39         // loaded, so we can later check if some are missing
  40         switch (m_State)
  41         {
  42                 case FileStateVersioned                         : g_normalovlloaded = true; break;
  43                 case FileStateModified                          : g_modifiedovlloaded = true; break;
  44                 case FileStateConflict                          : g_conflictedovlloaded = true; break;
  45                 case FileStateDeleted                           : g_deletedovlloaded = true; break;
  46                 case FileStateReadOnly                          : g_readonlyovlloaded = true; break;
  47                 case FileStateLockedOverlay                     : g_lockedovlloaded = true; break;
  48                 case FileStateAddedOverlay                      : g_addedovlloaded = true; break;
  49                 case FileStateIgnoredOverlay            : g_ignoredovlloaded = true; break;
  50                 case FileStateUnversionedOverlay        : g_unversionedovlloaded = true; break;
  51         }
  52
  53         // we don't have to set the icon file and/or the index here:
  54         // the icons are handled by the TortoiseOverlays dll.
  55     return S_OK;
  56 };
  57
  58 STDMETHODIMP CShellExt::GetPriority(int *pPriority)
  59 {
  60         switch (m_State)
  61         {
  62                 case FileStateConflict:
  63                         *pPriority = 0;
  64                         break;
  65                 case FileStateModified:
  66                         *pPriority = 1;
  67                         break;
  68                 case FileStateDeleted:
  69                         *pPriority = 2;
  70                         break;
  71                 case FileStateReadOnly:
  72                         *pPriority = 3;
  73                         break;
  74                 case FileStateLockedOverlay:
  75                         *pPriority = 4;
  76                         break;
  77                 case FileStateAddedOverlay:
  78                         *pPriority = 5;
  79                         break;
  80                 case FileStateVersioned:
  81                         *pPriority = 6;
  82                         break;
  83                 default:
  84                         *pPriority = 100;
  85                         return S_FALSE;
  86         }
  87     return S_OK;
  88 }
  89
  90 // "Before painting an object's icon, the Shell passes the object's name to
  91 //  each icon overlay handler's IShellIconOverlayIdentifier::IsMemberOf
  92 //  method. If a handler wants to have its icon overlay displayed,
  93 //  it returns S_OK. The Shell then calls the handler's
  94 //  IShellIconOverlayIdentifier::GetOverlayInfo method to determine which icon
  95 //  to display."
  96
  97 STDMETHODIMP CShellExt::IsMemberOf(LPCWSTR pwszPath, DWORD /*dwAttrib*/)
  98 {
  99         PreserveChdir preserveChdir;
 100         git_wc_status_kind status = git_wc_status_none;
 101         bool readonlyoverlay = false;
 102         bool lockedoverlay = false;
 103         if (pwszPath == NULL)
 104                 return S_FALSE;
 105         const TCHAR* pPath = pwszPath;
 106
 107         // the shell sometimes asks overlays for invalid paths, e.g. for network
 108         // printers (in that case the path is "0", at least for me here).
 109         if (_tcslen(pPath)<2)
 110                 return S_FALSE;
 111         // since the shell calls each and every overlay handler with the same filepath
 112         // we use a small 'fast' cache of just one path here.
 113         // To make sure that cache expires, clear it as soon as one handler is used.
 114
 115         AutoLocker lock(g_csGlobalCOMGuard);
 116         if (_tcscmp(pPath, g_filepath.c_str())==0)
 117         {
 118                 status = g_filestatus;
 119                 readonlyoverlay = g_readonlyoverlay;
 120                 lockedoverlay = g_lockedoverlay;
 121         }
 122         else
 123         {
 124                 if (!g_ShellCache.IsPathAllowed(pPath))
 125                 {
 126                         int drivenumber = -1;
 127                         if ((m_State == FileStateVersioned) && g_ShellCache.ShowExcludedAsNormal() &&
 128                                 ((drivenumber=PathGetDriveNumber(pPath))!=0)&&(drivenumber!=1) &&
 129                                 PathIsDirectory(pPath) && g_ShellCache.HasSVNAdminDir(pPath, true))
 130                         {
 131                                 return S_OK;
 132                         }
 133                         return S_FALSE;
 134                 }
 135
 136                 switch (g_ShellCache.GetCacheType())
 137                 {
 138                 case ShellCache::exe:
 139                         {
 140                                 CTGitPath tpath(pPath);
 141                                 if(!tpath.HasAdminDir())
 142                                 {
 143                                         status = git_wc_status_none;
 144                                         break;
 145                                 }
 146                                 if(tpath.IsAdminDir())
 147                                 {
 148                                         status = git_wc_status_none;
 149                                         break;
 150                                 }
 151                                 TSVNCacheResponse itemStatus;
 152                                 SecureZeroMemory(&itemStatus, sizeof(itemStatus));
 153                                 if (m_remoteCacheLink.GetStatusFromRemoteCache(tpath, &itemStatus, true))
 154                                 {
 155                                         status = GitStatus::GetMoreImportant(itemStatus.m_status.text_status, itemStatus.m_status.prop_status);
 156 /*                                      if ((itemStatus.m_kind == git_node_file)&&(status == git_wc_status_normal)&&((itemStatus.m_needslock && itemStatus.m_owner[0]==0)||(itemStatus.m_readonly)))
 157                                                 readonlyoverlay = true;
 158                                         if (itemStatus.m_owner[0]!=0)
 159                                                 lockedoverlay = true;*/
 160                                 }
 161                         }
 162                         break;
 163                 case ShellCache::dll:
 164                 case ShellCache::dllFull:
 165                         {
 166                                 // Look in our caches for this item
 167                                 const FileStatusCacheEntry * s = m_CachedStatus.GetCachedItem(CTGitPath(pPath));
 168                                 if (s)
 169                                 {
 170                                         status = s->status;
 171                                 }
 172                                 else
 173                                 {
 174                                         // No cached status available
 175
 176                                         // since the dwAttrib param of the IsMemberOf() function does not
 177                                         // have the SFGAO_FOLDER flag set at all (it's 0 for files and folders!)
 178                                         // we have to check if the path is a folder ourselves :(
 179                                         if (PathIsDirectory(pPath))
 180                                         {
 181                                                 if (g_ShellCache.HasSVNAdminDir(pPath, TRUE))
 182                                                 {
 183                                                         if ((!g_ShellCache.IsRecursive()) && (!g_ShellCache.IsFolderOverlay()))
 184                                                         {
 185                                                                 status = git_wc_status_normal;
 186                                                         }
 187                                                         else
 188                                                         {
 189                                                                 const FileStatusCacheEntry * s = m_CachedStatus.GetFullStatus(CTGitPath(pPath), TRUE);
 190                                                                 status = s->status;
 191                                                                 // GitFolderStatus does not list unversioned files/dir so they would always end up as normal below
 192                                                                 // so let's assume file/dir is unversioned if not found in cache
 193                                                                 /*// sub-dirs that are empty (or contain no versioned files) are reported as unversioned (and should be kept as such)
 194                                                                 if (status != git_wc_status_unversioned)
 195                                                                 {
 196                                                                         // if get status fails then display status as 'normal' on folder (since it contains .git)
 197                                                                         // TODO: works for svn since each folder has .svn, not sure if git needs additinoal processing
 198                                                                         status = GitStatus::GetMoreImportant(git_wc_status_normal, status);
 199                                                                 }*/
 200                                                         }
 201                                                 }
 202                                                 else
 203                                                 {
 204                                                         status = git_wc_status_none;
 205                                                 }
 206                                         }
 207                                         else
 208                                         {
 209                                                 const FileStatusCacheEntry * s = m_CachedStatus.GetFullStatus(CTGitPath(pPath), FALSE);
 210                                                 status = s->status;
 211                                         }
 212                                 }
 213                                 if ((s)&&(status == git_wc_status_normal)&&(s->needslock)&&(s->owner[0]==0))
 214                                         readonlyoverlay = true;
 215                                 if ((s)&&(s->owner[0]!=0))
 216                                         lockedoverlay = true;
 217                         }
 218
 219                         // index based version does not enumerate unversioned files, so default to unversioned
 220                         if (g_ShellCache.GetCacheType() == ShellCache::dll
 221                                 && status == git_wc_status_none && g_ShellCache.HasSVNAdminDir(pPath, true))
 222                                 status = git_wc_status_unversioned;
 223                         break;
 224                 default:
 225                 case ShellCache::none:
 226                         {
 227                                 // no cache means we only show a 'versioned' overlay on folders
 228                                 // with an admin directory
 229                                 if (PathIsDirectory(pPath))
 230                                 {
 231                                         if (g_ShellCache.HasSVNAdminDir(pPath, TRUE))
 232                                         {
 233                                                 status = git_wc_status_normal;
 234                                         }
 235                                         else
 236                                         {
 237                                                 status = git_wc_status_none;
 238                                         }
 239                                 }
 240                                 else
 241                                 {
 242                                         status = git_wc_status_none;
 243                                 }
 244                         }
 245                         break;
 246                 }
 247                 ATLTRACE(_T("Status %d for file %s\n"), status, pwszPath);
 248         }
 249         g_filepath.clear();
 250         g_filepath = pPath;
 251         g_filestatus = status;
 252         g_readonlyoverlay = readonlyoverlay;
 253         g_lockedoverlay = lockedoverlay;
 254
 255         //the priority system of the shell doesn't seem to work as expected (or as I expected):
 256         //as it seems that if one handler returns S_OK then that handler is used, no matter
 257         //if other handlers would return S_OK too (they're never called on my machine!)
 258         //So we return S_OK for ONLY ONE handler!
 259
 260         switch (status)
 261         {
 262                 // note: we can show other overlays if due to lack of enough free overlay
 263                 // slots some of our overlays aren't loaded. But we assume that
 264                 // at least the 'normal' and 'modified' overlay are available.
 265                 case git_wc_status_none:
 266                         return S_FALSE;
 267                 case git_wc_status_unversioned:
 268                         if (g_ShellCache.ShowUnversionedOverlay() && g_unversionedovlloaded && (m_State == FileStateUnversionedOverlay))
 269                         {
 270                                 g_filepath.clear();
 271                                 return S_OK;
 272                         }
 273                         return S_FALSE;
 274                 case git_wc_status_ignored:
 275                         if (g_ShellCache.ShowIgnoredOverlay() && g_ignoredovlloaded && (m_State == FileStateIgnoredOverlay))
 276                         {
 277                                 g_filepath.clear();
 278                                 return S_OK;
 279                         }
 280                         return S_FALSE;
 281                 case git_wc_status_normal:
 282                 case git_wc_status_external:
 283                 case git_wc_status_incomplete:
 284                         if ((readonlyoverlay)&&(g_readonlyovlloaded))
 285                         {
 286                                 if (m_State == FileStateReadOnly)
 287                                 {
 288                                         g_filepath.clear();
 289                                         return S_OK;
 290                                 }
 291                                 else
 292                                         return S_FALSE;
 293                         }
 294                         else if ((lockedoverlay)&&(g_lockedovlloaded))
 295                         {
 296                                 if (m_State == FileStateLockedOverlay)
 297                                 {
 298                                         g_filepath.clear();
 299                                         return S_OK;
 300                                 }
 301                                 else
 302                                         return S_FALSE;
 303                         }
 304                         else if (m_State == FileStateVersioned)
 305                         {
 306                                 g_filepath.clear();
 307                                 return S_OK;
 308                         }
 309                         else
 310                                 return S_FALSE;
 311                 case git_wc_status_missing:
 312                 case git_wc_status_deleted:
 313                         if (g_deletedovlloaded)
 314                         {
 315                                 if (m_State == FileStateDeleted)
 316                                 {
 317                                         g_filepath.clear();
 318                                         return S_OK;
 319                                 }
 320                                 else
 321                                         return S_FALSE;
 322                         }
 323                         else
 324                         {
 325                                 // the 'deleted' overlay isn't available (due to lack of enough
 326                                 // overlay slots). So just show the 'modified' overlay instead.
 327                                 if (m_State == FileStateModified)
 328                                 {
 329                                         g_filepath.clear();
 330                                         return S_OK;
 331                                 }
 332                                 else
 333                                         return S_FALSE;
 334                         }
 335                 case git_wc_status_replaced:
 336                 case git_wc_status_modified:
 337                         if (m_State == FileStateModified)
 338                         {
 339                                 g_filepath.clear();
 340                                 return S_OK;
 341                         }
 342                         else
 343                                 return S_FALSE;
 344                 case git_wc_status_merged:
 345                         if (m_State == FileStateReadOnly)
 346                         {
 347                                 g_filepath.clear();
 348                                 return S_OK;
 349                         }
 350                         else
 351                                 return S_FALSE;
 352                 case git_wc_status_added:
 353                         if (g_addedovlloaded)
 354                         {
 355                                 if (m_State== FileStateAddedOverlay)
 356                                 {
 357                                         g_filepath.clear();
 358                                         return S_OK;
 359                                 }
 360                                 else
 361                                         return S_FALSE;
 362                         }
 363                         else
 364                         {
 365                                 // the 'added' overlay isn't available (due to lack of enough
 366                                 // overlay slots). So just show the 'modified' overlay instead.
 367                                 if (m_State == FileStateModified)
 368                                 {
 369                                         g_filepath.clear();
 370                                         return S_OK;
 371                                 }
 372                                 else
 373                                         return S_FALSE;
 374                         }
 375                 case git_wc_status_conflicted:
 376                 case git_wc_status_obstructed:
 377                         if (g_conflictedovlloaded)
 378                         {
 379                                 if (m_State == FileStateConflict)
 380                                 {
 381                                         g_filepath.clear();
 382                                         return S_OK;
 383                                 }
 384                                 else
 385                                         return S_FALSE;
 386                         }
 387                         else
 388                         {
 389                                 // the 'conflicted' overlay isn't available (due to lack of enough
 390                                 // overlay slots). So just show the 'modified' overlay instead.
 391                                 if (m_State == FileStateModified)
 392                                 {
 393                                         g_filepath.clear();
 394                                         return S_OK;
 395                                 }
 396                                 else
 397                                         return S_FALSE;
 398                         }
 399                 default:
 400                         return S_FALSE;
 401         } // switch (status)
 402     //return S_FALSE;
 403 }
 404