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