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