Download bar MD overhaul, part 3

chrome/browser/ui/views/download/download_item_view_md.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/views/download/download_item_view_md.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 54 matching lines @@
 using content::DownloadItem;
 using extensions::ExperienceSamplingEvent;
 
 namespace {
 
 // All values in dp.
 const int kTextWidth = 140;
 const int kDangerousTextWidth = 200;
 
 // The normal height of the item which may be exceeded if text is large.
-const int kDefaultHeight = 36;
+const int kDefaultHeight = 48;
+
+// The vertical distance between the item's visual upper bound (as delineated by
+// the separator on the right) and the edge of the shelf.
+const int kTopBottomPadding = 6;
 
 // The minimum vertical padding above and below contents of the download item.
 // This is only used when the text size is large.
-const int kMinimumVerticalPadding = 2;
+const int kMinimumVerticalPadding = 2 + kTopBottomPadding;
 
 // Vertical padding between filename and status text.
 const int kVerticalTextPadding = 1;
 
 const int kTooltipMaxWidth = 800;
 
-// Padding before the icon and at end of the item. TODO(estade): this needs to
-// be used when drawing the non-warning dialog state. Currently we just use the
-// built in padding for the progress indicator.
+// Padding before the icon and at end of the item.
 const int kStartPadding = 12;
 const int kEndPadding = 19;
 
+// Horizontal padding between progress indicator and filename/status text.
+const int kProgressTextPadding = 8;
+
 // The space between the Save and Discard buttons when prompting for a dangerous
 // download.
 const int kButtonPadding = 5;
 
 // The space on the left and right side of the dangerous download label.
 const int kLabelPadding = 8;
 
 const SkColor kFileNameDisabledColor = SkColorSetRGB(171, 192, 212);
 
 // How long the 'download complete' animation should last for.
 const int kCompleteAnimationDurationMs = 2500;
 
 // How long the 'download interrupted' animation should last for.
 const int kInterruptedAnimationDurationMs = 2500;
 
 // How long we keep the item disabled after the user clicked it to open the
 // downloaded item.
 const int kDisabledOnOpenDuration = 3000;
 
+// The separator is drawn as a border. It's one dp wide.
+class SeparatorBorder : public views::Border {
+ public:
+  explicit SeparatorBorder(SkColor color) : color_(color) {}
+  ~SeparatorBorder() override {}
+
+  void Paint(const views::View& view, gfx::Canvas* canvas) override {
+    int end_x = base::i18n::IsRTL() ? 0 : view.width() - 1;
+    canvas->DrawLine(gfx::Point(end_x, kTopBottomPadding),
+                     gfx::Point(end_x, view.height() - kTopBottomPadding),
+                     color_);
+  }
+
+  gfx::Insets GetInsets() const override { return gfx::Insets(0, 0, 0, 1); }
+
+  gfx::Size GetMinimumSize() const override {
+    return gfx::Size(1, 2 * kTopBottomPadding + 1);
+  }
+
+ private:
+  SkColor color_;
+
+  DISALLOW_COPY_AND_ASSIGN(SeparatorBorder);
+};
+
 }  // namespace
 
 DownloadItemViewMd::DownloadItemViewMd(DownloadItem* download_item,
                                        DownloadShelfView* parent)
     : warning_icon_(nullptr),
       shelf_(parent),
       status_text_(l10n_util::GetStringUTF16(IDS_DOWNLOAD_STATUS_STARTING)),
       dropdown_state_(NORMAL),
       mode_(NORMAL_MODE),
       dragging_(false),
@@ skipping 195 matching lines @@
   }
 }
 
 gfx::Size DownloadItemViewMd::GetPreferredSize() const {
   int width, height;
 
   // First, we set the height to the height of two rows or text plus margins.
   height = std::max(kDefaultHeight,
                     2 * kMinimumVerticalPadding + font_list_.GetBaseline() +
                         kVerticalTextPadding + status_font_list_.GetHeight());
-  // Then we increase the size if the progress icon doesn't fit.
-  height = std::max<int>(height, DownloadShelf::kProgressIndicatorSize);
 
   if (IsShowingWarningDialog()) {
     width = kStartPadding + warning_icon_->width() + kLabelPadding +
             dangerous_download_label_->width() + kLabelPadding;
     gfx::Size button_size = GetButtonSize();
     // Make sure the button fits.
     height = std::max<int>(height,
                            2 * kMinimumVerticalPadding + button_size.height());
     // Then we make sure the warning icon fits.
     height = std::max<int>(
         height, 2 * kMinimumVerticalPadding + warning_icon_->height());
     if (save_button_)
       width += button_size.width() + kButtonPadding;
     width += button_size.width() + kEndPadding;
   } else {
-    width = kStartPadding + DownloadShelf::kProgressIndicatorSize + kTextWidth +
-            kEndPadding;
+    width = kStartPadding + DownloadShelf::kProgressIndicatorSize +
+            kProgressTextPadding + kTextWidth + kEndPadding;
   }
   return gfx::Size(width, height);
 }
 
 // Handle a mouse click and open the context menu if the mouse is
 // over the drop-down region.
 bool DownloadItemViewMd::OnMousePressed(const ui::MouseEvent& event) {
   HandlePressEvent(event, event.IsOnlyLeftMouseButton());
   return true;
 }
@@ skipping 192 matching lines @@
   if (!status_text_.empty())
     text_height += kVerticalTextPadding + status_font_list_.GetBaseline();
   return (height() - text_height) / 2;
 }
 
 void DownloadItemViewMd::DrawStatusText(gfx::Canvas* canvas) {
   if (status_text_.empty() || IsShowingWarningDialog())
     return;
 
   int mirrored_x = GetMirroredXWithWidthInView(
-      DownloadShelf::kProgressIndicatorSize, kTextWidth);
+      kStartPadding + DownloadShelf::kProgressIndicatorSize +
+          kProgressTextPadding,
+      kTextWidth);
   int y =
       GetYForFilenameText() + font_list_.GetBaseline() + kVerticalTextPadding;
   SkColor file_name_color = SkColorSetA(
       GetThemeProvider()->GetColor(ThemeProperties::COLOR_BOOKMARK_TEXT), 0xC7);
   canvas->DrawStringRect(
       status_text_, status_font_list_, file_name_color,
       gfx::Rect(mirrored_x, y, kTextWidth, status_font_list_.GetHeight()));
 }
 
 void DownloadItemViewMd::DrawFilename(gfx::Canvas* canvas) {
@@ skipping 15 matching lines @@
     // Then, elide the file name.
     base::string16 filename_string =
         gfx::ElideFilename(download()->GetFileNameToReportUser(), font_list_,
                            kTextWidth - status_string_width);
     // Last, concat the whole string.
     filename = l10n_util::GetStringFUTF16(IDS_DOWNLOAD_STATUS_OPENING,
                                           filename_string);
   }
 
   int mirrored_x = GetMirroredXWithWidthInView(
-      DownloadShelf::kProgressIndicatorSize, kTextWidth);
+      kStartPadding + DownloadShelf::kProgressIndicatorSize +
+          kProgressTextPadding,
+      kTextWidth);
   SkColor file_name_color =
       GetThemeProvider()->GetColor(ThemeProperties::COLOR_BOOKMARK_TEXT);
 
   canvas->DrawStringRect(filename, font_list_,
                          enabled() ? file_name_color : kFileNameDisabledColor,
                          gfx::Rect(mirrored_x, GetYForFilenameText(),
                                    kTextWidth, font_list_.GetHeight()));
 }
 
 void DownloadItemViewMd::DrawIcon(gfx::Canvas* canvas) {
   if (IsShowingWarningDialog()) {
-    int icon_x = kStartPadding;
+    int icon_x = base::i18n::IsRTL()
+                     ? width() - warning_icon_->width() - kStartPadding
+                     : kStartPadding;
     int icon_y = (height() - warning_icon_->height()) / 2;
     canvas->DrawImageInt(*warning_icon_, icon_x, icon_y);
     return;
   }
 
   // Paint download progress.
   DownloadItem::DownloadState state = download()->GetState();
   canvas->Save();
-  if (base::i18n::IsRTL()) {
-    canvas->Translate(
-        gfx::Vector2d(width() - DownloadShelf::kProgressIndicatorSize, 0));
-  }
+  int progress_x =
+      base::i18n::IsRTL()
+          ? width() - kStartPadding - DownloadShelf::kProgressIndicatorSize
+          : kStartPadding;
+  int progress_y = (height() - DownloadShelf::kProgressIndicatorSize) / 2;
+  canvas->Translate(gfx::Vector2d(progress_x, progress_y));
 
   if (state == DownloadItem::IN_PROGRESS) {
     base::TimeDelta progress_time = previous_progress_elapsed_;
     if (!download()->IsPaused())
       progress_time += base::TimeTicks::Now() - progress_start_time_;
     DownloadShelf::PaintDownloadProgress(
         canvas, *GetThemeProvider(), progress_time, model_.PercentComplete());
   } else if (complete_animation_.get() && complete_animation_->is_animating()) {
     if (state == DownloadItem::INTERRUPTED) {
       DownloadShelf::PaintDownloadInterrupted(
           canvas, *GetThemeProvider(), complete_animation_->GetCurrentValue());
     } else {
       DCHECK_EQ(DownloadItem::COMPLETE, state);
       DownloadShelf::PaintDownloadComplete(
           canvas, *GetThemeProvider(), complete_animation_->GetCurrentValue());
     }
   }
   canvas->Restore();
 
   // Fetch the already-loaded icon.
   IconManager* im = g_browser_process->icon_manager();
   gfx::Image* icon = im->LookupIconFromFilepath(download()->GetTargetFilePath(),
                                                 IconLoader::SMALL);
   if (!icon)
     return;
 
   // Draw the icon image.
-  int icon_x = DownloadShelf::kFiletypeIconOffset;
-  icon_x = GetMirroredXWithWidthInView(icon_x, icon->Width());
-  int icon_y = DownloadShelf::kFiletypeIconOffset;
-
+  int icon_x = progress_x + DownloadShelf::kFiletypeIconOffset;
+  int icon_y = progress_y + DownloadShelf::kFiletypeIconOffset;
   SkPaint paint;
   // Use an alpha to make the image look disabled.
   if (!enabled())
     paint.setAlpha(120);
   canvas->DrawImageInt(*icon->ToImageSkia(), icon_x, icon_y, paint);
 }
 
 void DownloadItemViewMd::OnFocus() {
   View::OnFocus();
   // We render differently when focused.
@@ skipping 63 matching lines @@
 }
 
 void DownloadItemViewMd::UpdateColorsFromTheme() {
   if (!GetThemeProvider())
     return;
 
   if (dangerous_download_label_) {
     dangerous_download_label_->SetEnabledColor(
         GetThemeProvider()->GetColor(ThemeProperties::COLOR_BOOKMARK_TEXT));
   }
-  SetBorder(views::Border::CreateSolidSidedBorder(
-      0, 0, 0, 1,
-      GetThemeProvider()->GetColor(ThemeProperties::COLOR_TOOLBAR_SEPARATOR)));
+  SetBorder(make_scoped_ptr(new SeparatorBorder(
+      GetThemeProvider()->GetColor(ThemeProperties::COLOR_TOOLBAR_SEPARATOR))));
 }
 
 void DownloadItemViewMd::ShowContextMenuImpl(const gfx::Rect& rect,
                                              ui::MenuSourceType source_type) {
   // Similar hack as in MenuButton.
   // We're about to show the menu from a mouse press. By showing from the
   // mouse press event we block RootView in mouse dispatching. This also
   // appears to cause RootView to get a mouse pressed BEFORE the mouse
   // release is seen, which means RootView sends us another mouse press no
   // matter where the user pressed. To force RootView to recalculate the
@@ skipping 285 matching lines @@
     State to,
     gfx::SlideAnimation* animation) {
   if (from == NORMAL && to == HOT) {
     animation->Show();
   } else if (from == HOT && to == NORMAL) {
     animation->Hide();
   } else if (from != to) {
     animation->Reset((to == HOT) ? 1.0 : 0.0);
   }
 }