1 // ProgressDialog2.cpp 2 3 #include "StdAfx.h" 4 5 #include "../../../Common/IntToString.h" 6 #include "../../../Common/StringConvert.h" 7 8 #include "../../../Windows/Control/Static.h" 9 #include "../../../Windows/ErrorMsg.h" 10 11 #include "../GUI/ExtractRes.h" 12 13 #include "LangUtils.h" 14 15 #include "DialogSize.h" 16 #include "ProgressDialog2.h" 17 #include "ProgressDialog2Res.h" 18 19 using namespace NWindows; 20 21 extern HINSTANCE g_hInstance; 22 23 static const UINT_PTR kTimerID = 3; 24 25 static const UINT kCloseMessage = WM_APP + 1; 26 // we can't use WM_USER, since WM_USER can be used by standard Windows procedure for Dialog 27 28 static const UINT kTimerElapse = 29 #ifdef UNDER_CE 30 500 31 #else 32 200 33 #endif 34 ; 35 36 static const UINT kCreateDelay = 37 #ifdef UNDER_CE 38 2500 39 #else 40 500 41 #endif 42 ; 43 44 static const DWORD kPauseSleepTime = 100; 45 46 #ifdef LANG 47 48 static const UInt32 kLangIDs[] = 49 { 50 IDT_PROGRESS_ELAPSED, 51 IDT_PROGRESS_REMAINING, 52 IDT_PROGRESS_TOTAL, 53 IDT_PROGRESS_SPEED, 54 IDT_PROGRESS_PROCESSED, 55 IDT_PROGRESS_RATIO, 56 IDT_PROGRESS_ERRORS, 57 IDB_PROGRESS_BACKGROUND, 58 IDB_PAUSE 59 }; 60 61 static const UInt32 kLangIDs_Colon[] = 62 { 63 IDT_PROGRESS_PACKED, 64 IDT_PROGRESS_FILES 65 }; 66 67 #endif 68 69 70 #define UNDEFINED_VAL ((UInt64)(Int64)-1) 71 #define INIT_AS_UNDEFINED(v) v = UNDEFINED_VAL; 72 #define IS_UNDEFINED_VAL(v) ((v) == UNDEFINED_VAL) 73 #define IS_DEFINED_VAL(v) ((v) != UNDEFINED_VAL) 74 75 CProgressSync::CProgressSync(): 76 _stopped(false), _paused(false), 77 _bytesProgressMode(true), 78 _totalBytes(UNDEFINED_VAL), _completedBytes(0), 79 _totalFiles(UNDEFINED_VAL), _curFiles(0), 80 _inSize(UNDEFINED_VAL), 81 _outSize(UNDEFINED_VAL), 82 _isDir(false) 83 {} 84 85 #define CHECK_STOP if (_stopped) return E_ABORT; if (!_paused) return S_OK; 86 #define CRITICAL_LOCK NSynchronization::CCriticalSectionLock lock(_cs); 87 88 bool CProgressSync::Get_Paused() 89 { 90 CRITICAL_LOCK 91 return _paused; 92 } 93 94 HRESULT CProgressSync::CheckStop() 95 { 96 for (;;) 97 { 98 { 99 CRITICAL_LOCK 100 CHECK_STOP 101 } 102 ::Sleep(kPauseSleepTime); 103 } 104 } 105 106 HRESULT CProgressSync::ScanProgress(UInt64 numFiles, UInt64 totalSize, const FString &fileName, bool isDir) 107 { 108 { 109 CRITICAL_LOCK 110 _totalFiles = numFiles; 111 _totalBytes = totalSize; 112 _filePath = fs2us(fileName); 113 _isDir = isDir; 114 // _completedBytes = 0; 115 CHECK_STOP 116 } 117 return CheckStop(); 118 } 119 120 HRESULT CProgressSync::Set_NumFilesTotal(UInt64 val) 121 { 122 { 123 CRITICAL_LOCK 124 _totalFiles = val; 125 CHECK_STOP 126 } 127 return CheckStop(); 128 } 129 130 void CProgressSync::Set_NumBytesTotal(UInt64 val) 131 { 132 CRITICAL_LOCK 133 _totalBytes = val; 134 } 135 136 void CProgressSync::Set_NumFilesCur(UInt64 val) 137 { 138 CRITICAL_LOCK 139 _curFiles = val; 140 } 141 142 HRESULT CProgressSync::Set_NumBytesCur(const UInt64 *val) 143 { 144 { 145 CRITICAL_LOCK 146 if (val) 147 _completedBytes = *val; 148 CHECK_STOP 149 } 150 return CheckStop(); 151 } 152 153 HRESULT CProgressSync::Set_NumBytesCur(UInt64 val) 154 { 155 { 156 CRITICAL_LOCK 157 _completedBytes = val; 158 CHECK_STOP 159 } 160 return CheckStop(); 161 } 162 163 void CProgressSync::Set_Ratio(const UInt64 *inSize, const UInt64 *outSize) 164 { 165 CRITICAL_LOCK 166 if (inSize) 167 _inSize = *inSize; 168 if (outSize) 169 _outSize = *outSize; 170 } 171 172 void CProgressSync::Set_TitleFileName(const UString &fileName) 173 { 174 CRITICAL_LOCK 175 _titleFileName = fileName; 176 } 177 178 void CProgressSync::Set_Status(const UString &s) 179 { 180 CRITICAL_LOCK 181 _status = s; 182 } 183 184 HRESULT CProgressSync::Set_Status2(const UString &s, const wchar_t *path, bool isDir) 185 { 186 { 187 CRITICAL_LOCK 188 _status = s; 189 if (path) 190 _filePath = path; 191 else 192 _filePath.Empty(); 193 _isDir = isDir; 194 } 195 return CheckStop(); 196 } 197 198 void CProgressSync::Set_FilePath(const wchar_t *path, bool isDir) 199 { 200 CRITICAL_LOCK 201 if (path) 202 _filePath = path; 203 else 204 _filePath.Empty(); 205 _isDir = isDir; 206 } 207 208 209 void CProgressSync::AddError_Message(const wchar_t *message) 210 { 211 CRITICAL_LOCK 212 Messages.Add(message); 213 } 214 215 void CProgressSync::AddError_Message_Name(const wchar_t *message, const wchar_t *name) 216 { 217 UString s; 218 if (name && *name != 0) 219 s += name; 220 if (message && *message != 0) 221 { 222 if (!s.IsEmpty()) 223 s.Add_LF(); 224 s += message; 225 if (!s.IsEmpty() && s.Back() == L'\n') 226 s.DeleteBack(); 227 } 228 AddError_Message(s); 229 } 230 231 void CProgressSync::AddError_Code_Name(DWORD systemError, const wchar_t *name) 232 { 233 UString s = NError::MyFormatMessage(systemError); 234 if (systemError == 0) 235 s = "Error"; 236 AddError_Message_Name(s, name); 237 } 238 239 CProgressDialog::CProgressDialog(): 240 _timer(0), 241 CompressingMode(true), 242 MainWindow(0) 243 { 244 _isDir = false; 245 246 _numMessages = 0; 247 IconID = -1; 248 MessagesDisplayed = false; 249 _wasCreated = false; 250 _needClose = false; 251 _inCancelMessageBox = false; 252 _externalCloseMessageWasReceived = false; 253 254 _numPostedMessages = 0; 255 _numAutoSizeMessages = 0; 256 _errorsWereDisplayed = false; 257 _waitCloseByCancelButton = false; 258 _cancelWasPressed = false; 259 ShowCompressionInfo = true; 260 WaitMode = false; 261 if (_dialogCreatedEvent.Create() != S_OK) 262 throw 1334987; 263 if (_createDialogEvent.Create() != S_OK) 264 throw 1334987; 265 #ifdef __ITaskbarList3_INTERFACE_DEFINED__ 266 CoCreateInstance(CLSID_TaskbarList, NULL, CLSCTX_INPROC_SERVER, IID_ITaskbarList3, (void**)&_taskbarList); 267 if (_taskbarList) 268 _taskbarList->HrInit(); 269 #endif 270 } 271 272 #ifndef _SFX 273 274 CProgressDialog::~CProgressDialog() 275 { 276 #ifdef __ITaskbarList3_INTERFACE_DEFINED__ 277 SetTaskbarProgressState(TBPF_NOPROGRESS); 278 #endif 279 AddToTitle(L""); 280 } 281 void CProgressDialog::AddToTitle(LPCWSTR s) 282 { 283 if (MainWindow != 0) 284 { 285 CWindow window(MainWindow); 286 window.SetText((UString)s + MainTitle); 287 } 288 } 289 290 #endif 291 292 293 void CProgressDialog::SetTaskbarProgressState() 294 { 295 #ifdef __ITaskbarList3_INTERFACE_DEFINED__ 296 if (_taskbarList && _hwndForTaskbar) 297 { 298 TBPFLAG tbpFlags; 299 if (Sync.Get_Paused()) 300 tbpFlags = TBPF_PAUSED; 301 else 302 tbpFlags = _errorsWereDisplayed ? TBPF_ERROR: TBPF_NORMAL; 303 SetTaskbarProgressState(tbpFlags); 304 } 305 #endif 306 } 307 308 static const unsigned kTitleFileNameSizeLimit = 36; 309 static const unsigned kCurrentFileNameSizeLimit = 82; 310 311 static void ReduceString(UString &s, unsigned size) 312 { 313 if (s.Len() <= size) 314 return; 315 s.Delete(size / 2, s.Len() - size); 316 s.Insert(size / 2, L" ... "); 317 } 318 319 void CProgressDialog::EnableErrorsControls(bool enable) 320 { 321 ShowItem_Bool(IDT_PROGRESS_ERRORS, enable); 322 ShowItem_Bool(IDT_PROGRESS_ERRORS_VAL, enable); 323 ShowItem_Bool(IDL_PROGRESS_MESSAGES, enable); 324 } 325 326 bool CProgressDialog::OnInit() 327 { 328 _hwndForTaskbar = MainWindow; 329 if (!_hwndForTaskbar) 330 _hwndForTaskbar = GetParent(); 331 if (!_hwndForTaskbar) 332 _hwndForTaskbar = *this; 333 334 INIT_AS_UNDEFINED(_progressBar_Range); 335 INIT_AS_UNDEFINED(_progressBar_Pos); 336 337 INIT_AS_UNDEFINED(_prevPercentValue); 338 INIT_AS_UNDEFINED(_prevElapsedSec); 339 INIT_AS_UNDEFINED(_prevRemainingSec); 340 341 INIT_AS_UNDEFINED(_prevSpeed); 342 _prevSpeed_MoveBits = 0; 343 344 _prevTime = ::GetTickCount(); 345 _elapsedTime = 0; 346 347 INIT_AS_UNDEFINED(_totalBytes_Prev); 348 INIT_AS_UNDEFINED(_processed_Prev); 349 INIT_AS_UNDEFINED(_packed_Prev); 350 INIT_AS_UNDEFINED(_ratio_Prev); 351 _filesStr_Prev.Empty(); 352 353 _foreground = true; 354 355 m_ProgressBar.Attach(GetItem(IDC_PROGRESS1)); 356 _messageList.Attach(GetItem(IDL_PROGRESS_MESSAGES)); 357 _messageList.SetUnicodeFormat(); 358 359 _wasCreated = true; 360 _dialogCreatedEvent.Set(); 361 362 #ifdef LANG 363 LangSetDlgItems(*this, kLangIDs, ARRAY_SIZE(kLangIDs)); 364 LangSetDlgItems_Colon(*this, kLangIDs_Colon, ARRAY_SIZE(kLangIDs_Colon)); 365 #endif 366 367 CWindow window(GetItem(IDB_PROGRESS_BACKGROUND)); 368 window.GetText(_background_String); 369 _backgrounded_String = _background_String; 370 _backgrounded_String.RemoveChar(L'&'); 371 372 window = GetItem(IDB_PAUSE); 373 window.GetText(_pause_String); 374 375 LangString(IDS_PROGRESS_FOREGROUND, _foreground_String); 376 LangString(IDS_CONTINUE, _continue_String); 377 LangString(IDS_PROGRESS_PAUSED, _paused_String); 378 379 SetText(_title); 380 SetPauseText(); 381 SetPriorityText(); 382 383 _messageList.InsertColumn(0, L"", 30); 384 _messageList.InsertColumn(1, L"", 600); 385 386 _messageList.SetColumnWidthAuto(0); 387 _messageList.SetColumnWidthAuto(1); 388 389 EnableErrorsControls(false); 390 391 GetItemSizes(IDCANCEL, _buttonSizeX, _buttonSizeY); 392 _numReduceSymbols = kCurrentFileNameSizeLimit; 393 NormalizeSize(true); 394 395 if (!ShowCompressionInfo) 396 { 397 HideItem(IDT_PROGRESS_PACKED); 398 HideItem(IDT_PROGRESS_PACKED_VAL); 399 HideItem(IDT_PROGRESS_RATIO); 400 HideItem(IDT_PROGRESS_RATIO_VAL); 401 } 402 403 if (IconID >= 0) 404 { 405 HICON icon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IconID)); 406 // SetIcon(ICON_SMALL, icon); 407 SetIcon(ICON_BIG, icon); 408 } 409 _timer = SetTimer(kTimerID, kTimerElapse); 410 #ifdef UNDER_CE 411 Foreground(); 412 #endif 413 414 CheckNeedClose(); 415 416 SetTaskbarProgressState(); 417 418 return CModalDialog::OnInit(); 419 } 420 421 static const UINT kIDs[] = 422 { 423 IDT_PROGRESS_ELAPSED, IDT_PROGRESS_ELAPSED_VAL, 424 IDT_PROGRESS_REMAINING, IDT_PROGRESS_REMAINING_VAL, 425 IDT_PROGRESS_FILES, IDT_PROGRESS_FILES_VAL, 426 IDT_PROGRESS_RATIO, IDT_PROGRESS_RATIO_VAL, 427 IDT_PROGRESS_ERRORS, IDT_PROGRESS_ERRORS_VAL, 428 429 IDT_PROGRESS_TOTAL, IDT_PROGRESS_TOTAL_VAL, 430 IDT_PROGRESS_SPEED, IDT_PROGRESS_SPEED_VAL, 431 IDT_PROGRESS_PROCESSED, IDT_PROGRESS_PROCESSED_VAL, 432 IDT_PROGRESS_PACKED, IDT_PROGRESS_PACKED_VAL 433 }; 434 435 bool CProgressDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize) 436 { 437 int sY; 438 int sStep; 439 int mx, my; 440 { 441 RECT r; 442 GetClientRectOfItem(IDT_PROGRESS_ELAPSED, r); 443 mx = r.left; 444 my = r.top; 445 sY = RECT_SIZE_Y(r); 446 GetClientRectOfItem(IDT_PROGRESS_REMAINING, r); 447 sStep = r.top - my; 448 } 449 450 InvalidateRect(NULL); 451 452 int xSizeClient = xSize - mx * 2; 453 454 { 455 int i; 456 for (i = 800; i > 40; i = i * 9 / 10) 457 if (Units_To_Pixels_X(i) <= xSizeClient) 458 break; 459 _numReduceSymbols = i / 4; 460 } 461 462 int yPos = ySize - my - _buttonSizeY; 463 464 ChangeSubWindowSizeX(GetItem(IDT_PROGRESS_STATUS), xSize - mx * 2); 465 ChangeSubWindowSizeX(GetItem(IDT_PROGRESS_FILE_NAME), xSize - mx * 2); 466 ChangeSubWindowSizeX(GetItem(IDC_PROGRESS1), xSize - mx * 2); 467 468 int bSizeX = _buttonSizeX; 469 int mx2 = mx; 470 for (;; mx2--) 471 { 472 int bSize2 = bSizeX * 3 + mx2 * 2; 473 if (bSize2 <= xSizeClient) 474 break; 475 if (mx2 < 5) 476 { 477 bSizeX = (xSizeClient - mx2 * 2) / 3; 478 break; 479 } 480 } 481 if (bSizeX < 2) 482 bSizeX = 2; 483 484 { 485 RECT r; 486 GetClientRectOfItem(IDL_PROGRESS_MESSAGES, r); 487 int y = r.top; 488 int ySize2 = yPos - my - y; 489 const int kMinYSize = _buttonSizeY + _buttonSizeY * 3 / 4; 490 int xx = xSize - mx * 2; 491 if (ySize2 < kMinYSize) 492 { 493 ySize2 = kMinYSize; 494 if (xx > bSizeX * 2) 495 xx -= bSizeX; 496 } 497 498 _messageList.Move(mx, y, xx, ySize2); 499 } 500 501 { 502 int xPos = xSize - mx; 503 xPos -= bSizeX; 504 MoveItem(IDCANCEL, xPos, yPos, bSizeX, _buttonSizeY); 505 xPos -= (mx2 + bSizeX); 506 MoveItem(IDB_PAUSE, xPos, yPos, bSizeX, _buttonSizeY); 507 xPos -= (mx2 + bSizeX); 508 MoveItem(IDB_PROGRESS_BACKGROUND, xPos, yPos, bSizeX, _buttonSizeY); 509 } 510 511 int valueSize; 512 int labelSize; 513 int padSize; 514 515 labelSize = Units_To_Pixels_X(MY_PROGRESS_LABEL_UNITS_MIN); 516 valueSize = Units_To_Pixels_X(MY_PROGRESS_VAL_UNITS); 517 padSize = Units_To_Pixels_X(MY_PROGRESS_PAD_UNITS); 518 int requiredSize = (labelSize + valueSize) * 2 + padSize; 519 520 int gSize; 521 { 522 if (requiredSize < xSizeClient) 523 { 524 int incr = (xSizeClient - requiredSize) / 3; 525 labelSize += incr; 526 } 527 else 528 labelSize = (xSizeClient - valueSize * 2 - padSize) / 2; 529 if (labelSize < 0) 530 labelSize = 0; 531 532 gSize = labelSize + valueSize; 533 padSize = xSizeClient - gSize * 2; 534 } 535 536 labelSize = gSize - valueSize; 537 538 yPos = my; 539 for (int i = 0; i < ARRAY_SIZE(kIDs); i += 2) 540 { 541 int x = mx; 542 const int kNumColumn1Items = 5 * 2; 543 if (i >= kNumColumn1Items) 544 { 545 if (i == kNumColumn1Items) 546 yPos = my; 547 x = mx + gSize + padSize; 548 } 549 MoveItem(kIDs[i], x, yPos, labelSize, sY); 550 MoveItem(kIDs[i + 1], x + labelSize, yPos, valueSize, sY); 551 yPos += sStep; 552 } 553 return false; 554 } 555 556 void CProgressDialog::OnCancel() { Sync.Set_Stopped(true); } 557 void CProgressDialog::OnOK() { } 558 559 void CProgressDialog::SetProgressRange(UInt64 range) 560 { 561 if (range == _progressBar_Range) 562 return; 563 _progressBar_Range = range; 564 INIT_AS_UNDEFINED(_progressBar_Pos); 565 _progressConv.Init(range); 566 m_ProgressBar.SetRange32(0, _progressConv.Count(range)); 567 } 568 569 void CProgressDialog::SetProgressPos(UInt64 pos) 570 { 571 if (pos >= _progressBar_Range || 572 pos <= _progressBar_Pos || 573 pos - _progressBar_Pos >= (_progressBar_Range >> 10)) 574 { 575 m_ProgressBar.SetPos(_progressConv.Count(pos)); 576 #ifdef __ITaskbarList3_INTERFACE_DEFINED__ 577 if (_taskbarList && _hwndForTaskbar) 578 _taskbarList->SetProgressValue(_hwndForTaskbar, pos, _progressBar_Range); 579 #endif 580 _progressBar_Pos = pos; 581 } 582 } 583 584 #define UINT_TO_STR_2(val) { s[0] = (wchar_t)('0' + (val) / 10); s[1] = (wchar_t)('0' + (val) % 10); s += 2; } 585 586 void GetTimeString(UInt64 timeValue, wchar_t *s) 587 { 588 UInt64 hours = timeValue / 3600; 589 UInt32 seconds = (UInt32)(timeValue - hours * 3600); 590 UInt32 minutes = seconds / 60; 591 seconds %= 60; 592 if (hours > 99) 593 { 594 ConvertUInt64ToString(hours, s); 595 for (; *s != 0; s++); 596 } 597 else 598 { 599 UInt32 hours32 = (UInt32)hours; 600 UINT_TO_STR_2(hours32); 601 } 602 *s++ = ':'; UINT_TO_STR_2(minutes); 603 *s++ = ':'; UINT_TO_STR_2(seconds); 604 *s = 0; 605 } 606 607 static void ConvertSizeToString(UInt64 v, wchar_t *s) 608 { 609 Byte c = 0; 610 if (v >= ((UInt64)100000 << 20)) { v >>= 30; c = 'G'; } 611 else if (v >= ((UInt64)100000 << 10)) { v >>= 20; c = 'M'; } 612 else if (v >= ((UInt64)100000 << 0)) { v >>= 10; c = 'K'; } 613 ConvertUInt64ToString(v, s); 614 if (c != 0) 615 { 616 s += MyStringLen(s); 617 *s++ = ' '; 618 *s++ = c; 619 *s++ = 0; 620 } 621 } 622 623 void CProgressDialog::ShowSize(int id, UInt64 val, UInt64 &prev) 624 { 625 if (val == prev) 626 return; 627 prev = val; 628 wchar_t s[40]; 629 s[0] = 0; 630 if (IS_DEFINED_VAL(val)) 631 ConvertSizeToString(val, s); 632 SetItemText(id, s); 633 } 634 635 static void GetChangedString(const UString &newStr, UString &prevStr, bool &hasChanged) 636 { 637 hasChanged = !(prevStr == newStr); 638 if (hasChanged) 639 prevStr = newStr; 640 } 641 642 static unsigned GetPower32(UInt32 val) 643 { 644 const unsigned kStart = 32; 645 UInt32 mask = ((UInt32)1 << (kStart - 1)); 646 for (unsigned i = kStart;; i--) 647 { 648 if (i == 0 || (val & mask) != 0) 649 return i; 650 mask >>= 1; 651 } 652 } 653 654 static unsigned GetPower64(UInt64 val) 655 { 656 UInt32 high = (UInt32)(val >> 32); 657 if (high == 0) 658 return GetPower32((UInt32)val); 659 return GetPower32(high) + 32; 660 } 661 662 static UInt64 MyMultAndDiv(UInt64 mult1, UInt64 mult2, UInt64 divider) 663 { 664 unsigned pow1 = GetPower64(mult1); 665 unsigned pow2 = GetPower64(mult2); 666 while (pow1 + pow2 > 64) 667 { 668 if (pow1 > pow2) { pow1--; mult1 >>= 1; } 669 else { pow2--; mult2 >>= 1; } 670 divider >>= 1; 671 } 672 UInt64 res = mult1 * mult2; 673 if (divider != 0) 674 res /= divider; 675 return res; 676 } 677 678 void CProgressDialog::UpdateStatInfo(bool showAll) 679 { 680 UInt64 total, completed, totalFiles, completedFiles, inSize, outSize; 681 bool bytesProgressMode; 682 683 bool titleFileName_Changed; 684 bool curFilePath_Changed; 685 bool status_Changed; 686 unsigned numErrors; 687 { 688 NSynchronization::CCriticalSectionLock lock(Sync._cs); 689 total = Sync._totalBytes; 690 completed = Sync._completedBytes; 691 totalFiles = Sync._totalFiles; 692 completedFiles = Sync._curFiles; 693 inSize = Sync._inSize; 694 outSize = Sync._outSize; 695 bytesProgressMode = Sync._bytesProgressMode; 696 697 GetChangedString(Sync._titleFileName, _titleFileName, titleFileName_Changed); 698 GetChangedString(Sync._filePath, _filePath, curFilePath_Changed); 699 GetChangedString(Sync._status, _status, status_Changed); 700 if (_isDir != Sync._isDir) 701 { 702 curFilePath_Changed = true; 703 _isDir = Sync._isDir; 704 } 705 numErrors = Sync.Messages.Size(); 706 } 707 708 UInt32 curTime = ::GetTickCount(); 709 710 const UInt64 progressTotal = bytesProgressMode ? total : totalFiles; 711 const UInt64 progressCompleted = bytesProgressMode ? completed : completedFiles; 712 { 713 if (IS_UNDEFINED_VAL(progressTotal)) 714 { 715 // SetPos(0); 716 // SetRange(progressCompleted); 717 } 718 else 719 { 720 if (_progressBar_Pos != 0 || progressCompleted != 0 || 721 (_progressBar_Range == 0 && progressTotal != 0)) 722 { 723 SetProgressRange(progressTotal); 724 SetProgressPos(progressCompleted); 725 } 726 } 727 } 728 729 ShowSize(IDT_PROGRESS_TOTAL_VAL, total, _totalBytes_Prev); 730 731 _elapsedTime += (curTime - _prevTime); 732 _prevTime = curTime; 733 UInt64 elapsedSec = _elapsedTime / 1000; 734 bool elapsedChanged = false; 735 if (elapsedSec != _prevElapsedSec) 736 { 737 _prevElapsedSec = elapsedSec; 738 elapsedChanged = true; 739 wchar_t s[40]; 740 GetTimeString(elapsedSec, s); 741 SetItemText(IDT_PROGRESS_ELAPSED_VAL, s); 742 } 743 744 bool needSetTitle = false; 745 if (elapsedChanged || showAll) 746 { 747 if (numErrors > _numPostedMessages) 748 { 749 UpdateMessagesDialog(); 750 wchar_t s[32]; 751 ConvertUInt64ToString(numErrors, s); 752 SetItemText(IDT_PROGRESS_ERRORS_VAL, s); 753 if (!_errorsWereDisplayed) 754 { 755 _errorsWereDisplayed = true; 756 EnableErrorsControls(true); 757 SetTaskbarProgressState(); 758 } 759 } 760 761 if (progressCompleted != 0) 762 { 763 if (IS_UNDEFINED_VAL(progressTotal)) 764 { 765 if (IS_DEFINED_VAL(_prevRemainingSec)) 766 { 767 INIT_AS_UNDEFINED(_prevRemainingSec); 768 SetItemText(IDT_PROGRESS_REMAINING_VAL, L""); 769 } 770 } 771 else 772 { 773 UInt64 remainingTime = 0; 774 if (progressCompleted < progressTotal) 775 remainingTime = MyMultAndDiv(_elapsedTime, progressTotal - progressCompleted, progressCompleted); 776 UInt64 remainingSec = remainingTime / 1000; 777 if (remainingSec != _prevRemainingSec) 778 { 779 _prevRemainingSec = remainingSec; 780 wchar_t s[40]; 781 GetTimeString(remainingSec, s); 782 SetItemText(IDT_PROGRESS_REMAINING_VAL, s); 783 } 784 } 785 { 786 UInt64 elapsedTime = (_elapsedTime == 0) ? 1 : _elapsedTime; 787 UInt64 v = (progressCompleted * 1000) / elapsedTime; 788 Byte c = 0; 789 unsigned moveBits = 0; 790 if (v >= ((UInt64)10000 << 10)) { moveBits = 20; c = 'M'; } 791 else if (v >= ((UInt64)10000 << 0)) { moveBits = 10; c = 'K'; } 792 v >>= moveBits; 793 if (moveBits != _prevSpeed_MoveBits || v != _prevSpeed) 794 { 795 _prevSpeed_MoveBits = moveBits; 796 _prevSpeed = v; 797 wchar_t s[40]; 798 ConvertUInt64ToString(v, s); 799 unsigned pos = MyStringLen(s); 800 s[pos++] = ' '; 801 if (moveBits != 0) 802 s[pos++] = c; 803 s[pos++] = 'B'; 804 s[pos++] = '/'; 805 s[pos++] = 's'; 806 s[pos++] = 0; 807 SetItemText(IDT_PROGRESS_SPEED_VAL, s); 808 } 809 } 810 } 811 812 { 813 UInt64 percent = 0; 814 { 815 if (IS_DEFINED_VAL(progressTotal)) 816 { 817 percent = progressCompleted * 100; 818 if (progressTotal != 0) 819 percent /= progressTotal; 820 } 821 } 822 if (percent != _prevPercentValue) 823 { 824 _prevPercentValue = percent; 825 needSetTitle = true; 826 } 827 } 828 829 { 830 wchar_t s[64]; 831 ConvertUInt64ToString(completedFiles, s); 832 if (IS_DEFINED_VAL(totalFiles)) 833 { 834 MyStringCat(s, L" / "); 835 ConvertUInt64ToString(totalFiles, s + MyStringLen(s)); 836 } 837 if (_filesStr_Prev != s) 838 { 839 _filesStr_Prev = s; 840 SetItemText(IDT_PROGRESS_FILES_VAL, s); 841 } 842 } 843 844 const UInt64 packSize = CompressingMode ? outSize : inSize; 845 const UInt64 unpackSize = CompressingMode ? inSize : outSize; 846 847 if (IS_UNDEFINED_VAL(unpackSize) && 848 IS_UNDEFINED_VAL(packSize)) 849 { 850 ShowSize(IDT_PROGRESS_PROCESSED_VAL, completed, _processed_Prev); 851 ShowSize(IDT_PROGRESS_PACKED_VAL, UNDEFINED_VAL, _packed_Prev); 852 } 853 else 854 { 855 ShowSize(IDT_PROGRESS_PROCESSED_VAL, unpackSize, _processed_Prev); 856 ShowSize(IDT_PROGRESS_PACKED_VAL, packSize, _packed_Prev); 857 858 if (IS_DEFINED_VAL(packSize) && 859 IS_DEFINED_VAL(unpackSize) && 860 unpackSize != 0) 861 { 862 wchar_t s[32]; 863 UInt64 ratio = packSize * 100 / unpackSize; 864 if (_ratio_Prev != ratio) 865 { 866 _ratio_Prev = ratio; 867 ConvertUInt64ToString(ratio, s); 868 MyStringCat(s, L"%"); 869 SetItemText(IDT_PROGRESS_RATIO_VAL, s); 870 } 871 } 872 } 873 } 874 875 if (needSetTitle || titleFileName_Changed) 876 SetTitleText(); 877 878 if (status_Changed) 879 { 880 UString s = _status; 881 ReduceString(s, _numReduceSymbols); 882 SetItemText(IDT_PROGRESS_STATUS, _status); 883 } 884 885 if (curFilePath_Changed) 886 { 887 UString s1, s2; 888 if (_isDir) 889 s1 = _filePath; 890 else 891 { 892 int slashPos = _filePath.ReverseFind_PathSepar(); 893 if (slashPos >= 0) 894 { 895 s1.SetFrom(_filePath, slashPos + 1); 896 s2 = _filePath.Ptr(slashPos + 1); 897 } 898 else 899 s2 = _filePath; 900 } 901 ReduceString(s1, _numReduceSymbols); 902 ReduceString(s2, _numReduceSymbols); 903 s1.Add_LF(); 904 s1 += s2; 905 SetItemText(IDT_PROGRESS_FILE_NAME, s1); 906 } 907 } 908 909 bool CProgressDialog::OnTimer(WPARAM /* timerID */, LPARAM /* callback */) 910 { 911 if (Sync.Get_Paused()) 912 return true; 913 CheckNeedClose(); 914 UpdateStatInfo(false); 915 return true; 916 } 917 918 struct CWaitCursor 919 { 920 HCURSOR _waitCursor; 921 HCURSOR _oldCursor; 922 CWaitCursor() 923 { 924 _waitCursor = LoadCursor(NULL, IDC_WAIT); 925 if (_waitCursor != NULL) 926 _oldCursor = SetCursor(_waitCursor); 927 } 928 ~CWaitCursor() 929 { 930 if (_waitCursor != NULL) 931 SetCursor(_oldCursor); 932 } 933 }; 934 935 INT_PTR CProgressDialog::Create(const UString &title, NWindows::CThread &thread, HWND wndParent) 936 { 937 INT_PTR res = 0; 938 try 939 { 940 if (WaitMode) 941 { 942 CWaitCursor waitCursor; 943 HANDLE h[] = { thread, _createDialogEvent }; 944 945 WRes res2 = WaitForMultipleObjects(ARRAY_SIZE(h), h, FALSE, kCreateDelay); 946 if (res2 == WAIT_OBJECT_0 && !Sync.ThereIsMessage()) 947 return 0; 948 } 949 _title = title; 950 BIG_DIALOG_SIZE(360, 192); 951 res = CModalDialog::Create(SIZED_DIALOG(IDD_PROGRESS), wndParent); 952 } 953 catch(...) 954 { 955 _wasCreated = true; 956 _dialogCreatedEvent.Set(); 957 res = res; 958 } 959 thread.Wait(); 960 if (!MessagesDisplayed) 961 MessageBoxW(wndParent, L"Progress Error", L"7-Zip", MB_ICONERROR); 962 return res; 963 } 964 965 bool CProgressDialog::OnExternalCloseMessage() 966 { 967 // it doesn't work if there is MessageBox. 968 #ifdef __ITaskbarList3_INTERFACE_DEFINED__ 969 SetTaskbarProgressState(TBPF_NOPROGRESS); 970 #endif 971 // AddToTitle(L"Finished "); 972 // SetText(L"Finished2 "); 973 974 UpdateStatInfo(true); 975 976 SetItemText(IDCANCEL, LangString(IDS_CLOSE)); 977 ::SendMessage(GetItem(IDCANCEL), BM_SETSTYLE, BS_DEFPUSHBUTTON, MAKELPARAM(TRUE, 0)); 978 HideItem(IDB_PROGRESS_BACKGROUND); 979 HideItem(IDB_PAUSE); 980 981 ProcessWasFinished_GuiVirt(); 982 983 bool thereAreMessages; 984 CProgressFinalMessage fm; 985 { 986 NSynchronization::CCriticalSectionLock lock(Sync._cs); 987 thereAreMessages = !Sync.Messages.IsEmpty(); 988 fm = Sync.FinalMessage; 989 } 990 991 if (!fm.ErrorMessage.Message.IsEmpty()) 992 { 993 MessagesDisplayed = true; 994 if (fm.ErrorMessage.Title.IsEmpty()) 995 fm.ErrorMessage.Title = "7-Zip"; 996 MessageBoxW(*this, fm.ErrorMessage.Message, fm.ErrorMessage.Title, MB_ICONERROR); 997 } 998 else if (!thereAreMessages) 999 { 1000 MessagesDisplayed = true; 1001 1002 if (!fm.OkMessage.Message.IsEmpty()) 1003 { 1004 if (fm.OkMessage.Title.IsEmpty()) 1005 fm.OkMessage.Title = "7-Zip"; 1006 MessageBoxW(*this, fm.OkMessage.Message, fm.OkMessage.Title, MB_OK); 1007 } 1008 } 1009 1010 if (thereAreMessages && !_cancelWasPressed) 1011 { 1012 _waitCloseByCancelButton = true; 1013 UpdateMessagesDialog(); 1014 return true; 1015 } 1016 1017 End(0); 1018 return true; 1019 } 1020 1021 bool CProgressDialog::OnMessage(UINT message, WPARAM wParam, LPARAM lParam) 1022 { 1023 switch (message) 1024 { 1025 case kCloseMessage: 1026 { 1027 KillTimer(_timer); 1028 _timer = 0; 1029 if (_inCancelMessageBox) 1030 { 1031 _externalCloseMessageWasReceived = true; 1032 break; 1033 } 1034 return OnExternalCloseMessage(); 1035 } 1036 /* 1037 case WM_SETTEXT: 1038 { 1039 if (_timer == 0) 1040 return true; 1041 break; 1042 } 1043 */ 1044 } 1045 return CModalDialog::OnMessage(message, wParam, lParam); 1046 } 1047 1048 void CProgressDialog::SetTitleText() 1049 { 1050 UString s; 1051 if (Sync.Get_Paused()) 1052 { 1053 s += _paused_String; 1054 s.Add_Space(); 1055 } 1056 if (IS_DEFINED_VAL(_prevPercentValue)) 1057 { 1058 char temp[32]; 1059 ConvertUInt64ToString(_prevPercentValue, temp); 1060 s += temp; 1061 s += '%'; 1062 } 1063 if (!_foreground) 1064 { 1065 s.Add_Space(); 1066 s += _backgrounded_String; 1067 } 1068 1069 s.Add_Space(); 1070 #ifndef _SFX 1071 { 1072 unsigned len = s.Len(); 1073 s += MainAddTitle; 1074 AddToTitle(s); 1075 s.DeleteFrom(len); 1076 } 1077 #endif 1078 1079 s += _title; 1080 if (!_titleFileName.IsEmpty()) 1081 { 1082 UString fileName = _titleFileName; 1083 ReduceString(fileName, kTitleFileNameSizeLimit); 1084 s.Add_Space(); 1085 s += fileName; 1086 } 1087 SetText(s); 1088 } 1089 1090 void CProgressDialog::SetPauseText() 1091 { 1092 SetItemText(IDB_PAUSE, Sync.Get_Paused() ? _continue_String : _pause_String); 1093 SetTitleText(); 1094 } 1095 1096 void CProgressDialog::OnPauseButton() 1097 { 1098 bool paused = !Sync.Get_Paused(); 1099 Sync.Set_Paused(paused); 1100 UInt32 curTime = ::GetTickCount(); 1101 if (paused) 1102 _elapsedTime += (curTime - _prevTime); 1103 SetTaskbarProgressState(); 1104 _prevTime = curTime; 1105 SetPauseText(); 1106 } 1107 1108 void CProgressDialog::SetPriorityText() 1109 { 1110 SetItemText(IDB_PROGRESS_BACKGROUND, _foreground ? 1111 _background_String : 1112 _foreground_String); 1113 SetTitleText(); 1114 } 1115 1116 void CProgressDialog::OnPriorityButton() 1117 { 1118 _foreground = !_foreground; 1119 #ifndef UNDER_CE 1120 SetPriorityClass(GetCurrentProcess(), _foreground ? NORMAL_PRIORITY_CLASS: IDLE_PRIORITY_CLASS); 1121 #endif 1122 SetPriorityText(); 1123 } 1124 1125 void CProgressDialog::AddMessageDirect(LPCWSTR message, bool needNumber) 1126 { 1127 int itemIndex = _messageList.GetItemCount(); 1128 wchar_t sz[16]; 1129 sz[0] = 0; 1130 if (needNumber) 1131 ConvertUInt32ToString(_numMessages + 1, sz); 1132 _messageList.InsertItem(itemIndex, sz); 1133 _messageList.SetSubItem(itemIndex, 1, message); 1134 } 1135 1136 void CProgressDialog::AddMessage(LPCWSTR message) 1137 { 1138 UString s = message; 1139 bool needNumber = true; 1140 while (!s.IsEmpty()) 1141 { 1142 int pos = s.Find(L'\n'); 1143 if (pos < 0) 1144 break; 1145 AddMessageDirect(s.Left(pos), needNumber); 1146 needNumber = false; 1147 s.DeleteFrontal(pos + 1); 1148 } 1149 AddMessageDirect(s, needNumber); 1150 _numMessages++; 1151 } 1152 1153 static unsigned GetNumDigits(UInt32 val) 1154 { 1155 unsigned i; 1156 for (i = 0; val >= 10; i++) 1157 val /= 10; 1158 return i; 1159 } 1160 1161 void CProgressDialog::UpdateMessagesDialog() 1162 { 1163 UStringVector messages; 1164 { 1165 NSynchronization::CCriticalSectionLock lock(Sync._cs); 1166 unsigned num = Sync.Messages.Size(); 1167 if (num > _numPostedMessages) 1168 { 1169 messages.ClearAndReserve(num - _numPostedMessages); 1170 for (unsigned i = _numPostedMessages; i < num; i++) 1171 messages.AddInReserved(Sync.Messages[i]); 1172 _numPostedMessages = num; 1173 } 1174 } 1175 if (!messages.IsEmpty()) 1176 { 1177 FOR_VECTOR (i, messages) 1178 AddMessage(messages[i]); 1179 if (_numAutoSizeMessages < 256 || GetNumDigits(_numPostedMessages) > GetNumDigits(_numAutoSizeMessages)) 1180 { 1181 _messageList.SetColumnWidthAuto(0); 1182 _messageList.SetColumnWidthAuto(1); 1183 _numAutoSizeMessages = _numPostedMessages; 1184 } 1185 } 1186 } 1187 1188 1189 bool CProgressDialog::OnButtonClicked(int buttonID, HWND buttonHWND) 1190 { 1191 switch (buttonID) 1192 { 1193 // case IDOK: // if IDCANCEL is not DEFPUSHBUTTON 1194 case IDCANCEL: 1195 { 1196 if (_waitCloseByCancelButton) 1197 { 1198 MessagesDisplayed = true; 1199 End(IDCLOSE); 1200 break; 1201 } 1202 1203 bool paused = Sync.Get_Paused(); 1204 if (!paused) 1205 OnPauseButton(); 1206 _inCancelMessageBox = true; 1207 int res = ::MessageBoxW(*this, LangString(IDS_PROGRESS_ASK_CANCEL), _title, MB_YESNOCANCEL); 1208 _inCancelMessageBox = false; 1209 if (!paused) 1210 OnPauseButton(); 1211 if (res == IDCANCEL || res == IDNO) 1212 { 1213 if (_externalCloseMessageWasReceived) 1214 OnExternalCloseMessage(); 1215 return true; 1216 } 1217 1218 _cancelWasPressed = true; 1219 MessagesDisplayed = true; 1220 break; 1221 } 1222 1223 case IDB_PAUSE: 1224 OnPauseButton(); 1225 return true; 1226 case IDB_PROGRESS_BACKGROUND: 1227 OnPriorityButton(); 1228 return true; 1229 } 1230 return CModalDialog::OnButtonClicked(buttonID, buttonHWND); 1231 } 1232 1233 void CProgressDialog::CheckNeedClose() 1234 { 1235 if (_needClose) 1236 { 1237 PostMsg(kCloseMessage); 1238 _needClose = false; 1239 } 1240 } 1241 1242 void CProgressDialog::ProcessWasFinished() 1243 { 1244 // Set Window title here. 1245 if (!WaitMode) 1246 WaitCreating(); 1247 1248 if (_wasCreated) 1249 PostMsg(kCloseMessage); 1250 else 1251 _needClose = true; 1252 } 1253 1254 1255 static THREAD_FUNC_DECL MyThreadFunction(void *param) 1256 { 1257 CProgressThreadVirt *p = (CProgressThreadVirt *)param; 1258 try 1259 { 1260 p->Process(); 1261 p->ThreadFinishedOK = true; 1262 } 1263 catch (...) { p->Result = E_FAIL; } 1264 return 0; 1265 } 1266 1267 1268 HRESULT CProgressThreadVirt::Create(const UString &title, HWND parentWindow) 1269 { 1270 NWindows::CThread thread; 1271 RINOK(thread.Create(MyThreadFunction, this)); 1272 CProgressDialog::Create(title, thread, parentWindow); 1273 return S_OK; 1274 } 1275 1276 static void AddMessageToString(UString &dest, const UString &src) 1277 { 1278 if (!src.IsEmpty()) 1279 { 1280 if (!dest.IsEmpty()) 1281 dest.Add_LF(); 1282 dest += src; 1283 } 1284 } 1285 1286 void CProgressThreadVirt::Process() 1287 { 1288 CProgressCloser closer(*this); 1289 UString m; 1290 try { Result = ProcessVirt(); } 1291 catch(const wchar_t *s) { m = s; } 1292 catch(const UString &s) { m = s; } 1293 catch(const char *s) { m = GetUnicodeString(s); } 1294 catch(int v) 1295 { 1296 m = "Error #"; 1297 m.Add_UInt32(v); 1298 } 1299 catch(...) { m = "Error"; } 1300 if (Result != E_ABORT) 1301 { 1302 if (m.IsEmpty() && Result != S_OK) 1303 m = HResultToMessage(Result); 1304 } 1305 AddMessageToString(m, FinalMessage.ErrorMessage.Message); 1306 1307 { 1308 FOR_VECTOR(i, ErrorPaths) 1309 { 1310 if (i >= 32) 1311 break; 1312 AddMessageToString(m, fs2us(ErrorPaths[i])); 1313 } 1314 } 1315 1316 CProgressSync &sync = Sync; 1317 NSynchronization::CCriticalSectionLock lock(sync._cs); 1318 if (m.IsEmpty()) 1319 { 1320 if (!FinalMessage.OkMessage.Message.IsEmpty()) 1321 sync.FinalMessage.OkMessage = FinalMessage.OkMessage; 1322 } 1323 else 1324 { 1325 sync.FinalMessage.ErrorMessage.Message = m; 1326 if (Result == S_OK) 1327 Result = E_FAIL; 1328 } 1329 } 1330 1331 UString HResultToMessage(HRESULT errorCode) 1332 { 1333 if (errorCode == E_OUTOFMEMORY) 1334 return LangString(IDS_MEM_ERROR); 1335 else 1336 return NError::MyFormatMessage(errorCode); 1337 } 1338
