src/Utils/MiscUI/SysProgressDlg.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2010-2012 - TortoiseGit
   4 // Copyright (C) 2003-2006,2008-2011 - TortoiseSVN
   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 #include "stdafx.h"
  21 #include "SysProgressDlg.h"
  22
  23 CSysProgressDlg::CSysProgressDlg()
  24         : m_pIDlg(NULL)
  25         , m_isVisible(false)
  26         , m_dwDlgFlags(PROGDLG_NORMAL)
  27         , m_hWndProgDlg(NULL)
  28         , m_hWndParent(NULL)
  29 {
  30         EnsureValid();
  31 }
  32
  33 CSysProgressDlg::~CSysProgressDlg()
  34 {
  35         if (IsValid())
  36         {
  37                 if (m_isVisible)                        //still visible, so stop first before destroying
  38                         m_pIDlg->StopProgressDialog();
  39
  40                 m_pIDlg.Release();
  41                 m_hWndProgDlg = NULL;
  42         }
  43 }
  44
  45 bool CSysProgressDlg::EnsureValid()
  46 {
  47         if(IsValid())
  48                 return true;
  49
  50         HRESULT hr = m_pIDlg.CoCreateInstance (CLSID_ProgressDialog, NULL, CLSCTX_INPROC_SERVER);
  51         return (SUCCEEDED(hr));
  52 }
  53
  54 void CSysProgressDlg::SetTitle(LPCTSTR szTitle)
  55 {
  56         USES_CONVERSION;
  57         if (IsValid())
  58         {
  59                 m_pIDlg->SetTitle(T2COLE(szTitle));
  60         }
  61 }
  62 void CSysProgressDlg::SetTitle ( UINT idTitle)
  63 {
  64         SetTitle(CString(MAKEINTRESOURCE(idTitle)));
  65 }
  66
  67 void CSysProgressDlg::SetLine(DWORD dwLine, LPCTSTR szText, bool bCompactPath /* = false */)
  68 {
  69         USES_CONVERSION;
  70         if (IsValid())
  71         {
  72                 m_pIDlg->SetLine(dwLine, T2COLE(szText), bCompactPath, NULL);
  73         }
  74 }
  75
  76 #ifdef _MFC_VER
  77 void CSysProgressDlg::SetCancelMsg ( UINT idMessage )
  78 {
  79         SetCancelMsg(CString(MAKEINTRESOURCE(idMessage)));
  80 }
  81 #endif // _MFC_VER
  82
  83 void CSysProgressDlg::SetCancelMsg(LPCTSTR szMessage)
  84 {
  85         USES_CONVERSION;
  86         if (IsValid())
  87         {
  88                 m_pIDlg->SetCancelMsg(T2COLE(szMessage), NULL);
  89         }
  90 }
  91
  92 void CSysProgressDlg::SetAnimation(HINSTANCE hinst, UINT uRsrcID)
  93 {
  94         if (IsValid())
  95         {
  96                 m_pIDlg->SetAnimation(hinst, uRsrcID);
  97         }
  98 }
  99 #ifdef _MFC_VER
 100 void CSysProgressDlg::SetAnimation(UINT uRsrcID)
 101 {
 102         if (IsValid())
 103         {
 104                 m_pIDlg->SetAnimation(AfxGetResourceHandle(), uRsrcID);
 105         }
 106 }
 107 #endif
 108 void CSysProgressDlg::SetTime(bool bTime /* = true */)
 109 {
 110         m_dwDlgFlags &= ~(PROGDLG_NOTIME | PROGDLG_AUTOTIME);
 111
 112         if (bTime)
 113                 m_dwDlgFlags |= PROGDLG_AUTOTIME;
 114         else
 115                 m_dwDlgFlags |= PROGDLG_NOTIME;
 116 }
 117
 118 void CSysProgressDlg::SetShowProgressBar(bool bShow /* = true */)
 119 {
 120         if (bShow)
 121                 m_dwDlgFlags &= ~PROGDLG_NOPROGRESSBAR;
 122         else
 123                 m_dwDlgFlags |= PROGDLG_NOPROGRESSBAR;
 124 }
 125 #ifdef _MFC_VER
 126 HRESULT CSysProgressDlg::ShowModal (CWnd* pwndParent, BOOL immediately /* = true */)
 127 {
 128         EnsureValid();
 129         return ShowModal(pwndParent->GetSafeHwnd(), immediately);
 130 }
 131
 132 HRESULT CSysProgressDlg::ShowModeless(CWnd* pwndParent, BOOL immediately)
 133 {
 134         EnsureValid();
 135         return ShowModeless(pwndParent->GetSafeHwnd(), immediately);
 136 }
 137
 138 void CSysProgressDlg::FormatPathLine ( DWORD dwLine, UINT idFormatText, ...)
 139 {
 140         va_list args;
 141         va_start(args, idFormatText);
 142
 143         CString sText;
 144         sText.FormatV(CString(MAKEINTRESOURCE(idFormatText)), args);
 145         SetLine(dwLine, sText, true);
 146
 147         va_end(args);
 148 }
 149
 150 void CSysProgressDlg::FormatPathLine ( DWORD dwLine, CString FormatText, ...)
 151 {
 152         va_list args;
 153         va_start(args, FormatText);
 154
 155         CString sText;
 156         sText.FormatV(FormatText, args);
 157         SetLine(dwLine, sText, true);
 158
 159         va_end(args);
 160 }
 161
 162 void CSysProgressDlg::FormatNonPathLine(DWORD dwLine, UINT idFormatText, ...)
 163 {
 164         va_list args;
 165         va_start(args, idFormatText);
 166
 167         CString sText;
 168         sText.FormatV(CString(MAKEINTRESOURCE(idFormatText)), args);
 169         SetLine(dwLine, sText, false);
 170
 171         va_end(args);
 172 }
 173
 174 void CSysProgressDlg::FormatNonPathLine(DWORD dwLine, CString FormatText, ...)
 175 {
 176         va_list args;
 177         va_start(args, FormatText);
 178
 179         CString sText;
 180         sText.FormatV(FormatText, args);
 181         SetLine(dwLine, sText, false);
 182
 183         va_end(args);
 184 }
 185
 186 #endif
 187 HRESULT CSysProgressDlg::ShowModal(HWND hWndParent, BOOL immediately /* = true */)
 188 {
 189         EnsureValid();
 190         m_hWndProgDlg = NULL;
 191         if (!IsValid())
 192                 return E_FAIL;
 193         m_hWndParent = hWndParent;
 194         HRESULT hr = m_pIDlg->StartProgressDialog(hWndParent, NULL, m_dwDlgFlags | PROGDLG_MODAL, NULL);
 195         if(FAILED(hr))
 196                 return hr;
 197
 198         ATL::CComPtr<IOleWindow> pOleWindow;
 199         HRESULT hr2 = m_pIDlg.QueryInterface(&pOleWindow);
 200         if(SUCCEEDED(hr2))
 201         {
 202                 hr2 = pOleWindow->GetWindow(&m_hWndProgDlg);
 203                 if(SUCCEEDED(hr2))
 204                 {
 205                         // StartProgressDialog creates a new thread to host the progress window.
 206                         // When the window receives WM_DESTROY message StopProgressDialog() wrongly
 207                         // attempts to re-enable the parent in the calling thread (our thread),
 208                         // after the progress window is destroyed and the progress thread has died.
 209                         // When the progress window dies, the system tries to assign a new foreground window.
 210                         // It cannot assign to hwndParent because StartProgressDialog (w/PROGDLG_MODAL) disabled the parent window.
 211                         // So the system hands the foreground activation to the next process that wants it in the
 212                         // system foreground queue. Thus we lose our right to recapture the foreground window.
 213                         // The way to fix this bug is to insert a call to EnableWindow(hWndParent) in the WM_DESTROY
 214                         // handler for the progress window in the progress thread.
 215
 216                         // To do that, we Subclass the progress dialog
 217                         // Since the window and thread created by the progress dialog object live on a few
 218                         // milliseconds after calling Stop() and Release(), we must not store anything
 219                         // in member variables of this class but must only store everything in the window
 220                         // itself: thus we use SetProp()/GetProp() to store the data.
 221                         if (!m_isVisible)
 222                         {
 223                                 m_OrigProc = (WNDPROC) SetWindowLongPtr(m_hWndProgDlg, GWLP_WNDPROC, (LONG_PTR) fnSubclass);
 224                                 SetProp(m_hWndProgDlg, L"ParentWindow", m_hWndParent);
 225                                 SetProp(m_hWndProgDlg, L"OrigProc", m_OrigProc);
 226                         }
 227                         if(immediately)
 228                                 ShowWindow(m_hWndProgDlg, SW_SHOW);
 229                 }
 230         }
 231
 232         m_isVisible = true;
 233         return hr;
 234 }
 235
 236 HRESULT CSysProgressDlg::ShowModeless(HWND hWndParent, BOOL immediately)
 237 {
 238         EnsureValid();
 239         m_hWndProgDlg = NULL;
 240         if (!IsValid())
 241                 return E_FAIL;
 242         m_hWndParent = hWndParent;
 243         HRESULT hr = m_pIDlg->StartProgressDialog(hWndParent, NULL, m_dwDlgFlags, NULL);
 244         if(FAILED(hr))
 245                 return hr;
 246
 247         ATL::CComPtr<IOleWindow> pOleWindow;
 248         HRESULT hr2 = m_pIDlg.QueryInterface(&pOleWindow);
 249         if(SUCCEEDED(hr2))
 250         {
 251                 hr2 = pOleWindow->GetWindow(&m_hWndProgDlg);
 252                 if(SUCCEEDED(hr2))
 253                 {
 254                         // see comment in ShowModal() for why we subclass the window
 255                         if (!m_isVisible)
 256                         {
 257                                 m_OrigProc = (WNDPROC) SetWindowLongPtr(m_hWndProgDlg, GWLP_WNDPROC, (LONG_PTR) fnSubclass);
 258                                 SetProp(m_hWndProgDlg, L"ParentWindow", m_hWndParent);
 259                                 SetProp(m_hWndProgDlg, L"OrigProc", m_OrigProc);
 260                         }
 261                         if (immediately)
 262                                 ShowWindow(m_hWndProgDlg, SW_SHOW);
 263                 }
 264         }
 265         m_isVisible = true;
 266         return hr;
 267 }
 268
 269 void CSysProgressDlg::SetProgress(DWORD dwProgress, DWORD dwMax)
 270 {
 271         if (IsValid())
 272         {
 273                 m_pIDlg->SetProgress(dwProgress, dwMax);
 274         }
 275 }
 276
 277 void CSysProgressDlg::SetProgress64(ULONGLONG u64Progress, ULONGLONG u64ProgressMax)
 278 {
 279         if (IsValid())
 280         {
 281                 m_pIDlg->SetProgress64(u64Progress, u64ProgressMax);
 282         }
 283 }
 284
 285 bool CSysProgressDlg::HasUserCancelled()
 286 {
 287         if (!IsValid())
 288                 return false;
 289
 290         return (0 != m_pIDlg->HasUserCancelled());
 291 }
 292
 293 void CSysProgressDlg::Stop()
 294 {
 295         if ((m_isVisible)&&(IsValid()))
 296         {
 297                 m_pIDlg->StopProgressDialog();
 298                 // Sometimes the progress dialog sticks around after stopping it,
 299                 // until the mouse pointer is moved over it or some other triggers.
 300                 // We hide the window here immediately.
 301                 if (m_hWndProgDlg)
 302                 {
 303                         ShowWindow(m_hWndProgDlg, SW_HIDE);
 304                 }
 305                 m_isVisible = false;
 306                 m_pIDlg.Release();
 307
 308                 m_hWndProgDlg = NULL;
 309         }
 310 }
 311
 312 void CSysProgressDlg::ResetTimer()
 313 {
 314         if (IsValid())
 315         {
 316                 m_pIDlg->Timer(PDTIMER_RESET, NULL);
 317         }
 318 }
 319
 320 LRESULT CSysProgressDlg::fnSubclass(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
 321 {
 322         LONG_PTR origproc = (LONG_PTR)GetProp(hwnd, L"OrigProc");
 323         if (uMsg == WM_DESTROY)
 324         {
 325                 HWND hParent = (HWND)GetProp(hwnd, L"ParentWindow");
 326                 EnableWindow(hParent, TRUE);
 327                 SetFocus(hParent);
 328                 SetWindowLongPtr (hwnd, GWLP_WNDPROC, origproc);
 329                 RemoveProp(hwnd, L"ParentWindow");
 330                 RemoveProp(hwnd, L"OrigProc");
 331         }
 332         return CallWindowProc ((WNDPROC)origproc, hwnd, uMsg, wParam, lParam);
 333 }