src/kits/tracker/StatusWindow.cpp

   1 /*
   2 Open Tracker License
   3
   4 Terms and Conditions
   5
   6 Copyright (c) 1991-2000, Be Incorporated. All rights reserved.
   7
   8 Permission is hereby granted, free of charge, to any person obtaining a copy of
   9 this software and associated documentation files (the "Software"), to deal in
  10 the Software without restriction, including without limitation the rights to
  11 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
  12 of the Software, and to permit persons to whom the Software is furnished to do
  13 so, subject to the following conditions:
  14
  15 The above copyright notice and this permission notice applies to all licensees
  16 and shall be included in all copies or substantial portions of the Software.
  17
  18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF TITLE, MERCHANTABILITY,
  20 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  21 BE INCORPORATED BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  22 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION
  23 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24
  25 Except as contained in this notice, the name of Be Incorporated shall not be
  26 used in advertising or otherwise to promote the sale, use or other dealings in
  27 this Software without prior written authorization from Be Incorporated.
  28
  29 Tracker(TM), Be(R), BeOS(R), and BeIA(TM) are trademarks or registered trademarks
  30 of Be Incorporated in the United States and other countries. Other brand product
  31 names are registered trademarks or trademarks of their respective holders.
  32 All rights reserved.
  33 */
  34
  35 /*!     A subclass of BWindow that is used to display the status of the Tracker
  36         operations (copying, deleting, etc.).
  37 */
  38
  39
  40 #include <Application.h>
  41 #include <Button.h>
  42 #include <Catalog.h>
  43 #include <ControlLook.h>
  44 #include <Debug.h>
  45 #include <DurationFormat.h>
  46 #include <Locale.h>
  47 #include <MessageFilter.h>
  48 #include <StringView.h>
  49 #include <String.h>
  50 #include <TimeFormat.h>
  51
  52 #include <string.h>
  53
  54 #include "AutoLock.h"
  55 #include "Bitmaps.h"
  56 #include "Commands.h"
  57 #include "StatusWindow.h"
  58 #include "StringForSize.h"
  59 #include "DeskWindow.h"
  60
  61
  62 #undef B_TRANSLATION_CONTEXT
  63 #define B_TRANSLATION_CONTEXT "StatusWindow"
  64
  65
  66 const float kDefaultStatusViewHeight = 50;
  67 const bigtime_t kMaxUpdateInterval = 100000LL;
  68 const bigtime_t kSpeedReferenceInterval = 2000000LL;
  69 const bigtime_t kShowSpeedInterval = 8000000LL;
  70 const bigtime_t kShowEstimatedFinishInterval = 4000000LL;
  71 const BRect kStatusRect(200, 200, 550, 200);
  72
  73 static bigtime_t sLastEstimatedFinishSpeedToggleTime = -1;
  74 static bool sShowSpeed = true;
  75 static const time_t kSecondsPerDay = 24 * 60 * 60;
  76
  77
  78 class TCustomButton : public BButton {
  79 public:
  80                                                                 TCustomButton(BRect frame, uint32 command);
  81         virtual void                            Draw(BRect updateRect);
  82 private:
  83                         typedef BButton _inherited;
  84 };
  85
  86
  87 class BStatusMouseFilter : public BMessageFilter {
  88 public:
  89                                                                 BStatusMouseFilter();
  90         virtual filter_result           Filter(BMessage* message, BHandler** target);
  91 };
  92
  93
  94 namespace BPrivate {
  95 BStatusWindow* gStatusWindow = NULL;
  96 }
  97
  98
  99 //      #pragma mark - BStatusMouseFilter
 100
 101
 102 BStatusMouseFilter::BStatusMouseFilter()
 103         :
 104         BMessageFilter(B_ANY_DELIVERY, B_ANY_SOURCE, B_MOUSE_DOWN)
 105 {
 106 }
 107
 108
 109 filter_result
 110 BStatusMouseFilter::Filter(BMessage* message, BHandler** target)
 111 {
 112         // If the target is the status bar, make sure the message goes to the
 113         // parent view instead.
 114         if ((*target)->Name() != NULL
 115                 && strcmp((*target)->Name(), "StatusBar") == 0) {
 116                 BView* view = dynamic_cast<BView*>(*target);
 117                 if (view != NULL)
 118                         view = view->Parent();
 119
 120                 if (view != NULL)
 121                         *target = view;
 122         }
 123
 124         return B_DISPATCH_MESSAGE;
 125 }
 126
 127
 128 //      #pragma mark - TCustomButton
 129
 130
 131 TCustomButton::TCustomButton(BRect frame, uint32 what)
 132         :
 133         BButton(frame, "", "", new BMessage(what), B_FOLLOW_LEFT | B_FOLLOW_TOP,
 134                 B_WILL_DRAW)
 135 {
 136 }
 137
 138
 139 void
 140 TCustomButton::Draw(BRect updateRect)
 141 {
 142         _inherited::Draw(updateRect);
 143
 144         if (Message()->what == kStopButton) {
 145                 updateRect = Bounds();
 146                 updateRect.InsetBy(9, 8);
 147                 SetHighColor(0, 0, 0);
 148                 if (Value() == B_CONTROL_ON)
 149                         updateRect.OffsetBy(1, 1);
 150                 FillRect(updateRect);
 151         } else {
 152                 updateRect = Bounds();
 153                 updateRect.InsetBy(9, 7);
 154                 BRect rect(updateRect);
 155                 rect.right -= 3;
 156
 157                 updateRect.left += 3;
 158                 updateRect.OffsetBy(1, 0);
 159                 SetHighColor(0, 0, 0);
 160                 if (Value() == B_CONTROL_ON) {
 161                         updateRect.OffsetBy(1, 1);
 162                         rect.OffsetBy(1, 1);
 163                 }
 164                 FillRect(updateRect);
 165                 FillRect(rect);
 166         }
 167 }
 168
 169
 170 // #pragma mark - StatusBackgroundView
 171
 172
 173 class StatusBackgroundView : public BView {
 174 public:
 175         StatusBackgroundView(BRect frame)
 176                 :
 177                 BView(frame, "BackView", B_FOLLOW_ALL, B_WILL_DRAW | B_PULSE_NEEDED)
 178         {
 179                 SetViewUIColor(B_PANEL_BACKGROUND_COLOR);
 180         }
 181
 182         virtual void Pulse()
 183         {
 184                 bigtime_t now = system_time();
 185                 if (sShowSpeed
 186                         && sLastEstimatedFinishSpeedToggleTime + kShowSpeedInterval
 187                                 <= now) {
 188                         sShowSpeed = false;
 189                         sLastEstimatedFinishSpeedToggleTime = now;
 190                 } else if (!sShowSpeed
 191                         && sLastEstimatedFinishSpeedToggleTime
 192                                 + kShowEstimatedFinishInterval <= now) {
 193                         sShowSpeed = true;
 194                         sLastEstimatedFinishSpeedToggleTime = now;
 195                 }
 196         }
 197 };
 198
 199
 200 //      #pragma mark - BStatusWindow
 201
 202
 203 BStatusWindow::BStatusWindow()
 204         :
 205         BWindow(kStatusRect, B_TRANSLATE("Tracker status"),     B_TITLED_WINDOW,
 206                 B_NOT_CLOSABLE | B_NOT_RESIZABLE | B_NOT_ZOOMABLE, B_ALL_WORKSPACES),
 207         fRetainDesktopFocus(false)
 208 {
 209         SetSizeLimits(0, 100000, 0, 100000);
 210         fMouseDownFilter = new BStatusMouseFilter();
 211         AddCommonFilter(fMouseDownFilter);
 212
 213         BView* view = new StatusBackgroundView(Bounds());
 214         AddChild(view);
 215
 216         SetPulseRate(1000000);
 217
 218         Hide();
 219         Show();
 220 }
 221
 222
 223 BStatusWindow::~BStatusWindow()
 224 {
 225 }
 226
 227
 228 void
 229 BStatusWindow::CreateStatusItem(thread_id thread, StatusWindowState type)
 230 {
 231         AutoLock<BWindow> lock(this);
 232
 233         BRect rect(Bounds());
 234         if (BStatusView* lastView = fViewList.LastItem())
 235                 rect.top = lastView->Frame().bottom + 1;
 236         else {
 237                 // This is the first status item, reset speed/estimated finish toggle.
 238                 sShowSpeed = true;
 239                 sLastEstimatedFinishSpeedToggleTime = system_time();
 240         }
 241         rect.bottom = rect.top + kDefaultStatusViewHeight - 1;
 242
 243         BStatusView* view = new BStatusView(rect, thread, type);
 244         // the BStatusView will resize itself if needed in its constructor
 245         ChildAt(0)->AddChild(view);
 246         fViewList.AddItem(view);
 247
 248         ResizeTo(Bounds().Width(), view->Frame().bottom);
 249
 250         // find out if the desktop is the active window
 251         // if the status window is the only thing to take over active state and
 252         // desktop was active to begin with, return focus back to desktop
 253         // when we are done
 254         bool desktopActive = false;
 255         {
 256                 AutoLock<BLooper> lock(be_app);
 257                 int32 count = be_app->CountWindows();
 258                 for (int32 index = 0; index < count; index++) {
 259                         BWindow* window = be_app->WindowAt(index);
 260                         if (dynamic_cast<BDeskWindow*>(window) != NULL
 261                                 && window->IsActive()) {
 262                                 desktopActive = true;
 263                                 break;
 264                         }
 265                 }
 266         }
 267
 268         if (IsHidden()) {
 269                 fRetainDesktopFocus = desktopActive;
 270                 Minimize(false);
 271                 Show();
 272         } else
 273                 fRetainDesktopFocus &= desktopActive;
 274 }
 275
 276
 277 void
 278 BStatusWindow::InitStatusItem(thread_id thread, int32 totalItems,
 279         off_t totalSize, const entry_ref* destDir, bool showCount)
 280 {
 281         AutoLock<BWindow> lock(this);
 282
 283         int32 numItems = fViewList.CountItems();
 284         for (int32 index = 0; index < numItems; index++) {
 285                 BStatusView* view = fViewList.ItemAt(index);
 286                 if (view->Thread() == thread) {
 287                         view->InitStatus(totalItems, totalSize, destDir, showCount);
 288                         break;
 289                 }
 290         }
 291
 292 }
 293
 294
 295 void
 296 BStatusWindow::UpdateStatus(thread_id thread, const char* curItem,
 297         off_t itemSize, bool optional)
 298 {
 299         AutoLock<BWindow> lock(this);
 300
 301         int32 numItems = fViewList.CountItems();
 302         for (int32 index = 0; index < numItems; index++) {
 303                 BStatusView* view = fViewList.ItemAt(index);
 304                 if (view->Thread() == thread) {
 305                         view->UpdateStatus(curItem, itemSize, optional);
 306                         break;
 307                 }
 308         }
 309 }
 310
 311
 312 void
 313 BStatusWindow::RemoveStatusItem(thread_id thread)
 314 {
 315         AutoLock<BWindow> lock(this);
 316         BStatusView* winner = NULL;
 317
 318         int32 numItems = fViewList.CountItems();
 319         int32 index;
 320         for (index = 0; index < numItems; index++) {
 321                 BStatusView* view = fViewList.ItemAt(index);
 322                 if (view->Thread() == thread) {
 323                         winner = view;
 324                         break;
 325                 }
 326         }
 327
 328         if (winner != NULL) {
 329                 // The height by which the other views will have to be moved
 330                 // (in pixel count).
 331                 float height = winner->Bounds().Height() + 1;
 332                 fViewList.RemoveItem(winner);
 333                 winner->RemoveSelf();
 334                 delete winner;
 335
 336                 if (--numItems == 0 && !IsHidden()) {
 337                         BDeskWindow* desktop = NULL;
 338                         if (fRetainDesktopFocus) {
 339                                 AutoLock<BLooper> lock(be_app);
 340                                 int32 count = be_app->CountWindows();
 341                                 for (int32 index = 0; index < count; index++) {
 342                                         desktop = dynamic_cast<BDeskWindow*>(
 343                                                 be_app->WindowAt(index));
 344                                         if (desktop != NULL)
 345                                                 break;
 346                                 }
 347                         }
 348                         Hide();
 349                         if (desktop != NULL) {
 350                                 // desktop was active when we first started,
 351                                 // make it active again
 352                                 desktop->Activate();
 353                         }
 354                 }
 355
 356                 for (; index < numItems; index++)
 357                         fViewList.ItemAt(index)->MoveBy(0, -height);
 358
 359                 ResizeTo(Bounds().Width(), Bounds().Height() - height);
 360         }
 361 }
 362
 363
 364 bool
 365 BStatusWindow::CheckCanceledOrPaused(thread_id thread)
 366 {
 367         bool wasCanceled = false;
 368         bool isPaused = false;
 369
 370         BStatusView* view = NULL;
 371
 372         AutoLock<BWindow> lock(this);
 373         // check if cancel or pause hit
 374         for (int32 index = fViewList.CountItems() - 1; index >= 0; index--) {
 375                 view = fViewList.ItemAt(index);
 376                 if (view && view->Thread() == thread) {
 377                         isPaused = view->IsPaused();
 378                         wasCanceled = view->WasCanceled();
 379                         break;
 380                 }
 381         }
 382
 383         if (wasCanceled || !isPaused)
 384                 return wasCanceled;
 385
 386         if (isPaused && view != NULL) {
 387                 // say we are paused
 388                 view->Invalidate();
 389                 thread_id thread = view->Thread();
 390
 391                 lock.Unlock();
 392
 393                 // and suspend ourselves
 394                 // we will get resumed from BStatusView::MessageReceived
 395                 ASSERT(find_thread(NULL) == thread);
 396                 suspend_thread(thread);
 397         }
 398
 399         return wasCanceled;
 400 }
 401
 402
 403 bool
 404 BStatusWindow::AttemptToQuit()
 405 {
 406         // called when tracker is quitting
 407         // try to cancel all the move/copy/empty trash threads in a nice way
 408         // by issuing cancels
 409         int32 count = fViewList.CountItems();
 410
 411         if (count == 0)
 412                 return true;
 413
 414         for (int32 index = 0; index < count; index++)
 415                 fViewList.ItemAt(index)->SetWasCanceled();
 416
 417         // maybe next time everything will have been canceled
 418         return false;
 419 }
 420
 421
 422 void
 423 BStatusWindow::WindowActivated(bool state)
 424 {
 425         if (!state)
 426                 fRetainDesktopFocus = false;
 427
 428         return _inherited::WindowActivated(state);
 429 }
 430
 431
 432 // #pragma mark - BStatusView
 433
 434
 435 BStatusView::BStatusView(BRect bounds, thread_id thread, StatusWindowState type)
 436         :
 437         BView(bounds, "StatusView", B_FOLLOW_NONE, B_WILL_DRAW),
 438         fStatusBar(NULL),
 439         fType(type),
 440         fBitmap(NULL),
 441         fStopButton(NULL),
 442         fPauseButton(NULL),
 443         fThread(thread)
 444 {
 445         Init();
 446
 447         SetViewUIColor(B_PANEL_BACKGROUND_COLOR);
 448         SetLowUIColor(ViewUIColor());
 449         SetHighColor(20, 20, 20);
 450         SetDrawingMode(B_OP_ALPHA);
 451
 452         const float buttonWidth = 22;
 453         const float buttonHeight = 20;
 454
 455         BRect rect(bounds);
 456         rect.OffsetTo(B_ORIGIN);
 457         rect.left += 40;
 458         rect.right -= buttonWidth * 2 + 12;
 459         rect.top += 6;
 460         rect.bottom = rect.top + 15;
 461
 462         BString caption;
 463         int32 id = 0;
 464
 465         switch (type) {
 466                 case kCopyState:
 467                         caption = B_TRANSLATE("Preparing to copy items" B_UTF8_ELLIPSIS);
 468                         id = R_CopyStatusIcon;
 469                         break;
 470
 471                 case kMoveState:
 472                         caption = B_TRANSLATE("Preparing to move items" B_UTF8_ELLIPSIS);
 473                         id = R_MoveStatusIcon;
 474                         break;
 475
 476                 case kCreateLinkState:
 477                         caption = B_TRANSLATE("Preparing to create links"
 478                                 B_UTF8_ELLIPSIS);
 479                         id = R_MoveStatusIcon;
 480                         break;
 481
 482                 case kTrashState:
 483                         caption = B_TRANSLATE("Preparing to empty Trash" B_UTF8_ELLIPSIS);
 484                         id = R_TrashIcon;
 485                         break;
 486
 487                 case kVolumeState:
 488                         caption = B_TRANSLATE("Searching for disks to mount"
 489                                 B_UTF8_ELLIPSIS);
 490                         break;
 491
 492                 case kDeleteState:
 493                         caption = B_TRANSLATE("Preparing to delete items"
 494                                 B_UTF8_ELLIPSIS);
 495                         id = R_TrashIcon;
 496                         break;
 497
 498                 case kRestoreFromTrashState:
 499                         caption = B_TRANSLATE("Preparing to restore items"
 500                                 B_UTF8_ELLIPSIS);
 501                         break;
 502
 503                 default:
 504                         TRESPASS();
 505                         break;
 506         }
 507
 508         if (caption.Length() != 0) {
 509                 fStatusBar = new BStatusBar(rect, "StatusBar", caption.String());
 510                 fStatusBar->SetBarHeight(12);
 511                 float width, height;
 512                 fStatusBar->GetPreferredSize(&width, &height);
 513                 fStatusBar->ResizeTo(fStatusBar->Frame().Width(), height);
 514                 AddChild(fStatusBar);
 515
 516                 // Figure out how much room we need to display the additional status
 517                 // message below the bar
 518                 font_height fh;
 519                 GetFontHeight(&fh);
 520                 BRect f = fStatusBar->Frame();
 521                 // Height is 3 x the "room from the top" + bar height + room for
 522                 // string.
 523                 ResizeTo(Bounds().Width(), f.top + f.Height() + fh.leading + fh.ascent
 524                         + fh.descent + f.top);
 525         }
 526
 527         if (id != 0) {
 528                 fBitmap = new BBitmap(BRect(0, 0, 16, 16), B_RGBA32);
 529                 GetTrackerResources()->GetIconResource(id, B_MINI_ICON,
 530                         fBitmap);
 531         }
 532
 533         rect = Bounds();
 534         rect.left = rect.right - buttonWidth * 2 - 7;
 535         rect.right = rect.left + buttonWidth;
 536         rect.top = floorf((rect.top + rect.bottom) / 2 + 0.5) - buttonHeight / 2;
 537         rect.bottom = rect.top + buttonHeight;
 538
 539         fPauseButton = new TCustomButton(rect, kPauseButton);
 540         fPauseButton->ResizeTo(buttonWidth, buttonHeight);
 541         AddChild(fPauseButton);
 542
 543         rect.OffsetBy(buttonWidth + 2, 0);
 544         fStopButton = new TCustomButton(rect, kStopButton);
 545         fStopButton->ResizeTo(buttonWidth, buttonHeight);
 546         AddChild(fStopButton);
 547 }
 548
 549
 550 BStatusView::~BStatusView()
 551 {
 552         delete fBitmap;
 553 }
 554
 555
 556 void
 557 BStatusView::Init()
 558 {
 559         fTotalSize = fItemSize = fSizeProcessed = fLastSpeedReferenceSize
 560                 = fEstimatedFinishReferenceSize = 0;
 561         fCurItem = 0;
 562         fLastUpdateTime = fLastSpeedReferenceTime = fProcessStartTime
 563                 = fLastSpeedUpdateTime = fEstimatedFinishReferenceTime
 564                 = system_time();
 565         fCurrentBytesPerSecondSlot = 0;
 566         for (size_t i = 0; i < kBytesPerSecondSlots; i++)
 567                 fBytesPerSecondSlot[i] = 0.0;
 568
 569         fBytesPerSecond = 0.0;
 570         fShowCount = fWasCanceled = fIsPaused = false;
 571         fDestDir.SetTo("");
 572         fPendingStatusString[0] = '\0';
 573 }
 574
 575
 576 void
 577 BStatusView::InitStatus(int32 totalItems, off_t totalSize,
 578         const entry_ref* destDir, bool showCount)
 579 {
 580         Init();
 581         fTotalSize = totalSize;
 582         fShowCount = showCount;
 583
 584         BEntry entry;
 585         char name[B_FILE_NAME_LENGTH];
 586         if (destDir != NULL && entry.SetTo(destDir) == B_OK) {
 587                 entry.GetName(name);
 588                 fDestDir.SetTo(name);
 589         }
 590
 591         BString buffer;
 592         if (totalItems > 0) {
 593                 char totalStr[32];
 594                 buffer.SetTo(B_TRANSLATE("of %items"));
 595                 snprintf(totalStr, sizeof(totalStr), "%" B_PRId32, totalItems);
 596                 buffer.ReplaceFirst("%items", totalStr);
 597         }
 598
 599         switch (fType) {
 600                 case kCopyState:
 601                         fStatusBar->Reset(B_TRANSLATE("Copying: "), buffer.String());
 602                         break;
 603
 604                 case kCreateLinkState:
 605                         fStatusBar->Reset(B_TRANSLATE("Creating links: "),
 606                                 buffer.String());
 607                         break;
 608
 609                 case kMoveState:
 610                         fStatusBar->Reset(B_TRANSLATE("Moving: "), buffer.String());
 611                         break;
 612
 613                 case kTrashState:
 614                         fStatusBar->Reset(
 615                                 B_TRANSLATE("Emptying Trash" B_UTF8_ELLIPSIS " "),
 616                                 buffer.String());
 617                         break;
 618
 619                 case kDeleteState:
 620                         fStatusBar->Reset(B_TRANSLATE("Deleting: "), buffer.String());
 621                         break;
 622
 623                 case kRestoreFromTrashState:
 624                         fStatusBar->Reset(B_TRANSLATE("Restoring: "), buffer.String());
 625                         break;
 626         }
 627
 628         fStatusBar->SetMaxValue(1);
 629                 // SetMaxValue has to be here because Reset changes it to 100
 630         Invalidate();
 631 }
 632
 633
 634 void
 635 BStatusView::Draw(BRect updateRect)
 636 {
 637         if (fBitmap != NULL) {
 638                 BPoint location;
 639                 location.x = (fStatusBar->Frame().left
 640                         - fBitmap->Bounds().Width()) / 2;
 641                 location.y = (Bounds().Height()- fBitmap->Bounds().Height()) / 2;
 642                 DrawBitmap(fBitmap, location);
 643         }
 644
 645         BRect bounds(Bounds());
 646         be_control_look->DrawRaisedBorder(this, bounds, updateRect, ViewColor());
 647
 648         SetHighColor(0, 0, 0);
 649
 650         BPoint tp = fStatusBar->Frame().LeftBottom();
 651         font_height fh;
 652         GetFontHeight(&fh);
 653         tp.y += ceilf(fh.leading) + ceilf(fh.ascent);
 654         if (IsPaused()) {
 655                 DrawString(B_TRANSLATE("Paused: click to resume or stop"), tp);
 656                 return;
 657         }
 658
 659         BFont font;
 660         GetFont(&font);
 661         float normalFontSize = font.Size();
 662         float smallFontSize = max_c(normalFontSize * 0.8f, 8.0f);
 663         float availableSpace = fStatusBar->Frame().Width();
 664         availableSpace -= be_control_look->DefaultLabelSpacing();
 665                 // subtract to provide some room between our two strings
 666
 667         float destinationStringWidth = 0.f;
 668         BString destinationString(_DestinationString(&destinationStringWidth));
 669         availableSpace -= destinationStringWidth;
 670
 671         float statusStringWidth = 0.f;
 672         BString statusString(_StatusString(availableSpace, smallFontSize,
 673                 &statusStringWidth));
 674
 675         if (statusStringWidth > availableSpace) {
 676                 TruncateString(&destinationString, B_TRUNCATE_MIDDLE,
 677                         availableSpace + destinationStringWidth - statusStringWidth);
 678         }
 679
 680         BPoint textPoint = fStatusBar->Frame().LeftBottom();
 681         textPoint.y += ceilf(fh.leading) + ceilf(fh.ascent);
 682
 683         if (destinationStringWidth > 0) {
 684                 DrawString(destinationString.String(), textPoint);
 685         }
 686
 687         SetHighColor(tint_color(LowColor(), B_DARKEN_4_TINT));
 688         font.SetSize(smallFontSize);
 689         SetFont(&font, B_FONT_SIZE);
 690
 691         textPoint.x = fStatusBar->Frame().right - statusStringWidth;
 692         DrawString(statusString.String(), textPoint);
 693
 694         font.SetSize(normalFontSize);
 695         SetFont(&font, B_FONT_SIZE);
 696 }
 697
 698
 699 BString
 700 BStatusView::_DestinationString(float* _width)
 701 {
 702         if (fDestDir.Length() > 0) {
 703                 BString buffer(B_TRANSLATE("To: %dir"));
 704                 buffer.ReplaceFirst("%dir", fDestDir);
 705
 706                 *_width = ceilf(StringWidth(buffer.String()));
 707                 return buffer;
 708         } else {
 709                 *_width = 0;
 710                 return BString();
 711         }
 712 }
 713
 714
 715 BString
 716 BStatusView::_StatusString(float availableSpace, float fontSize,
 717         float* _width)
 718 {
 719         BFont font;
 720         GetFont(&font);
 721         float oldSize = font.Size();
 722         font.SetSize(fontSize);
 723         SetFont(&font, B_FONT_SIZE);
 724
 725         BString status;
 726         if (sShowSpeed) {
 727                 status = _SpeedStatusString(availableSpace, _width);
 728         } else
 729                 status = _TimeStatusString(availableSpace, _width);
 730
 731         font.SetSize(oldSize);
 732         SetFont(&font, B_FONT_SIZE);
 733         return status;
 734 }
 735
 736
 737 BString
 738 BStatusView::_SpeedStatusString(float availableSpace, float* _width)
 739 {
 740         BString string(_FullSpeedString());
 741         *_width = StringWidth(string.String());
 742         if (*_width > availableSpace) {
 743                 string.SetTo(_ShortSpeedString());
 744                 *_width = StringWidth(string.String());
 745         }
 746         *_width = ceilf(*_width);
 747         return string;
 748 }
 749
 750
 751 BString
 752 BStatusView::_FullSpeedString()
 753 {
 754         BString buffer;
 755         if (fBytesPerSecond != 0.0) {
 756                 char sizeBuffer[128];
 757                 buffer.SetTo(B_TRANSLATE(
 758                         "%SizeProcessed of %TotalSize, %BytesPerSecond/s"));
 759                 buffer.ReplaceFirst("%SizeProcessed",
 760                         string_for_size((double)fSizeProcessed, sizeBuffer,
 761                         sizeof(sizeBuffer)));
 762                 buffer.ReplaceFirst("%TotalSize",
 763                         string_for_size((double)fTotalSize, sizeBuffer,
 764                         sizeof(sizeBuffer)));
 765                 buffer.ReplaceFirst("%BytesPerSecond",
 766                         string_for_size(fBytesPerSecond, sizeBuffer, sizeof(sizeBuffer)));
 767         }
 768
 769         return buffer;
 770 }
 771
 772
 773 BString
 774 BStatusView::_ShortSpeedString()
 775 {
 776         BString buffer;
 777         if (fBytesPerSecond != 0.0) {
 778                 char sizeBuffer[128];
 779                 buffer << B_TRANSLATE("%BytesPerSecond/s");
 780                 buffer.ReplaceFirst("%BytesPerSecond",
 781                         string_for_size(fBytesPerSecond, sizeBuffer, sizeof(sizeBuffer)));
 782         }
 783
 784         return buffer;
 785 }
 786
 787
 788 BString
 789 BStatusView::_TimeStatusString(float availableSpace, float* _width)
 790 {
 791         double totalBytesPerSecond = (double)(fSizeProcessed
 792                         - fEstimatedFinishReferenceSize)
 793                 * 1000000LL / (system_time() - fEstimatedFinishReferenceTime);
 794         double secondsRemaining = (fTotalSize - fSizeProcessed)
 795                 / totalBytesPerSecond;
 796         time_t now = (time_t)real_time_clock();
 797         time_t finishTime = (time_t)(now + secondsRemaining);
 798
 799         char timeText[32];
 800         if (finishTime - now > kSecondsPerDay) {
 801                 BDateTimeFormat().Format(timeText, sizeof(timeText), finishTime,
 802                         B_MEDIUM_DATE_FORMAT, B_MEDIUM_TIME_FORMAT);
 803         } else {
 804                 BTimeFormat().Format(timeText, sizeof(timeText), finishTime,
 805                         B_MEDIUM_TIME_FORMAT);
 806         }
 807
 808         BString string(_FullTimeRemainingString(now, finishTime, timeText));
 809         float width = StringWidth(string.String());
 810         if (width > availableSpace) {
 811                 string.SetTo(_ShortTimeRemainingString(timeText));
 812                 width = StringWidth(string.String());
 813         }
 814
 815         if (_width != NULL)
 816                 *_width = width;
 817
 818         return string;
 819 }
 820
 821
 822 BString
 823 BStatusView::_ShortTimeRemainingString(const char* timeText)
 824 {
 825         BString buffer;
 826
 827         // complete string too wide, try with shorter version
 828         buffer.SetTo(B_TRANSLATE("Finish: %time"));
 829         buffer.ReplaceFirst("%time", timeText);
 830
 831         return buffer;
 832 }
 833
 834
 835 BString
 836 BStatusView::_FullTimeRemainingString(time_t now, time_t finishTime,
 837         const char* timeText)
 838 {
 839         BDurationFormat formatter;
 840         BString buffer;
 841         BString finishStr;
 842         if (finishTime - now > 60 * 60) {
 843                 buffer.SetTo(B_TRANSLATE("Finish: %time - Over %finishtime left"));
 844                 formatter.Format(finishStr, now * 1000000LL, finishTime * 1000000LL);
 845         } else {
 846                 buffer.SetTo(B_TRANSLATE("Finish: %time - %finishtime left"));
 847                 formatter.Format(finishStr, now * 1000000LL, finishTime * 1000000LL);
 848         }
 849
 850         buffer.ReplaceFirst("%time", timeText);
 851         buffer.ReplaceFirst("%finishtime", finishStr);
 852
 853         return buffer;
 854 }
 855
 856
 857 void
 858 BStatusView::AttachedToWindow()
 859 {
 860         fPauseButton->SetTarget(this);
 861         fStopButton->SetTarget(this);
 862 }
 863
 864
 865 void
 866 BStatusView::MessageReceived(BMessage* message)
 867 {
 868         switch (message->what) {
 869                 case kPauseButton:
 870                         fIsPaused = !fIsPaused;
 871                         fPauseButton->SetValue(fIsPaused ? B_CONTROL_ON : B_CONTROL_OFF);
 872                         if (fBytesPerSecond != 0.0) {
 873                                 fBytesPerSecond = 0.0;
 874                                 for (size_t i = 0; i < kBytesPerSecondSlots; i++)
 875                                         fBytesPerSecondSlot[i] = 0.0;
 876                                 Invalidate();
 877                         }
 878                         if (!fIsPaused) {
 879                                 fEstimatedFinishReferenceTime = system_time();
 880                                 fEstimatedFinishReferenceSize = fSizeProcessed;
 881
 882                                 // force window update
 883                                 Invalidate();
 884
 885                                 // let 'er rip
 886                                 resume_thread(Thread());
 887                         }
 888                         break;
 889
 890                 case kStopButton:
 891                         fWasCanceled = true;
 892                         if (fIsPaused) {
 893                                 // resume so that the copy loop gets a chance to finish up
 894                                 fIsPaused = false;
 895
 896                                 // force window update
 897                                 Invalidate();
 898
 899                                 // let 'er rip
 900                                 resume_thread(Thread());
 901                         }
 902                         break;
 903
 904                 default:
 905                         _inherited::MessageReceived(message);
 906                         break;
 907         }
 908 }
 909
 910
 911 void
 912 BStatusView::UpdateStatus(const char* curItem, off_t itemSize, bool optional)
 913 {
 914         if (!fShowCount) {
 915                 fStatusBar->Update((float)fItemSize / fTotalSize);
 916                 fItemSize = 0;
 917                 return;
 918         }
 919
 920         if (curItem != NULL)
 921                 fCurItem++;
 922
 923         fItemSize += itemSize;
 924         fSizeProcessed += itemSize;
 925
 926         bigtime_t currentTime = system_time();
 927         if (!optional || ((currentTime - fLastUpdateTime) > kMaxUpdateInterval)) {
 928                 if (curItem != NULL || fPendingStatusString[0]) {
 929                         // forced update or past update time
 930
 931                         BString buffer;
 932                         buffer <<  fCurItem << " ";
 933
 934                         // if we don't have curItem, take the one from the stash
 935                         const char* statusItem = curItem != NULL
 936                                 ? curItem : fPendingStatusString;
 937
 938                         fStatusBar->Update((float)fItemSize / fTotalSize, statusItem,
 939                                 buffer.String());
 940
 941                         // we already displayed this item, clear the stash
 942                         fPendingStatusString[0] =  '\0';
 943
 944                         fLastUpdateTime = currentTime;
 945                 } else {
 946                         // don't have a file to show, just update the bar
 947                         fStatusBar->Update((float)fItemSize / fTotalSize);
 948                 }
 949
 950                 if (currentTime
 951                                 >= fLastSpeedReferenceTime + kSpeedReferenceInterval) {
 952                         // update current speed every kSpeedReferenceInterval
 953                         fCurrentBytesPerSecondSlot
 954                                 = (fCurrentBytesPerSecondSlot + 1) % kBytesPerSecondSlots;
 955                         fBytesPerSecondSlot[fCurrentBytesPerSecondSlot]
 956                                 = (double)(fSizeProcessed - fLastSpeedReferenceSize)
 957                                         * 1000000LL / (currentTime - fLastSpeedReferenceTime);
 958                         fLastSpeedReferenceSize = fSizeProcessed;
 959                         fLastSpeedReferenceTime = currentTime;
 960                         fBytesPerSecond = 0.0;
 961                         size_t count = 0;
 962                         for (size_t i = 0; i < kBytesPerSecondSlots; i++) {
 963                                 if (fBytesPerSecondSlot[i] != 0.0) {
 964                                         fBytesPerSecond += fBytesPerSecondSlot[i];
 965                                         count++;
 966                                 }
 967                         }
 968                         if (count > 0)
 969                                 fBytesPerSecond /= count;
 970
 971                         BString toolTip = _TimeStatusString(1024.f, NULL);
 972                         toolTip << "\n" << _FullSpeedString();
 973                         SetToolTip(toolTip.String());
 974
 975                         Invalidate();
 976                 }
 977
 978                 fItemSize = 0;
 979         } else if (curItem != NULL) {
 980                 // stash away the name of the item we are currently processing
 981                 // so we can show it when the time comes
 982                 strncpy(fPendingStatusString, curItem, 127);
 983                 fPendingStatusString[127] = '0';
 984         } else
 985                 SetToolTip((const char*)NULL);
 986 }
 987
 988
 989 void
 990 BStatusView::SetWasCanceled()
 991 {
 992         fWasCanceled = true;
 993 }