src/TortoiseProc/CheckForUpdatesDlg.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2008 - TortoiseSVN
   4 // Copyright (C) 2008-2012 - 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 #include "stdafx.h"
  21 #include "TortoiseProc.h"
  22 #include "LoglistCommonResource.h"
  23 #include "..\version.h"
  24 #include "MessageBox.h"
  25 #include ".\checkforupdatesdlg.h"
  26 #include "Registry.h"
  27 #include "AppUtils.h"
  28 #include "TempFile.h"
  29 #include <wintrust.h>
  30 #include <Softpub.h>
  31 #include "SmartHandle.h"
  32 #include "SysInfo.h"
  33 #include "PathUtils.h"
  34 #include "DirFileEnum.h"
  35 #include "ProjectProperties.h"
  36
  37 // Link with Wintrust.lib
  38 #pragma comment (lib, "wintrust")
  39
  40 #define WM_USER_DISPLAYSTATUS   (WM_USER + 1)
  41 #define WM_USER_ENDDOWNLOAD             (WM_USER + 2)
  42 #define WM_USER_FILLCHANGELOG   (WM_USER + 3)
  43
  44 IMPLEMENT_DYNAMIC(CCheckForUpdatesDlg, CStandAloneDialog)
  45 CCheckForUpdatesDlg::CCheckForUpdatesDlg(CWnd* pParent /*=NULL*/)
  46         : CStandAloneDialog(CCheckForUpdatesDlg::IDD, pParent)
  47         , m_bShowInfo(FALSE)
  48         , m_bVisible(FALSE)
  49         , m_pDownloadThread(NULL)
  50 {
  51         m_sUpdateDownloadLink = _T("http://code.google.com/p/tortoisegit/wiki/Download?tm=2");
  52 }
  53
  54 CCheckForUpdatesDlg::~CCheckForUpdatesDlg()
  55 {
  56 }
  57
  58 void CCheckForUpdatesDlg::DoDataExchange(CDataExchange* pDX)
  59 {
  60         CStandAloneDialog::DoDataExchange(pDX);
  61         DDX_Control(pDX, IDC_LINK, m_link);
  62         DDX_Control(pDX, IDC_PROGRESSBAR, m_progress);
  63         DDX_Control(pDX, IDC_LIST_DOWNLOADS, m_ctrlFiles);
  64         DDX_Control(pDX, IDC_BUTTON_UPDATE, m_ctrlUpdate);
  65         DDX_Control(pDX, IDC_LOGMESSAGE, m_cLogMessage);
  66 }
  67
  68 BEGIN_MESSAGE_MAP(CCheckForUpdatesDlg, CStandAloneDialog)
  69         ON_STN_CLICKED(IDC_CHECKRESULT, OnStnClickedCheckresult)
  70         ON_WM_TIMER()
  71         ON_WM_WINDOWPOSCHANGING()
  72         ON_WM_SETCURSOR()
  73         ON_BN_CLICKED(IDC_BUTTON_UPDATE, OnBnClickedButtonUpdate)
  74         ON_MESSAGE(WM_USER_DISPLAYSTATUS, OnDisplayStatus)
  75         ON_MESSAGE(WM_USER_ENDDOWNLOAD, OnEndDownload)
  76         ON_MESSAGE(WM_USER_FILLCHANGELOG, OnFillChangelog)
  77 END_MESSAGE_MAP()
  78
  79 BOOL CCheckForUpdatesDlg::OnInitDialog()
  80 {
  81         CStandAloneDialog::OnInitDialog();
  82         CAppUtils::MarkWindowAsUnpinnable(m_hWnd);
  83
  84         CString temp;
  85         temp.Format(IDS_CHECKNEWER_YOURVERSION, TGIT_VERMAJOR, TGIT_VERMINOR, TGIT_VERMICRO, TGIT_VERBUILD);
  86         SetDlgItemText(IDC_YOURVERSION, temp);
  87
  88         DialogEnableWindow(IDOK, FALSE);
  89
  90         // hide download controls
  91         m_ctrlFiles.ShowWindow(SW_HIDE);
  92         GetDlgItem(IDC_GROUP_DOWNLOADS)->ShowWindow(SW_HIDE);
  93         RECT rectWindow, rectGroupDownloads, rectOKButton;
  94         GetWindowRect(&rectWindow);
  95         GetDlgItem(IDC_GROUP_DOWNLOADS)->GetWindowRect(&rectGroupDownloads);
  96         GetDlgItem(IDOK)->GetWindowRect(&rectOKButton);
  97         LONG bottomDistance = rectWindow.bottom - rectOKButton.bottom;
  98         OffsetRect(&rectOKButton, 0, rectGroupDownloads.top - rectOKButton.top);
  99         rectWindow.bottom = rectOKButton.bottom + bottomDistance;
 100         MoveWindow(&rectWindow);
 101         ::MapWindowPoints(NULL, GetSafeHwnd(), (LPPOINT)&rectOKButton, 2);
 102         GetDlgItem(IDOK)->MoveWindow(&rectOKButton);
 103
 104         temp.LoadString(IDS_STATUSLIST_COLFILE);
 105         m_ctrlFiles.InsertColumn(0, temp, 0, -1);
 106         m_ctrlFiles.InsertColumn(1, temp, 0, -1);
 107         m_ctrlFiles.SetExtendedStyle(LVS_EX_DOUBLEBUFFER | LVS_EX_CHECKBOXES);
 108         m_ctrlFiles.SetColumnWidth(0, 350);
 109         m_ctrlFiles.SetColumnWidth(1, 200);
 110
 111         ProjectProperties pp;
 112         pp.SetCheckRe(_T("[Ii]ssues?:?(\\s*(,|and)?\\s*#?\\d+)+"));
 113         pp.SetBugIDRe(_T("(\\d+)"));
 114         pp.lProjectLanguage = 0;
 115         pp.sUrl = _T("http://code.google.com/p/tortoisegit/issues/detail?id=%BUGID%");
 116         m_cLogMessage.Init(pp);
 117         m_cLogMessage.SetFont((CString)CRegString(_T("Software\\TortoiseGit\\LogFontName"), _T("Courier New")), (DWORD)CRegDWORD(_T("Software\\TortoiseGit\\LogFontSize"), 8));
 118         m_cLogMessage.Call(SCI_SETREADONLY, TRUE);
 119
 120         if (AfxBeginThread(CheckThreadEntry, this)==NULL)
 121         {
 122                 CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
 123         }
 124
 125         SetTimer(100, 1000, NULL);
 126         return TRUE;
 127 }
 128
 129 void CCheckForUpdatesDlg::OnOK()
 130 {
 131         if (m_bThreadRunning || m_pDownloadThread != NULL)
 132                 return; // Don't exit while downloading
 133
 134         CStandAloneDialog::OnOK();
 135 }
 136
 137 void CCheckForUpdatesDlg::OnCancel()
 138 {
 139         if (m_bThreadRunning || m_pDownloadThread != NULL)
 140                 return; // Don't exit while downloading
 141         CStandAloneDialog::OnCancel();
 142 }
 143
 144 UINT CCheckForUpdatesDlg::CheckThreadEntry(LPVOID pVoid)
 145 {
 146         return ((CCheckForUpdatesDlg*)pVoid)->CheckThread();
 147 }
 148
 149 UINT CCheckForUpdatesDlg::CheckThread()
 150 {
 151         m_bThreadRunning = TRUE;
 152
 153         CString temp;
 154         CString tempfile = CTempFiles::Instance().GetTempFilePath(true).GetWinPathString();
 155
 156         CRegString checkurluser = CRegString(_T("Software\\TortoiseGit\\UpdateCheckURL"), _T(""));
 157         CRegString checkurlmachine = CRegString(_T("Software\\TortoiseGit\\UpdateCheckURL"), _T(""), FALSE, HKEY_LOCAL_MACHINE);
 158         CString sCheckURL = checkurluser;
 159         if (sCheckURL.IsEmpty())
 160         {
 161                 sCheckURL = checkurlmachine;
 162                 if (sCheckURL.IsEmpty())
 163                 {
 164                         bool checkPreview = false;
 165 #if PREVIEW
 166                         checkPreview = true;
 167 #else
 168                         CRegStdDWORD regCheckPreview(L"Software\\TortoiseGit\\VersionCheckPreview", FALSE);
 169                         if (DWORD(regCheckPreview))
 170                                 checkPreview = true;
 171 #endif
 172                         if (checkPreview)
 173                                 sCheckURL = _T("http://version.tortoisegit.googlecode.com/git/version-preview.txt");
 174                         else
 175                                 sCheckURL = _T("http://version.tortoisegit.googlecode.com/git/version.txt");
 176                 }
 177         }
 178         CoInitialize(NULL);
 179         HRESULT res = URLDownloadToFile(NULL, sCheckURL, tempfile, 0, NULL);
 180         if (res == S_OK)
 181         {
 182                 try
 183                 {
 184                         CStdioFile file(tempfile, CFile::modeRead | CFile::shareDenyWrite);
 185                         CString ver;
 186                         unsigned int major,minor,micro,build;
 187                         major=minor=micro=build=0;
 188                         unsigned __int64 version=0;
 189
 190                         if (file.ReadString(ver))
 191                         {
 192                                 CString vertemp = ver;
 193                                 // another versionstring for the filename can be provided after a semicolon
 194                                 // this is needed for preview releases
 195                                 int differentFilenamePos = vertemp.Find(_T(";"));
 196                                 if (differentFilenamePos > 0)
 197                                 {
 198                                         vertemp = vertemp.Left(differentFilenamePos);
 199                                         ver = ver.Mid(differentFilenamePos + 1);
 200                                 }
 201
 202                                 major = _ttoi(vertemp);
 203                                 vertemp = vertemp.Mid(vertemp.Find('.')+1);
 204                                 minor = _ttoi(vertemp);
 205                                 vertemp = vertemp.Mid(vertemp.Find('.')+1);
 206                                 micro = _ttoi(vertemp);
 207                                 vertemp = vertemp.Mid(vertemp.Find('.')+1);
 208                                 build = _ttoi(vertemp);
 209                                 version = major;
 210                                 version <<= 16;
 211                                 version += minor;
 212                                 version <<= 16;
 213                                 version += micro;
 214                                 version <<= 16;
 215                                 version += build;
 216                         }
 217
 218                         {
 219                                 BOOL bNewer = FALSE;
 220                                 if (major > TGIT_VERMAJOR)
 221                                         bNewer = TRUE;
 222                                 else if ((minor > TGIT_VERMINOR)&&(major == TGIT_VERMAJOR))
 223                                         bNewer = TRUE;
 224                                 else if ((micro > TGIT_VERMICRO)&&(minor == TGIT_VERMINOR)&&(major == TGIT_VERMAJOR))
 225                                         bNewer = TRUE;
 226                                 else if ((build > TGIT_VERBUILD)&&(micro == TGIT_VERMICRO)&&(minor == TGIT_VERMINOR)&&(major == TGIT_VERMAJOR))
 227                                         bNewer = TRUE;
 228
 229                                 if (version != 0)
 230                                 {
 231                                         CString version;
 232                                         version.Format(_T("%d.%d.%d.%d"),major,minor,micro,build);
 233                                         if (version != ver)
 234                                                 version += _T(" (") + ver + _T(")");
 235                                         temp.Format(IDS_CHECKNEWER_CURRENTVERSION, (LPCTSTR)version);
 236                                         SetDlgItemText(IDC_CURRENTVERSION, temp);
 237                                 }
 238
 239                                 if (version == 0)
 240                                 {
 241                                         temp.LoadString(IDS_CHECKNEWER_NETERROR);
 242                                         SetDlgItemText(IDC_CHECKRESULT, temp);
 243                                 }
 244                                 else if (bNewer)
 245                                 {
 246                                         if(file.ReadString(temp) && !temp.IsEmpty())
 247                                         {       // Read the next line, it could contain a message for the user
 248                                                 CString tempLink;
 249                                                 if(file.ReadString(tempLink) && !tempLink.IsEmpty())
 250                                                 {       // Read another line to find out the download link-URL, if any
 251                                                         m_sUpdateDownloadLink = tempLink;
 252                                                 }
 253                                         }
 254                                         else
 255                                         {
 256                                                 temp.LoadString(IDS_CHECKNEWER_NEWERVERSIONAVAILABLE);
 257                                                 CString tempLink;
 258                                                 file.ReadString(tempLink);
 259                                         }
 260                                         SetDlgItemText(IDC_CHECKRESULT, temp);
 261                                         m_bShowInfo = TRUE;
 262
 263                                         FillChangelog(file);
 264                                         FillDownloads(file, ver);
 265
 266                                         // Show download controls
 267                                         RECT rectWindow, rectProgress, rectGroupDownloads, rectOKButton;
 268                                         GetWindowRect(&rectWindow);
 269                                         m_progress.GetWindowRect(&rectProgress);
 270                                         GetDlgItem(IDC_GROUP_DOWNLOADS)->GetWindowRect(&rectGroupDownloads);
 271                                         GetDlgItem(IDOK)->GetWindowRect(&rectOKButton);
 272                                         LONG bottomDistance = rectWindow.bottom - rectOKButton.bottom;
 273                                         OffsetRect(&rectOKButton, 0, (rectGroupDownloads.bottom + (rectGroupDownloads.bottom - rectProgress.bottom)) - rectOKButton.top);
 274                                         rectWindow.bottom = rectOKButton.bottom + bottomDistance;
 275                                         MoveWindow(&rectWindow);
 276                                         ::MapWindowPoints(NULL, GetSafeHwnd(), (LPPOINT)&rectOKButton, 2);
 277                                         GetDlgItem(IDOK)->MoveWindow(&rectOKButton);
 278                                         m_ctrlFiles.ShowWindow(SW_SHOW);
 279                                         GetDlgItem(IDC_GROUP_DOWNLOADS)->ShowWindow(SW_SHOW);
 280                                         CenterWindow();
 281                                 }
 282                                 else
 283                                 {
 284                                         temp.LoadString(IDS_CHECKNEWER_YOURUPTODATE);
 285                                         SetDlgItemText(IDC_CHECKRESULT, temp);
 286                                         file.ReadString(temp);
 287                                         file.ReadString(temp);
 288                                         FillChangelog(file);
 289                                 }
 290                         }
 291                 }
 292                 catch (CException * e)
 293                 {
 294                         e->Delete();
 295                         temp.LoadString(IDS_CHECKNEWER_NETERROR);
 296                         SetDlgItemText(IDC_CHECKRESULT, temp);
 297                 }
 298         }
 299         else
 300         {
 301                 // Try to cache web page;
 302
 303                 temp.LoadString(IDS_CHECKNEWER_NETERROR);
 304                 SetDlgItemText(IDC_CHECKRESULT, temp);
 305         }
 306         if (!m_sUpdateDownloadLink.IsEmpty())
 307         {
 308                 m_link.ShowWindow(SW_SHOW);
 309                 m_link.SetURL(m_sUpdateDownloadLink);
 310         }
 311
 312         DeleteFile(tempfile);
 313         m_bThreadRunning = FALSE;
 314         DialogEnableWindow(IDOK, TRUE);
 315         return 0;
 316 }
 317
 318 void CCheckForUpdatesDlg::FillDownloads(CStdioFile &file, CString version)
 319 {
 320 #if WIN64
 321         const CString x86x64 = _T("64");
 322 #else
 323         const CString x86x64 = _T("32");
 324 #endif
 325
 326         if (!file.ReadString(m_sFilesURL) || m_sFilesURL.IsEmpty())
 327                 m_sFilesURL = _T("http://tortoisegit.googlecode.com/files/");
 328
 329         m_ctrlFiles.InsertItem(0, _T("TortoiseGit"));
 330         CString filename;
 331         filename.Format(_T("TortoiseGit-%s-%sbit.msi"), version, x86x64);
 332         m_ctrlFiles.SetItemData(0, (DWORD_PTR)(new CUpdateListCtrl::Entry(filename, CUpdateListCtrl::STATUS_NONE)));
 333         m_ctrlFiles.SetCheck(0 , TRUE);
 334
 335         std::vector<DWORD> m_installedLangs;
 336         {
 337                 // set up the language selecting combobox
 338                 CString path = CPathUtils::GetAppParentDirectory();
 339                 path = path + _T("Languages\\");
 340                 CSimpleFileFind finder(path, _T("*.dll"));
 341                 while (finder.FindNextFileNoDirectories())
 342                 {
 343                         CString file = finder.GetFilePath();
 344                         CString filename = finder.GetFileName();
 345                         if (filename.Left(12).CompareNoCase(_T("TortoiseProc")) == 0)
 346                         {
 347                                 CString sVer = _T(STRPRODUCTVER);
 348                                 sVer = sVer.Left(sVer.ReverseFind(','));
 349                                 CString sFileVer = CPathUtils::GetVersionFromFile(file);
 350                                 sFileVer = sFileVer.Left(sFileVer.ReverseFind(','));
 351                                 CString sLoc = filename.Mid(12);
 352                                 sLoc = sLoc.Left(sLoc.GetLength() - 4); // cut off ".dll"
 353                                 if ((sLoc.Left(2) == L"32") && (sLoc.GetLength() > 5))
 354                                         continue;
 355                                 DWORD loc = _tstoi(filename.Mid(12));
 356                                 m_installedLangs.push_back(loc);
 357                         }
 358                 }
 359         }
 360
 361         CString langs;
 362         while (file.ReadString(langs) && !langs.IsEmpty())
 363         {
 364                 CString sLang = _T("TortoiseGit Language Pack ") + langs.Mid(5);
 365
 366                 DWORD loc = _tstoi(langs.Mid(0, 4));
 367                 TCHAR buf[MAX_PATH];
 368                 GetLocaleInfo(loc, LOCALE_SNATIVELANGNAME, buf, _countof(buf));
 369                 CString sLang2(buf);
 370                 GetLocaleInfo(loc, LOCALE_SNATIVECTRYNAME, buf, _countof(buf));
 371                 if (buf[0])
 372                 {
 373                         sLang2 += _T(" (");
 374                         sLang2 += buf;
 375                         sLang2 += _T(")");
 376                 }
 377
 378                 int pos = m_ctrlFiles.InsertItem(m_ctrlFiles.GetItemCount(), sLang);
 379                 m_ctrlFiles.SetItemText(pos, 1, sLang2);
 380
 381                 CString filename;
 382                 filename.Format(_T("TortoiseGit-LanguagePack-%s-%sbit-%s.msi"), version, x86x64, langs.Mid(5));
 383                 m_ctrlFiles.SetItemData(pos, (DWORD_PTR)(new CUpdateListCtrl::Entry(filename, CUpdateListCtrl::STATUS_NONE)));
 384
 385                 if (std::find(m_installedLangs.begin(), m_installedLangs.end(), loc) != m_installedLangs.end())
 386                         m_ctrlFiles.SetCheck(pos , TRUE);
 387         }
 388         DialogEnableWindow(IDC_BUTTON_UPDATE, TRUE);
 389 }
 390
 391 void CCheckForUpdatesDlg::FillChangelog(CStdioFile &file)
 392 {
 393         CString sChangelogURL;
 394         if (!file.ReadString(sChangelogURL) || sChangelogURL.IsEmpty())
 395                 sChangelogURL = _T("http://tortoisegit.googlecode.com/git/src/Changelog.txt");
 396
 397         CString tempchangelogfile = CTempFiles::Instance().GetTempFilePath(true).GetWinPathString();
 398         HRESULT res = URLDownloadToFile(NULL, sChangelogURL, tempchangelogfile, 0, NULL);
 399         if (SUCCEEDED(res))
 400         {
 401                 CString temp;
 402                 CStdioFile file(tempchangelogfile, CFile::modeRead|CFile::typeText);
 403                 CString str;
 404                 while (file.ReadString(str))
 405                 {
 406                         temp += str + _T("\n");
 407                 }
 408                 ::SendMessage(m_hWnd, WM_USER_FILLCHANGELOG, 0, reinterpret_cast<LPARAM>(temp.GetBuffer()));
 409         }
 410         else
 411                 ::SendMessage(m_hWnd, WM_USER_FILLCHANGELOG, 0, reinterpret_cast<LPARAM>(_T("Could not load changelog.")));
 412 }
 413
 414 void CCheckForUpdatesDlg::OnStnClickedCheckresult()
 415 {
 416         // user clicked on the label, start the browser with our web page
 417         HINSTANCE result = ShellExecute(NULL, _T("opennew"), m_sUpdateDownloadLink, NULL,NULL, SW_SHOWNORMAL);
 418         if ((UINT)result <= HINSTANCE_ERROR)
 419         {
 420                 result = ShellExecute(NULL, _T("open"), m_sUpdateDownloadLink, NULL,NULL, SW_SHOWNORMAL);
 421         }
 422 }
 423
 424 void CCheckForUpdatesDlg::OnTimer(UINT_PTR nIDEvent)
 425 {
 426         if (nIDEvent == 100)
 427         {
 428                 if (m_bThreadRunning == FALSE)
 429                 {
 430                         if (m_bShowInfo)
 431                         {
 432                                 m_bVisible = TRUE;
 433                                 ShowWindow(SW_SHOWNORMAL);
 434                         }
 435                         else
 436                         {
 437                                 EndDialog(0);
 438                         }
 439                 }
 440         }
 441         CStandAloneDialog::OnTimer(nIDEvent);
 442 }
 443
 444 void CCheckForUpdatesDlg::OnWindowPosChanging(WINDOWPOS* lpwndpos)
 445 {
 446         CStandAloneDialog::OnWindowPosChanging(lpwndpos);
 447         if (m_bVisible == FALSE)
 448                 lpwndpos->flags &= ~SWP_SHOWWINDOW;
 449 }
 450
 451 BOOL CCheckForUpdatesDlg::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
 452 {
 453         if ((!m_sUpdateDownloadLink.IsEmpty())&&(pWnd)&&(pWnd == GetDlgItem(IDC_CHECKRESULT)))
 454         {
 455                 HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_HAND));
 456                 SetCursor(hCur);
 457                 return TRUE;
 458         }
 459
 460         HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW));
 461         SetCursor(hCur);
 462         return CStandAloneDialogTmpl<CDialog>::OnSetCursor(pWnd, nHitTest, message);
 463 }
 464
 465 void CCheckForUpdatesDlg::OnBnClickedButtonUpdate()
 466 {
 467         CString title;
 468         m_ctrlUpdate.GetWindowText(title);
 469         if (m_pDownloadThread == NULL && title == CString(MAKEINTRESOURCE(IDS_PROC_DOWNLOAD)))
 470         {
 471                 bool isOneSelected = false;
 472                 for (int i = 0; i < (int)m_ctrlFiles.GetItemCount(); i++)
 473                 {
 474                         if (m_ctrlFiles.GetCheck(i))
 475                         {
 476                                 isOneSelected = true;
 477                                 break;
 478                         }
 479                 }
 480                 if (!isOneSelected)
 481                         return;
 482
 483                 m_eventStop.ResetEvent();
 484
 485                 m_pDownloadThread = ::AfxBeginThread(DownloadThreadEntry, this, THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED);
 486                 if (m_pDownloadThread != NULL)
 487                 {
 488                         m_pDownloadThread->m_bAutoDelete = FALSE;
 489                         m_pDownloadThread->ResumeThread();
 490
 491                         GetDlgItem(IDC_BUTTON_UPDATE)->SetWindowText(CString(MAKEINTRESOURCE(IDS_ABORTBUTTON)));
 492                 }
 493                 else
 494                 {
 495                         CMessageBox::Show(NULL, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
 496                 }
 497         }
 498         else if (title == CString(MAKEINTRESOURCE(IDS_ABORTBUTTON)))
 499         {
 500                 // Abort
 501                 m_eventStop.SetEvent();
 502         }
 503         else
 504         {
 505                 CString folder = GetDownloadsDirectory();
 506                 if (m_ctrlUpdate.GetCurrentEntry() == 0)
 507                 {
 508                         for (int i = 0; i < (int)m_ctrlFiles.GetItemCount(); i++)
 509                         {
 510                                 CUpdateListCtrl::Entry *data = (CUpdateListCtrl::Entry *)m_ctrlFiles.GetItemData(i);
 511                                 if (m_ctrlFiles.GetCheck(i) == TRUE)
 512                                         ShellExecute(NULL, _T("open"), folder + data->m_filename, NULL, NULL, SW_SHOWNORMAL);
 513                         }
 514                         CStandAloneDialog::OnOK();
 515                 }
 516                 else if (m_ctrlUpdate.GetCurrentEntry() == 1)
 517                 {
 518                         ShellExecute(NULL, _T("open"), folder, NULL, NULL, SW_SHOWNORMAL);
 519                 }
 520
 521                 m_ctrlUpdate.SetCurrentEntry(0);
 522         }
 523 }
 524
 525 UINT CCheckForUpdatesDlg::DownloadThreadEntry(LPVOID pVoid)
 526 {
 527         return ((CCheckForUpdatesDlg*)pVoid)->DownloadThread();
 528 }
 529
 530 bool CCheckForUpdatesDlg::Download(CString filename)
 531 {
 532         CString destFilename = GetDownloadsDirectory() + filename;
 533         if (PathFileExists(destFilename))
 534         {
 535                 if (VerifySignature(destFilename))
 536                         return true;
 537                 else
 538                         DeleteFile(destFilename);
 539         }
 540
 541         CBSCallbackImpl bsc(this->GetSafeHwnd(), m_eventStop);
 542
 543         CString url = m_sFilesURL + filename;
 544
 545         m_progress.SetRange32(0, 1);
 546         m_progress.SetPos(0);
 547         m_progress.ShowWindow(SW_SHOW);
 548
 549         CString tempfile = CTempFiles::Instance().GetTempFilePath(true).GetWinPathString();
 550         HRESULT res = URLDownloadToFile(NULL, url, tempfile, 0, &bsc);
 551         if (res == S_OK)
 552         {
 553                 if (VerifySignature(tempfile))
 554                 {
 555                         if (PathFileExists(destFilename))
 556                                 DeleteFile(destFilename);
 557                         MoveFile(tempfile, destFilename);
 558                         return true;
 559                 }
 560         }
 561         return false;
 562 }
 563
 564 UINT CCheckForUpdatesDlg::DownloadThread()
 565 {
 566         m_ctrlFiles.SetExtendedStyle(m_ctrlFiles.GetExtendedStyle() & ~LVS_EX_CHECKBOXES);
 567
 568         BOOL result = TRUE;
 569         for (int i = 0; i < (int)m_ctrlFiles.GetItemCount(); i++)
 570         {
 571                 m_ctrlFiles.EnsureVisible(i, FALSE);
 572                 CRect rect;
 573                 m_ctrlFiles.GetItemRect(i, &rect, LVIR_BOUNDS);
 574                 CUpdateListCtrl::Entry *data = (CUpdateListCtrl::Entry *)m_ctrlFiles.GetItemData(i);
 575                 if (m_ctrlFiles.GetCheck(i) == TRUE)
 576                 {
 577                         data->m_status = CUpdateListCtrl::STATUS_DOWNLOADING;
 578                         m_ctrlFiles.InvalidateRect(rect);
 579                         if (Download(data->m_filename))
 580                                 data->m_status = CUpdateListCtrl::STATUS_SUCCESS;
 581                         else
 582                         {
 583                                 data->m_status = CUpdateListCtrl::STATUS_FAIL;
 584                                 result = FALSE;
 585                         }
 586                 }
 587                 else
 588                         data->m_status = CUpdateListCtrl::STATUS_IGNORE;
 589                 m_ctrlFiles.InvalidateRect(rect);
 590         }
 591
 592         ::PostMessage(GetSafeHwnd(), WM_USER_ENDDOWNLOAD, 0, 0);
 593
 594         return result;
 595 }
 596
 597 LRESULT CCheckForUpdatesDlg::OnEndDownload(WPARAM, LPARAM)
 598 {
 599         ASSERT(m_pDownloadThread != NULL);
 600
 601         // wait until the thread terminates
 602         DWORD dwExitCode;
 603         if (::GetExitCodeThread(m_pDownloadThread->m_hThread, &dwExitCode) && dwExitCode == STILL_ACTIVE)
 604                 ::WaitForSingleObject(m_pDownloadThread->m_hThread, INFINITE);
 605
 606         // make sure we always have the correct exit code
 607         ::GetExitCodeThread(m_pDownloadThread->m_hThread, &dwExitCode);
 608
 609         delete m_pDownloadThread;
 610         m_pDownloadThread = NULL;
 611
 612         m_progress.ShowWindow(SW_HIDE);
 613
 614         if (dwExitCode == TRUE)
 615         {
 616                 m_ctrlUpdate.AddEntry(CString(MAKEINTRESOURCE(IDS_PROC_INSTALL)));
 617                 m_ctrlUpdate.AddEntry(CString(MAKEINTRESOURCE(IDS_CHECKUPDATE_DESTFOLDER)));
 618                 m_ctrlUpdate.Invalidate();
 619         }
 620         else
 621         {
 622                 m_ctrlUpdate.SetWindowText(CString(MAKEINTRESOURCE(IDS_PROC_DOWNLOAD)));
 623                 CMessageBox::Show(NULL, IDS_ERR_FAILEDUPDATEDOWNLOAD, IDS_APPNAME, MB_ICONERROR);
 624         }
 625
 626         return 0;
 627 }
 628
 629 LRESULT CCheckForUpdatesDlg::OnFillChangelog(WPARAM, LPARAM lParam)
 630 {
 631         ASSERT(lParam != NULL);
 632
 633         TCHAR * changelog = reinterpret_cast<TCHAR *>(lParam);
 634         m_cLogMessage.Call(SCI_SETREADONLY, FALSE);
 635         m_cLogMessage.SetText(changelog);
 636         m_cLogMessage.Call(SCI_SETREADONLY, TRUE);
 637         m_cLogMessage.Call(SCI_GOTOPOS, 0);
 638
 639         return 0;
 640 }
 641
 642 CString CCheckForUpdatesDlg::GetDownloadsDirectory()
 643 {
 644         CString folder;
 645
 646         if (SysInfo::Instance().IsVistaOrLater())
 647         {
 648                 CAutoLibrary hShell = ::LoadLibrary(_T("shell32.dll"));
 649                 if (hShell)
 650                 {
 651                         typedef HRESULT STDAPICALLTYPE SHGetKnownFolderPathFN(__in REFKNOWNFOLDERID rfid, __in DWORD dwFlags, __in_opt HANDLE hToken, __deref_out PWSTR *ppszPath);
 652                         SHGetKnownFolderPathFN *pfnSHGetKnownFolderPath = (SHGetKnownFolderPathFN*)GetProcAddress(hShell, "SHGetKnownFolderPath");
 653                         if (pfnSHGetKnownFolderPath)
 654                         {
 655                                 wchar_t * wcharPtr = 0;
 656                                 HRESULT hr = pfnSHGetKnownFolderPath(FOLDERID_Downloads, KF_FLAG_CREATE, NULL, &wcharPtr);
 657                                 if (SUCCEEDED(hr))
 658                                 {
 659                                         folder = wcharPtr;
 660                                         CoTaskMemFree(static_cast<void*>(wcharPtr));
 661                                         return folder.TrimRight(_T("\\")) + _T("\\");
 662                                 }
 663                         }
 664                 }
 665         }
 666
 667         TCHAR szPath[MAX_PATH];
 668         if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_PERSONAL | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, szPath)))
 669                 folder = szPath;
 670         CString downloads = folder.TrimRight(_T("\\")) + _T("\\Downloads\\");
 671         if ((PathFileExists(downloads) && PathIsDirectory(downloads)) || (!PathFileExists(downloads) && CreateDirectory(downloads, NULL)))
 672                 return downloads;
 673
 674         return folder;
 675 }
 676
 677 LRESULT CCheckForUpdatesDlg::OnDisplayStatus(WPARAM, LPARAM lParam)
 678 {
 679         const DOWNLOADSTATUS *const pDownloadStatus = reinterpret_cast<DOWNLOADSTATUS *>(lParam);
 680         if (pDownloadStatus != NULL)
 681         {
 682                 ASSERT(::AfxIsValidAddress(pDownloadStatus, sizeof(DOWNLOADSTATUS)));
 683
 684                 m_progress.SetRange32(0, pDownloadStatus->ulProgressMax);
 685                 m_progress.SetPos(pDownloadStatus->ulProgress);
 686         }
 687
 688         return 0;
 689 }
 690
 691 CBSCallbackImpl::CBSCallbackImpl(HWND hWnd, HANDLE hEventStop)
 692 {
 693         m_hWnd = hWnd;
 694         m_hEventStop = hEventStop;
 695         m_ulObjRefCount = 1;
 696 }
 697
 698 // IUnknown
 699 STDMETHODIMP CBSCallbackImpl::QueryInterface(REFIID riid, void **ppvObject)
 700 {
 701         *ppvObject = NULL;
 702
 703         // IUnknown
 704         if (::IsEqualIID(riid, __uuidof(IUnknown)))
 705                 *ppvObject = this;
 706
 707         // IBindStatusCallback
 708         else if (::IsEqualIID(riid, __uuidof(IBindStatusCallback)))
 709                 *ppvObject = static_cast<IBindStatusCallback *>(this);
 710
 711         if (*ppvObject)
 712         {
 713                 (*reinterpret_cast<LPUNKNOWN *>(ppvObject))->AddRef();
 714                 return S_OK;
 715         }
 716
 717         return E_NOINTERFACE;
 718 }
 719
 720 STDMETHODIMP_(ULONG) CBSCallbackImpl::AddRef()
 721 {
 722         return ++m_ulObjRefCount;
 723 }
 724
 725 STDMETHODIMP_(ULONG) CBSCallbackImpl::Release()
 726 {
 727         return --m_ulObjRefCount;
 728 }
 729
 730 // IBindStatusCallback
 731 STDMETHODIMP CBSCallbackImpl::OnStartBinding(DWORD, IBinding *)
 732 {
 733         return S_OK;
 734 }
 735
 736 STDMETHODIMP CBSCallbackImpl::GetPriority(LONG *)
 737 {
 738         return E_NOTIMPL;
 739 }
 740 STDMETHODIMP CBSCallbackImpl::OnLowResource(DWORD)
 741 {
 742         return S_OK;
 743 }
 744
 745 STDMETHODIMP CBSCallbackImpl::OnProgress(ULONG ulProgress, ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR /* szStatusText */)
 746 {
 747         TRACE(_T("IBindStatusCallback::OnProgress\n"));
 748         TRACE(_T("ulProgress: %lu, ulProgressMax: %lu\n"), ulProgress, ulProgressMax);
 749         UNREFERENCED_PARAMETER(ulStatusCode);
 750         TRACE(_T("ulStatusCode: %lu "), ulStatusCode);
 751
 752         if (m_hWnd != NULL)
 753         {
 754                 // inform the dialog box to display current status,
 755                 // don't use PostMessage
 756                 CCheckForUpdatesDlg::DOWNLOADSTATUS downloadStatus = { ulProgress, ulProgressMax };
 757                 ::SendMessage(m_hWnd, WM_USER_DISPLAYSTATUS, 0, reinterpret_cast<LPARAM>(&downloadStatus));
 758         }
 759
 760         if (m_hEventStop != NULL && ::WaitForSingleObject(m_hEventStop, 0) == WAIT_OBJECT_0)
 761         {
 762                 return E_ABORT;  // canceled by the user
 763         }
 764
 765         return S_OK;
 766 }
 767
 768 STDMETHODIMP CBSCallbackImpl::OnStopBinding(HRESULT, LPCWSTR)
 769 {
 770         return S_OK;
 771 }
 772
 773 STDMETHODIMP CBSCallbackImpl::GetBindInfo(DWORD *, BINDINFO *)
 774 {
 775         return S_OK;
 776 }
 777
 778 STDMETHODIMP CBSCallbackImpl::OnDataAvailable(DWORD, DWORD, FORMATETC *, STGMEDIUM *)
 779 {
 780         return S_OK;
 781 }
 782
 783 STDMETHODIMP CBSCallbackImpl::OnObjectAvailable(REFIID, IUnknown *)
 784 {
 785         return S_OK;
 786 }
 787
 788 BOOL CCheckForUpdatesDlg::VerifySignature(CString fileName)
 789 {
 790         WINTRUST_FILE_INFO fileInfo;
 791         memset(&fileInfo, 0, sizeof(fileInfo));
 792         fileInfo.cbStruct = sizeof(WINTRUST_FILE_INFO);
 793         fileInfo.pcwszFilePath = fileName;
 794
 795         WINTRUST_DATA data;
 796         memset(&data, 0, sizeof(data));
 797         data.cbStruct = sizeof(data);
 798
 799         data.dwUIChoice = WTD_UI_NONE;
 800         data.fdwRevocationChecks = WTD_REVOKE_NONE;
 801         data.dwUnionChoice = WTD_CHOICE_FILE;
 802         data.pFile = &fileInfo;
 803
 804         GUID policyGUID = WINTRUST_ACTION_GENERIC_VERIFY_V2;
 805
 806         return (WinVerifyTrust(NULL, &policyGUID, &data) == ERROR_SUCCESS);
 807 }