cpp/demo/IcePatch2/MFC/PatchClientDlg.cpp

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 #include "stdafx.h"
  11 #include "PatchClient.h"
  12 #include "PatchClientDlg.h"
  13
  14 #include <IcePatch2/ClientUtil.h>
  15
  16 #ifdef _DEBUG
  17 #define new DEBUG_NEW
  18 #endif
  19
  20 using namespace std;
  21
  22 string
  23 getBasename(const string& path)
  24 {
  25     string::size_type pos = path.rfind('/');
  26     if(pos == string::npos)
  27     {
  28         pos = path.rfind('\\');
  29     }
  30
  31     if(pos == string::npos)
  32     {
  33         return path;
  34     }
  35     else
  36     {
  37         return path.substr(pos + 1);
  38     }
  39 }
  40
  41 class DialogPatcherFeedback : public IcePatch2::PatcherFeedback
  42 {
  43 public:
  44
  45     DialogPatcherFeedback(CPatchDlg* dialog) :
  46         _dialog(dialog),
  47         _filesPatched(0)
  48     {
  49         assert(_dialog);
  50     }
  51
  52     virtual bool
  53     noFileSummary(const string& reason)
  54     {
  55         return IDYES == AfxMessageBox(L"Cannot load file summary. Perform a thorough patch?", MB_YESNO|MB_ICONSTOP);
  56     }
  57
  58     virtual bool
  59     checksumStart()
  60     {
  61         return _dialog->checksumStart();
  62     }
  63
  64     virtual bool
  65     checksumProgress(const string& path)
  66     {
  67         return _dialog->checksumProgress(path);
  68     }
  69
  70     virtual bool
  71     checksumEnd()
  72     {
  73         return _dialog->checksumEnd();
  74     }
  75
  76     virtual bool
  77     fileListStart()
  78     {
  79         return _dialog->fileListStart();
  80     }
  81
  82     virtual bool
  83     fileListProgress(Ice::Int percent)
  84     {
  85         return _dialog->fileListProgress(percent);
  86     }
  87
  88     virtual bool
  89     fileListEnd()
  90     {
  91         return _dialog->fileListEnd();
  92     }
  93
  94     virtual bool
  95     patchStart(const string& path, Ice::Long size, Ice::Long totalProgress, Ice::Long totalSize)
  96     {
  97         return _dialog->patchStart(path, size, totalProgress, totalSize);
  98     }
  99
 100     virtual bool
 101     patchProgress(Ice::Long progress, Ice::Long size, Ice::Long totalProgress, Ice::Long totalSize)
 102     {
 103         return _dialog->patchProgress(progress, size, totalProgress, totalSize);
 104     }
 105
 106     virtual bool
 107     patchEnd()
 108     {
 109         ++_filesPatched;
 110         return _dialog->patchEnd();
 111     }
 112
 113     virtual int
 114     filesPatched() const
 115     {
 116         return _filesPatched;
 117     }
 118
 119 private:
 120
 121     CPatchDlg* const _dialog;
 122     int _filesPatched;
 123 };
 124
 125 typedef IceUtil::Handle<DialogPatcherFeedback> DialogPatcherFeedbackPtr;
 126
 127 CPatchDlg::CPatchDlg(const Ice::CommunicatorPtr& communicator, CWnd* pParent /*=NULL*/) :
 128     CDialog(CPatchDlg::IDD, pParent), _communicator(communicator), _isCancel(false), _isPatch(false)
 129 {
 130     _hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
 131 }
 132
 133 bool
 134 CPatchDlg::checksumStart()
 135 {
 136     _status->SetWindowText(CString(L" Calculating checksums..."));
 137
 138     _progress->SetRange(0, 0);
 139     _progress->SetPos(0);
 140
 141     processMessages();
 142     return !_isCancel;
 143 }
 144
 145 bool
 146 CPatchDlg::checksumProgress(const string& path)
 147 {
 148     // TODO: indicate busy progress
 149
 150     CString file;
 151     file.Format(L" %s", IceUtil::stringToWstring(getBasename(path)).c_str());
 152     _file->SetWindowText(file);
 153
 154     processMessages();
 155     return !_isCancel;
 156 }
 157
 158 bool
 159 CPatchDlg::checksumEnd()
 160 {
 161     processMessages();
 162     return !_isCancel;
 163 }
 164
 165 bool
 166 CPatchDlg::fileListStart()
 167 {
 168     _status->SetWindowText(CString(L" Retrieving file list..."));
 169
 170     _progress->SetRange(0, 100);
 171     _progress->SetPos(0);
 172
 173     processMessages();
 174     return !_isCancel;
 175 }
 176
 177 bool
 178 CPatchDlg::fileListProgress(Ice::Int pcnt)
 179 {
 180     CString percent;
 181     percent.Format(L"%d%%", pcnt);
 182     _percent->SetWindowText(percent);
 183
 184     _progress->SetPos(pcnt);
 185
 186     processMessages();
 187     return !_isCancel;
 188 }
 189
 190 bool
 191 CPatchDlg::fileListEnd()
 192 {
 193     processMessages();
 194     return !_isCancel;
 195 }
 196
 197 bool
 198 CPatchDlg::patchStart(const string& path, Ice::Long size, Ice::Long totalProgress, Ice::Long totalSize)
 199 {
 200     if(!_isPatch)
 201     {
 202         _startTime = IceUtil::Time::now(IceUtil::Time::Monotonic);
 203         _status->SetWindowText(CString(L" Patching..."));
 204         _speed->SetWindowText(CString(L" 0.0 KB/s"));
 205         _isPatch = true;
 206     }
 207
 208     CString file;
 209     file.Format(L" %s", IceUtil::stringToWstring(getBasename(path)).c_str());
 210     _file->SetWindowText(file);
 211
 212     return patchProgress(0, size, totalProgress, totalSize);
 213 }
 214
 215 bool
 216 CPatchDlg::patchProgress(Ice::Long, Ice::Long, Ice::Long totalProgress, Ice::Long totalSize)
 217 {
 218     IceUtil::Time elapsed = IceUtil::Time::now(IceUtil::Time::Monotonic) - _startTime;
 219     if(elapsed.toSeconds() > 0)
 220     {
 221         CString speed;
 222         speed.Format(L" %s/s", convertSize(totalProgress / elapsed.toSeconds()));
 223         _speed->SetWindowText(speed);
 224     }
 225
 226     int pcnt = 100;
 227     if(totalSize > 0)
 228     {
 229         pcnt = static_cast<int>(totalProgress * 100 / totalSize);
 230     }
 231     CString percent;
 232     percent.Format(L"%d%%", pcnt);
 233     _percent->SetWindowText(percent);
 234
 235     CString total;
 236     total.Format(L" %s / %s", convertSize(totalProgress), convertSize(totalSize));
 237     _total->SetWindowText(total);
 238
 239     _progress->SetPos(pcnt);
 240
 241     processMessages();
 242     return !_isCancel;
 243 }
 244
 245 bool
 246 CPatchDlg::patchEnd()
 247 {
 248     processMessages();
 249     return !_isCancel;
 250 }
 251
 252 void
 253 CPatchDlg::DoDataExchange(CDataExchange* pDX)
 254 {
 255     CDialog::DoDataExchange(pDX);
 256 }
 257
 258 BEGIN_MESSAGE_MAP(CPatchDlg, CDialog)
 259     ON_WM_PAINT()
 260     ON_WM_QUERYDRAGICON()
 261     //}}AFX_MSG_MAP
 262     ON_BN_CLICKED(IDC_SELECTDIR, OnSelectDir)
 263     ON_BN_CLICKED(IDC_STARTPATCH, OnStartPatch)
 264     ON_BN_CLICKED(IDC_CANCELPATCH, OnCancel)
 265 END_MESSAGE_MAP()
 266
 267 BOOL
 268 CPatchDlg::OnInitDialog()
 269 {
 270     CDialog::OnInitDialog();
 271
 272     // Set the icon for this dialog.  The framework does this automatically
 273     // when the application's main window is not a dialog
 274     SetIcon(_hIcon, TRUE);            // Set big icon
 275     SetIcon(_hIcon, FALSE);        // Set small icon
 276
 277     //
 278     // Retrieve the controls.
 279     //
 280     _path = (CEdit*)GetDlgItem(IDC_PATH);
 281     _thorough = (CButton*)GetDlgItem(IDC_THOROUGH);
 282     _remove = (CButton*)GetDlgItem(IDC_ORPHAN);
 283     _select = (CButton*)GetDlgItem(IDC_SELECTDIR);
 284     _start = (CButton*)GetDlgItem(IDC_STARTPATCH);
 285     _cancel = (CButton*)GetDlgItem(IDC_CANCELPATCH);
 286     _file = (CStatic*)GetDlgItem(IDC_FILE);
 287     _total = (CStatic*)GetDlgItem(IDC_TOTAL);
 288     _speed = (CStatic*)GetDlgItem(IDC_SPEED);
 289     _status = (CStatic*)GetDlgItem(IDC_STATUSBAR);
 290     _percent = (CStatic*)GetDlgItem(IDC_PERCENT);
 291     _progress = (CProgressCtrl*)GetDlgItem(IDC_PROGRESS);
 292
 293     //
 294     // Set the patch directory and thorough flag from properties.
 295     //
 296     Ice::PropertiesPtr properties = _communicator->getProperties();
 297     CString path = IceUtil::stringToWstring(properties->getPropertyWithDefault("IcePatch2.Directory", "")).c_str();
 298     _path->SetWindowText(path);
 299
 300     CString thorough = IceUtil::stringToWstring(properties->getPropertyWithDefault("IcePatch2.Thorough", "0")).c_str();
 301     _thorough->SetCheck(thorough != "0");
 302
 303     CString remove = IceUtil::stringToWstring(properties->getPropertyWithDefault("IcePatch2.Remove", "0")).c_str();
 304     _remove->SetCheck(remove != "0");
 305
 306     //
 307     // Indicate ready status.
 308     //
 309     reset(L" Ready");
 310
 311     return TRUE;  // return TRUE  unless you set the focus to a control
 312 }
 313
 314 // If you add a minimize button to your dialog, you will need the code below
 315 // to draw the icon.  For MFC applications using the document/view model,
 316 // this is automatically done for you by the framework.
 317
 318 void
 319 CPatchDlg::OnPaint()
 320 {
 321     if(IsIconic())
 322     {
 323         CPaintDC dc(this); // device context for painting
 324
 325         SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);
 326
 327         // Center icon in client rectangle
 328         int cxIcon = GetSystemMetrics(SM_CXICON);
 329         int cyIcon = GetSystemMetrics(SM_CYICON);
 330         CRect rect;
 331         GetClientRect(&rect);
 332         int x = (rect.Width() - cxIcon + 1) / 2;
 333         int y = (rect.Height() - cyIcon + 1) / 2;
 334
 335         // Draw the icon
 336         dc.DrawIcon(x, y, _hIcon);
 337     }
 338     else
 339     {
 340         CDialog::OnPaint();
 341     }
 342 }
 343
 344 // The system calls this function to obtain the cursor to display while the user drags
 345 // the minimized window.
 346 HCURSOR
 347 CPatchDlg::OnQueryDragIcon()
 348 {
 349     return static_cast<HCURSOR>(_hIcon);
 350 }
 351
 352 void
 353 CPatchDlg::OnSelectDir()
 354 {
 355     BROWSEINFO info = { 0 };
 356     info.lpszTitle = _T("Select Patch Directory");
 357     LPITEMIDLIST pidl = SHBrowseForFolder(&info);
 358     if(pidl != 0)
 359     {
 360         //
 361         // Get the name of the selected folder.
 362         //
 363         TCHAR path[MAX_PATH];
 364         if(SHGetPathFromIDList(pidl, path))
 365         {
 366             _path->SetWindowText(path);
 367         }
 368
 369         //
 370         // Free up memory used.
 371         //
 372         IMalloc * imalloc = 0;
 373         if(SUCCEEDED(SHGetMalloc(&imalloc)))
 374         {
 375             imalloc->Free(pidl);
 376             imalloc->Release();
 377         }
 378     }
 379 }
 380
 381 void
 382 CPatchDlg::OnStartPatch()
 383 {
 384     try
 385     {
 386         Ice::PropertiesPtr properties = _communicator->getProperties();
 387
 388         //
 389         // Set the patch directory.
 390         //
 391         CString path;
 392         _path->GetWindowText(path);
 393         if(path.IsEmpty())
 394         {
 395             AfxMessageBox(CString(L"Please select a patch directory."), MB_OK|MB_ICONEXCLAMATION);
 396             return;
 397         }
 398         properties->setProperty("IcePatch2.Directory", IceUtil::wstringToString(wstring(path)));
 399
 400         //
 401         // Set the thorough patch flag.
 402         //
 403         string thorough = _thorough->GetCheck() == BST_CHECKED ? "1" : "0";
 404         properties->setProperty("IcePatch2.Thorough", thorough);
 405
 406         //
 407         // Set the remove orphan flag.
 408         //
 409         string remove = _remove->GetCheck() == BST_CHECKED ? "1" : "0";
 410         properties->setProperty("IcePatch2.Remove", remove);
 411
 412         DialogPatcherFeedbackPtr feedback = new DialogPatcherFeedback(this);
 413         IcePatch2::PatcherPtr patcher = new IcePatch2::Patcher(_communicator, feedback);
 414
 415         //
 416         // Disable a few controls during the patch process.
 417         //
 418         _path->EnableWindow(false);
 419         _select->EnableWindow(false);
 420         _thorough->EnableWindow(false);
 421         _remove->EnableWindow(false);
 422         _start->EnableWindow(false);
 423
 424         //
 425         // Patch
 426         //
 427         bool aborted = !patcher->prepare();
 428         if(!aborted)
 429         {
 430             aborted = !patcher->patch("");
 431         }
 432         if(!aborted)
 433         {
 434             patcher->finish();
 435         }
 436
 437         //
 438         // Reset and indicate the completion status.
 439         //
 440         reset(aborted ? L" Aborted" : L" Completed");
 441     }
 442     catch(const IceUtil::Exception& ex)
 443     {
 444         handleException(ex);
 445     }
 446     catch(const string& ex)
 447     {
 448         AfxMessageBox(CString(ex.c_str()), MB_OK|MB_ICONEXCLAMATION);
 449     }
 450 }
 451
 452 void
 453 CPatchDlg::OnCancel()
 454 {
 455     _isCancel = true;
 456     _status->SetWindowText(CString(L" Canceled"));
 457     CDialog::OnCancel();
 458 }
 459
 460 void
 461 CPatchDlg::reset(const CString& status)
 462 {
 463     _isPatch = false;
 464
 465     _path->EnableWindow(true);
 466     _select->EnableWindow(true);
 467     _thorough->EnableWindow(true);
 468     _remove->EnableWindow(true);
 469     _start->EnableWindow(true);
 470
 471     _status->SetWindowText(status);
 472     _file->SetWindowText(CString());
 473     _total->SetWindowText(CString());
 474     _speed->SetWindowText(CString());
 475     _percent->SetWindowText(CString());
 476
 477     _progress->SetPos(0);
 478 }
 479
 480 void
 481 CPatchDlg::processMessages()
 482 {
 483     MSG msg;
 484     while(::PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
 485     {
 486         TranslateMessage(&msg);
 487         DispatchMessage(&msg);
 488     }
 489 }
 490
 491 void
 492 CPatchDlg::handleException(const IceUtil::Exception& e)
 493 {
 494     try
 495     {
 496         e.ice_throw();
 497     }
 498     catch(const IceUtil::Exception& ex)
 499     {
 500         ostringstream ostr;
 501         ostr << ex;
 502         string s = ostr.str();
 503         AfxMessageBox(CString(s.c_str()), MB_OK|MB_ICONEXCLAMATION);
 504     }
 505
 506     reset(L" Ready");
 507 }
 508
 509 CString
 510 CPatchDlg::convertSize(Ice::Long size) const
 511 {
 512     CString units;
 513     double start = static_cast<double>(size);
 514     double final = start / gigabyte;
 515     if(final >= 1)
 516     {
 517         units = L"GB";
 518     }
 519     else
 520     {
 521         final = start / megabyte;
 522         if(final >= 1)
 523         {
 524             units = L"MB";
 525         }
 526         else
 527         {
 528             final = start / kilobyte;
 529             if(final >= 1)
 530             {
 531                 units = L"KB";
 532             }
 533             else
 534             {
 535                 final = start;
 536                 units = L"B";
 537             }
 538         }
 539     }
 540
 541     CString convert;
 542     convert.Format(L"%.1f %s", final, units);
 543     return convert;
 544 }