src/TGitCache/ShellUpdater.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // External Cache Copyright (C) 2005-2008 - TortoiseSVN
   4 // Copyright (C) 2008-2011, 2013, 2015-2017, 2019, 2023 - TortoiseGit
   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
  21 #include "stdafx.h"
  22 #include <ShlObj.h>
  23 #include "GitAdminDir.h"
  24 #include "GitStatusCache.h"
  25
  26 CShellUpdater::CShellUpdater()
  27 {
  28         m_hWakeEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
  29         m_hTerminationEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
  30 }
  31
  32 CShellUpdater::~CShellUpdater()
  33 {
  34         Stop();
  35 }
  36
  37 void CShellUpdater::Stop()
  38 {
  39         InterlockedExchange(&m_bRunning, FALSE);
  40         if (m_hTerminationEvent)
  41         {
  42                 SetEvent(m_hTerminationEvent);
  43                 if(WaitForSingleObject(m_hThread, 200) != WAIT_OBJECT_0)
  44                         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Error terminating shell updater thread\n");
  45         }
  46         m_hThread.CloseHandle();
  47         m_hTerminationEvent.CloseHandle();
  48         m_hWakeEvent.CloseHandle();
  49 }
  50
  51 void CShellUpdater::Initialise()
  52 {
  53         // Don't call Initialize more than once
  54         ATLASSERT(!m_hThread);
  55
  56         // Just start the worker thread.
  57         // It will wait for event being signaled.
  58         // If m_hWakeEvent is already signaled the worker thread
  59         // will behave properly (with normal priority at worst).
  60
  61         InterlockedExchange(&m_bRunning, TRUE);
  62         unsigned int threadId;
  63         m_hThread = reinterpret_cast<HANDLE>(_beginthreadex(nullptr, 0, ThreadEntry, this, 0, &threadId));
  64         SetThreadPriority(m_hThread, THREAD_PRIORITY_LOWEST);
  65 }
  66
  67 void CShellUpdater::AddPathForUpdate(const CTGitPath& path)
  68 {
  69         {
  70                 AutoLocker lock(m_critSec);
  71
  72                 m_pathsToUpdate.push_back(path);
  73
  74                 // set this flag while we are synced
  75                 // with the worker thread
  76                 m_bItemsAddedSinceLastUpdate = true;
  77         }
  78
  79         SetEvent(m_hWakeEvent);
  80 }
  81
  82
  83 unsigned int CShellUpdater::ThreadEntry(void* pContext)
  84 {
  85         reinterpret_cast<CShellUpdater*>(pContext)->WorkerThread();
  86         return 0;
  87 }
  88
  89 void CShellUpdater::WorkerThread()
  90 {
  91         HANDLE hWaitHandles[2];
  92         hWaitHandles[0] = m_hTerminationEvent;
  93         hWaitHandles[1] = m_hWakeEvent;
  94
  95         for(;;)
  96         {
  97                 DWORD waitResult = WaitForMultipleObjects(_countof(hWaitHandles), hWaitHandles, FALSE, INFINITE);
  98
  99                 // exit event/working loop if the first event (m_hTerminationEvent)
 100                 // has been signaled or if one of the events has been abandoned
 101                 // (i.e. ~CShellUpdater() is being executed)
 102                 if(waitResult == WAIT_OBJECT_0 || waitResult == WAIT_ABANDONED_0 || waitResult == WAIT_ABANDONED_0+1)
 103                 {
 104                         // Termination event
 105                         break;
 106                 }
 107                 // wait some time before we notify the shell
 108                 Sleep(50);
 109                 for(;;)
 110                 {
 111                         CTGitPath workingPath;
 112                         if (!m_bRunning)
 113                                 return;
 114                         Sleep(0);
 115                         {
 116                                 AutoLocker lock(m_critSec);
 117                                 if(m_pathsToUpdate.empty())
 118                                 {
 119                                         // Nothing left to do
 120                                         break;
 121                                 }
 122
 123                                 if(m_bItemsAddedSinceLastUpdate)
 124                                 {
 125                                         m_pathsToUpdate.erase(std::unique(m_pathsToUpdate.begin(), m_pathsToUpdate.end(), &CTGitPath::PredLeftEquivalentToRight), m_pathsToUpdate.end());
 126                                         m_bItemsAddedSinceLastUpdate = false;
 127                                 }
 128
 129                                 workingPath = m_pathsToUpdate.front();
 130                                 m_pathsToUpdate.pop_front();
 131                         }
 132                         if (workingPath.IsEmpty())
 133                                 continue;
 134                         CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) L": shell notification for %s\n", workingPath.GetWinPath());
 135                         if (workingPath.IsDirectory())
 136                         {
 137                                 // first send a notification about a sub folder change, so explorer doesn't discard
 138                                 // the folder notification. Since we only know for sure that the git admin
 139                                 // dir is present, we send a notification for that folder.
 140                                 CString admindir(workingPath.GetWinPathString());
 141                                 admindir += L'\\';
 142                                 admindir += GitAdminDir::GetAdminDirName();
 143                                 if(::PathFileExists(admindir))
 144                                         SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_PATH | SHCNF_FLUSHNOWAIT, static_cast<LPCWSTR>(admindir), nullptr);
 145
 146                                 SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_PATH | SHCNF_FLUSHNOWAIT, workingPath.GetWinPath(), nullptr);
 147                                 // Sending an UPDATEDIR notification somehow overwrites/deletes the UPDATEITEM message. And without
 148                                 // that message, the folder overlays in the current view don't get updated without hitting F5.
 149                                 // Drawback is, without UPDATEDIR, the left tree view isn't always updated...
 150
 151                                 //SHChangeNotify(SHCNE_UPDATEDIR, SHCNF_PATH | SHCNF_FLUSHNOWAIT, workingPath.GetWinPath(), nullptr);
 152                         }
 153                         else
 154                                 SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_PATH | SHCNF_FLUSHNOWAIT, workingPath.GetWinPath(), nullptr);
 155                 }
 156         }
 157         _endthread();
 158 }
 159