| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/browser/ui/gtk/tabs/tab_renderer_gtk.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 #include <utility> | |
| 9 | |
| 10 #include "base/debug/trace_event.h" | |
| 11 #include "base/strings/utf_string_conversions.h" | |
| 12 #include "chrome/browser/chrome_notification_types.h" | |
| 13 #include "chrome/browser/defaults.h" | |
| 14 #include "chrome/browser/extensions/tab_helper.h" | |
| 15 #include "chrome/browser/favicon/favicon_tab_helper.h" | |
| 16 #include "chrome/browser/profiles/profile.h" | |
| 17 #include "chrome/browser/themes/theme_properties.h" | |
| 18 #include "chrome/browser/ui/browser.h" | |
| 19 #include "chrome/browser/ui/gtk/bookmarks/bookmark_utils_gtk.h" | |
| 20 #include "chrome/browser/ui/gtk/custom_button.h" | |
| 21 #include "chrome/browser/ui/gtk/gtk_theme_service.h" | |
| 22 #include "chrome/browser/ui/gtk/gtk_util.h" | |
| 23 #include "chrome/browser/ui/tab_contents/core_tab_helper.h" | |
| 24 #include "chrome/browser/ui/tabs/tab_utils.h" | |
| 25 #include "content/public/browser/notification_source.h" | |
| 26 #include "content/public/browser/web_contents.h" | |
| 27 #include "grit/generated_resources.h" | |
| 28 #include "grit/theme_resources.h" | |
| 29 #include "grit/ui_resources.h" | |
| 30 #include "skia/ext/image_operations.h" | |
| 31 #include "ui/base/gtk/gtk_screen_util.h" | |
| 32 #include "ui/base/l10n/l10n_util.h" | |
| 33 #include "ui/base/resource/resource_bundle.h" | |
| 34 #include "ui/gfx/animation/slide_animation.h" | |
| 35 #include "ui/gfx/animation/throb_animation.h" | |
| 36 #include "ui/gfx/canvas_skia_paint.h" | |
| 37 #include "ui/gfx/favicon_size.h" | |
| 38 #include "ui/gfx/gtk_compat.h" | |
| 39 #include "ui/gfx/gtk_util.h" | |
| 40 #include "ui/gfx/image/cairo_cached_surface.h" | |
| 41 #include "ui/gfx/image/image.h" | |
| 42 #include "ui/gfx/pango_util.h" | |
| 43 #include "ui/gfx/platform_font_pango.h" | |
| 44 #include "ui/gfx/skbitmap_operations.h" | |
| 45 | |
| 46 using content::WebContents; | |
| 47 | |
| 48 namespace { | |
| 49 | |
| 50 const int kFontPixelSize = 12; | |
| 51 const int kLeftPadding = 16; | |
| 52 const int kTopPadding = 6; | |
| 53 const int kRightPadding = 15; | |
| 54 const int kBottomPadding = 5; | |
| 55 const int kFaviconTitleSpacing = 4; | |
| 56 const int kTitleCloseButtonSpacing = 5; | |
| 57 const int kStandardTitleWidth = 175; | |
| 58 const int kDropShadowOffset = 2; | |
| 59 const int kInactiveTabBackgroundOffsetY = 15; | |
| 60 | |
| 61 // When a non-mini-tab becomes a mini-tab the width of the tab animates. If | |
| 62 // the width of a mini-tab is >= kMiniTabRendererAsNormalTabWidth then the tab | |
| 63 // is rendered as a normal tab. This is done to avoid having the title | |
| 64 // immediately disappear when transitioning a tab from normal to mini-tab. | |
| 65 const int kMiniTabRendererAsNormalTabWidth = | |
| 66 browser_defaults::kMiniTabWidth + 30; | |
| 67 | |
| 68 // The tab images are designed to overlap the toolbar by 1 pixel. For now we | |
| 69 // don't actually overlap the toolbar, so this is used to know how many pixels | |
| 70 // at the bottom of the tab images are to be ignored. | |
| 71 const int kToolbarOverlap = 1; | |
| 72 | |
| 73 // How long the hover state takes. | |
| 74 const int kHoverDurationMs = 90; | |
| 75 | |
| 76 // How opaque to make the hover state (out of 1). | |
| 77 const double kHoverOpacity = 0.33; | |
| 78 | |
| 79 // Opacity for non-active selected tabs. | |
| 80 const double kSelectedTabOpacity = 0.45; | |
| 81 | |
| 82 // Selected (but not active) tabs have their throb value scaled down by this. | |
| 83 const double kSelectedTabThrobScale = 0.5; | |
| 84 | |
| 85 // Max opacity for the mini-tab title change animation. | |
| 86 const double kMiniTitleChangeThrobOpacity = 0.75; | |
| 87 | |
| 88 // Duration for when the title of an inactive mini-tab changes. | |
| 89 const int kMiniTitleChangeThrobDuration = 1000; | |
| 90 | |
| 91 // The horizontal offset used to position the close button in the tab. | |
| 92 const int kCloseButtonHorzFuzz = 4; | |
| 93 | |
| 94 // Gets the bounds of |widget| relative to |parent|. | |
| 95 gfx::Rect GetWidgetBoundsRelativeToParent(GtkWidget* parent, | |
| 96 GtkWidget* widget) { | |
| 97 gfx::Rect bounds = ui::GetWidgetScreenBounds(widget); | |
| 98 bounds.Offset(-ui::GetWidgetScreenOffset(parent)); | |
| 99 return bounds; | |
| 100 } | |
| 101 | |
| 102 // Returns a GdkPixbuf after resizing the SkBitmap as necessary to the | |
| 103 // specified desired width and height. Caller must g_object_unref the returned | |
| 104 // pixbuf when no longer used. | |
| 105 GdkPixbuf* GetResizedGdkPixbufFromSkBitmap(const SkBitmap& bitmap, | |
| 106 int dest_w, | |
| 107 int dest_h) { | |
| 108 float float_dest_w = static_cast<float>(dest_w); | |
| 109 float float_dest_h = static_cast<float>(dest_h); | |
| 110 int bitmap_w = bitmap.width(); | |
| 111 int bitmap_h = bitmap.height(); | |
| 112 | |
| 113 // Scale proportionately. | |
| 114 float scale = std::min(float_dest_w / bitmap_w, | |
| 115 float_dest_h / bitmap_h); | |
| 116 int final_dest_w = static_cast<int>(bitmap_w * scale); | |
| 117 int final_dest_h = static_cast<int>(bitmap_h * scale); | |
| 118 | |
| 119 GdkPixbuf* pixbuf; | |
| 120 if (final_dest_w == bitmap_w && final_dest_h == bitmap_h) { | |
| 121 pixbuf = gfx::GdkPixbufFromSkBitmap(bitmap); | |
| 122 } else { | |
| 123 SkBitmap resized_icon = skia::ImageOperations::Resize( | |
| 124 bitmap, | |
| 125 skia::ImageOperations::RESIZE_BETTER, | |
| 126 final_dest_w, final_dest_h); | |
| 127 pixbuf = gfx::GdkPixbufFromSkBitmap(resized_icon); | |
| 128 } | |
| 129 return pixbuf; | |
| 130 } | |
| 131 | |
| 132 } // namespace | |
| 133 | |
| 134 TabRendererGtk::LoadingAnimation::Data::Data( | |
| 135 GtkThemeService* theme_service) { | |
| 136 // The loading animation image is a strip of states. Each state must be | |
| 137 // square, so the height must divide the width evenly. | |
| 138 SkBitmap loading_animation_frames = | |
| 139 theme_service->GetImageNamed(IDR_THROBBER).AsBitmap(); | |
| 140 DCHECK(!loading_animation_frames.isNull()); | |
| 141 DCHECK_EQ(loading_animation_frames.width() % | |
| 142 loading_animation_frames.height(), 0); | |
| 143 loading_animation_frame_count = | |
| 144 loading_animation_frames.width() / | |
| 145 loading_animation_frames.height(); | |
| 146 | |
| 147 SkBitmap waiting_animation_frames = | |
| 148 theme_service->GetImageNamed(IDR_THROBBER_WAITING).AsBitmap(); | |
| 149 DCHECK(!waiting_animation_frames.isNull()); | |
| 150 DCHECK_EQ(waiting_animation_frames.width() % | |
| 151 waiting_animation_frames.height(), 0); | |
| 152 waiting_animation_frame_count = | |
| 153 waiting_animation_frames.width() / | |
| 154 waiting_animation_frames.height(); | |
| 155 | |
| 156 waiting_to_loading_frame_count_ratio = | |
| 157 waiting_animation_frame_count / | |
| 158 loading_animation_frame_count; | |
| 159 // TODO(beng): eventually remove this when we have a proper themeing system. | |
| 160 // themes not supporting IDR_THROBBER_WAITING are causing this | |
| 161 // value to be 0 which causes DIV0 crashes. The value of 5 | |
| 162 // matches the current bitmaps in our source. | |
| 163 if (waiting_to_loading_frame_count_ratio == 0) | |
| 164 waiting_to_loading_frame_count_ratio = 5; | |
| 165 } | |
| 166 | |
| 167 TabRendererGtk::LoadingAnimation::Data::Data( | |
| 168 int loading, int waiting, int waiting_to_loading) | |
| 169 : loading_animation_frame_count(loading), | |
| 170 waiting_animation_frame_count(waiting), | |
| 171 waiting_to_loading_frame_count_ratio(waiting_to_loading) { | |
| 172 } | |
| 173 | |
| 174 bool TabRendererGtk::initialized_ = false; | |
| 175 int TabRendererGtk::tab_active_l_width_ = 0; | |
| 176 int TabRendererGtk::tab_active_l_height_ = 0; | |
| 177 int TabRendererGtk::tab_inactive_l_height_ = 0; | |
| 178 gfx::Font* TabRendererGtk::title_font_ = NULL; | |
| 179 int TabRendererGtk::title_font_height_ = 0; | |
| 180 int TabRendererGtk::close_button_width_ = 0; | |
| 181 int TabRendererGtk::close_button_height_ = 0; | |
| 182 | |
| 183 //////////////////////////////////////////////////////////////////////////////// | |
| 184 // TabRendererGtk::LoadingAnimation, public: | |
| 185 // | |
| 186 TabRendererGtk::LoadingAnimation::LoadingAnimation( | |
| 187 GtkThemeService* theme_service) | |
| 188 : data_(new Data(theme_service)), | |
| 189 theme_service_(theme_service), | |
| 190 animation_state_(ANIMATION_NONE), | |
| 191 animation_frame_(0) { | |
| 192 registrar_.Add(this, | |
| 193 chrome::NOTIFICATION_BROWSER_THEME_CHANGED, | |
| 194 content::Source<ThemeService>(theme_service_)); | |
| 195 } | |
| 196 | |
| 197 TabRendererGtk::LoadingAnimation::LoadingAnimation( | |
| 198 const LoadingAnimation::Data& data) | |
| 199 : data_(new Data(data)), | |
| 200 theme_service_(NULL), | |
| 201 animation_state_(ANIMATION_NONE), | |
| 202 animation_frame_(0) { | |
| 203 } | |
| 204 | |
| 205 TabRendererGtk::LoadingAnimation::~LoadingAnimation() {} | |
| 206 | |
| 207 bool TabRendererGtk::LoadingAnimation::ValidateLoadingAnimation( | |
| 208 AnimationState animation_state) { | |
| 209 bool has_changed = false; | |
| 210 if (animation_state_ != animation_state) { | |
| 211 // The waiting animation is the reverse of the loading animation, but at a | |
| 212 // different rate - the following reverses and scales the animation_frame_ | |
| 213 // so that the frame is at an equivalent position when going from one | |
| 214 // animation to the other. | |
| 215 if (animation_state_ == ANIMATION_WAITING && | |
| 216 animation_state == ANIMATION_LOADING) { | |
| 217 animation_frame_ = data_->loading_animation_frame_count - | |
| 218 (animation_frame_ / data_->waiting_to_loading_frame_count_ratio); | |
| 219 } | |
| 220 animation_state_ = animation_state; | |
| 221 has_changed = true; | |
| 222 } | |
| 223 | |
| 224 if (animation_state_ != ANIMATION_NONE) { | |
| 225 animation_frame_ = (animation_frame_ + 1) % | |
| 226 ((animation_state_ == ANIMATION_WAITING) ? | |
| 227 data_->waiting_animation_frame_count : | |
| 228 data_->loading_animation_frame_count); | |
| 229 has_changed = true; | |
| 230 } else { | |
| 231 animation_frame_ = 0; | |
| 232 } | |
| 233 return has_changed; | |
| 234 } | |
| 235 | |
| 236 void TabRendererGtk::LoadingAnimation::Observe( | |
| 237 int type, | |
| 238 const content::NotificationSource& source, | |
| 239 const content::NotificationDetails& details) { | |
| 240 DCHECK(type == chrome::NOTIFICATION_BROWSER_THEME_CHANGED); | |
| 241 data_.reset(new Data(theme_service_)); | |
| 242 } | |
| 243 | |
| 244 TabRendererGtk::TabData::TabData() | |
| 245 : is_default_favicon(false), | |
| 246 loading(false), | |
| 247 crashed(false), | |
| 248 incognito(false), | |
| 249 show_icon(true), | |
| 250 mini(false), | |
| 251 blocked(false), | |
| 252 animating_mini_change(false), | |
| 253 app(false), | |
| 254 media_state(TAB_MEDIA_STATE_NONE), | |
| 255 previous_media_state(TAB_MEDIA_STATE_NONE) { | |
| 256 } | |
| 257 | |
| 258 TabRendererGtk::TabData::~TabData() {} | |
| 259 | |
| 260 //////////////////////////////////////////////////////////////////////////////// | |
| 261 // FaviconCrashAnimation | |
| 262 // | |
| 263 // A custom animation subclass to manage the favicon crash animation. | |
| 264 class TabRendererGtk::FaviconCrashAnimation : public gfx::LinearAnimation, | |
| 265 public gfx::AnimationDelegate { | |
| 266 public: | |
| 267 explicit FaviconCrashAnimation(TabRendererGtk* target) | |
| 268 : gfx::LinearAnimation(1000, 25, this), | |
| 269 target_(target) { | |
| 270 } | |
| 271 virtual ~FaviconCrashAnimation() {} | |
| 272 | |
| 273 // gfx::Animation overrides: | |
| 274 virtual void AnimateToState(double state) OVERRIDE { | |
| 275 const double kHidingOffset = 27; | |
| 276 | |
| 277 if (state < .5) { | |
| 278 target_->SetFaviconHidingOffset( | |
| 279 static_cast<int>(floor(kHidingOffset * 2.0 * state))); | |
| 280 } else { | |
| 281 target_->DisplayCrashedFavicon(); | |
| 282 target_->SetFaviconHidingOffset( | |
| 283 static_cast<int>( | |
| 284 floor(kHidingOffset - ((state - .5) * 2.0 * kHidingOffset)))); | |
| 285 } | |
| 286 } | |
| 287 | |
| 288 // gfx::AnimationDelegate overrides: | |
| 289 virtual void AnimationCanceled(const gfx::Animation* animation) OVERRIDE { | |
| 290 target_->SetFaviconHidingOffset(0); | |
| 291 } | |
| 292 | |
| 293 private: | |
| 294 TabRendererGtk* target_; | |
| 295 | |
| 296 DISALLOW_COPY_AND_ASSIGN(FaviconCrashAnimation); | |
| 297 }; | |
| 298 | |
| 299 //////////////////////////////////////////////////////////////////////////////// | |
| 300 // TabRendererGtk, public: | |
| 301 | |
| 302 TabRendererGtk::TabRendererGtk(GtkThemeService* theme_service) | |
| 303 : showing_icon_(false), | |
| 304 showing_media_indicator_(false), | |
| 305 showing_close_button_(false), | |
| 306 favicon_hiding_offset_(0), | |
| 307 should_display_crashed_favicon_(false), | |
| 308 animating_media_state_(TAB_MEDIA_STATE_NONE), | |
| 309 loading_animation_(theme_service), | |
| 310 background_offset_x_(0), | |
| 311 background_offset_y_(kInactiveTabBackgroundOffsetY), | |
| 312 theme_service_(theme_service), | |
| 313 close_button_color_(0), | |
| 314 is_active_(false), | |
| 315 selected_title_color_(SK_ColorBLACK), | |
| 316 unselected_title_color_(SkColorSetRGB(64, 64, 64)) { | |
| 317 InitResources(); | |
| 318 | |
| 319 theme_service_->InitThemesFor(this); | |
| 320 registrar_.Add(this, chrome::NOTIFICATION_BROWSER_THEME_CHANGED, | |
| 321 content::Source<ThemeService>(theme_service_)); | |
| 322 | |
| 323 tab_.Own(gtk_fixed_new()); | |
| 324 gtk_widget_set_app_paintable(tab_.get(), TRUE); | |
| 325 g_signal_connect(tab_.get(), "expose-event", | |
| 326 G_CALLBACK(OnExposeEventThunk), this); | |
| 327 g_signal_connect(tab_.get(), "size-allocate", | |
| 328 G_CALLBACK(OnSizeAllocateThunk), this); | |
| 329 close_button_.reset(MakeCloseButton()); | |
| 330 gtk_widget_show(tab_.get()); | |
| 331 | |
| 332 hover_animation_.reset(new gfx::SlideAnimation(this)); | |
| 333 hover_animation_->SetSlideDuration(kHoverDurationMs); | |
| 334 } | |
| 335 | |
| 336 TabRendererGtk::~TabRendererGtk() { | |
| 337 tab_.Destroy(); | |
| 338 } | |
| 339 | |
| 340 void TabRendererGtk::Observe(int type, | |
| 341 const content::NotificationSource& source, | |
| 342 const content::NotificationDetails& details) { | |
| 343 DCHECK(chrome::NOTIFICATION_BROWSER_THEME_CHANGED); | |
| 344 selected_title_color_ = | |
| 345 theme_service_->GetColor(ThemeProperties::COLOR_TAB_TEXT); | |
| 346 unselected_title_color_ = | |
| 347 theme_service_->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB_TEXT); | |
| 348 } | |
| 349 | |
| 350 void TabRendererGtk::UpdateData(WebContents* contents, | |
| 351 bool app, | |
| 352 bool loading_only) { | |
| 353 DCHECK(contents); | |
| 354 FaviconTabHelper* favicon_tab_helper = | |
| 355 FaviconTabHelper::FromWebContents(contents); | |
| 356 | |
| 357 if (!loading_only) { | |
| 358 data_.title = contents->GetTitle(); | |
| 359 data_.incognito = contents->GetBrowserContext()->IsOffTheRecord(); | |
| 360 | |
| 361 TabMediaState next_media_state; | |
| 362 if (contents->IsCrashed()) { | |
| 363 data_.crashed = true; | |
| 364 next_media_state = TAB_MEDIA_STATE_NONE; | |
| 365 } else { | |
| 366 data_.crashed = false; | |
| 367 next_media_state = chrome::GetTabMediaStateForContents(contents); | |
| 368 } | |
| 369 if (data_.media_state != next_media_state) { | |
| 370 data_.previous_media_state = data_.media_state; | |
| 371 data_.media_state = next_media_state; | |
| 372 } | |
| 373 | |
| 374 data_.favicon = favicon_tab_helper->GetFavicon().AsBitmap(); | |
| 375 data_.app = app; | |
| 376 | |
| 377 // Make a cairo cached version of the favicon. | |
| 378 if (!data_.favicon.isNull()) { | |
| 379 // Instead of resizing the icon during each frame, create our resized | |
| 380 // icon resource now, send it to the xserver and use that each frame | |
| 381 // instead. | |
| 382 | |
| 383 // For source images smaller than the favicon square, scale them as if | |
| 384 // they were padded to fit the favicon square, so we don't blow up tiny | |
| 385 // favicons into larger or nonproportional results. | |
| 386 GdkPixbuf* pixbuf = GetResizedGdkPixbufFromSkBitmap(data_.favicon, | |
| 387 gfx::kFaviconSize, gfx::kFaviconSize); | |
| 388 data_.cairo_favicon.UsePixbuf(pixbuf); | |
| 389 g_object_unref(pixbuf); | |
| 390 } else { | |
| 391 data_.cairo_favicon.Reset(); | |
| 392 } | |
| 393 | |
| 394 // This is kind of a hacky way to determine whether our icon is the default | |
| 395 // favicon. But the plumbing that would be necessary to do it right would | |
| 396 // be a good bit of work and would sully code for other platforms which | |
| 397 // don't care to custom-theme the favicon. Hopefully the default favicon | |
| 398 // will eventually be chromium-themable and this code will go away. | |
| 399 data_.is_default_favicon = | |
| 400 (data_.favicon.pixelRef() == | |
| 401 ui::ResourceBundle::GetSharedInstance().GetImageNamed( | |
| 402 IDR_DEFAULT_FAVICON).AsBitmap().pixelRef()); | |
| 403 } | |
| 404 | |
| 405 // Loading state also involves whether we show the favicon, since that's where | |
| 406 // we display the throbber. | |
| 407 data_.loading = contents->IsLoading(); | |
| 408 data_.show_icon = favicon_tab_helper->ShouldDisplayFavicon(); | |
| 409 } | |
| 410 | |
| 411 void TabRendererGtk::UpdateFromModel() { | |
| 412 // Force a layout, since the tab may have grown a favicon. | |
| 413 Layout(); | |
| 414 SchedulePaint(); | |
| 415 | |
| 416 if (data_.crashed) { | |
| 417 if (!should_display_crashed_favicon_ && !IsPerformingCrashAnimation()) | |
| 418 StartCrashAnimation(); | |
| 419 } else { | |
| 420 if (IsPerformingCrashAnimation()) | |
| 421 StopCrashAnimation(); | |
| 422 ResetCrashedFavicon(); | |
| 423 } | |
| 424 | |
| 425 if (data_.media_state != data_.previous_media_state) { | |
| 426 data_.previous_media_state = data_.media_state; | |
| 427 if (data_.media_state != TAB_MEDIA_STATE_NONE) | |
| 428 animating_media_state_ = data_.media_state; | |
| 429 StartMediaIndicatorAnimation(); | |
| 430 } | |
| 431 } | |
| 432 | |
| 433 void TabRendererGtk::SetBlocked(bool blocked) { | |
| 434 if (data_.blocked == blocked) | |
| 435 return; | |
| 436 data_.blocked = blocked; | |
| 437 // TODO(zelidrag) bug 32399: Make tabs pulse on Linux as well. | |
| 438 } | |
| 439 | |
| 440 bool TabRendererGtk::is_blocked() const { | |
| 441 return data_.blocked; | |
| 442 } | |
| 443 | |
| 444 bool TabRendererGtk::IsActive() const { | |
| 445 return is_active_; | |
| 446 } | |
| 447 | |
| 448 bool TabRendererGtk::IsSelected() const { | |
| 449 return true; | |
| 450 } | |
| 451 | |
| 452 bool TabRendererGtk::IsVisible() const { | |
| 453 return gtk_widget_get_visible(tab_.get()); | |
| 454 } | |
| 455 | |
| 456 void TabRendererGtk::SetVisible(bool visible) const { | |
| 457 if (visible) { | |
| 458 gtk_widget_show(tab_.get()); | |
| 459 if (data_.mini) | |
| 460 gtk_widget_show(close_button_->widget()); | |
| 461 } else { | |
| 462 gtk_widget_hide_all(tab_.get()); | |
| 463 } | |
| 464 } | |
| 465 | |
| 466 bool TabRendererGtk::ValidateLoadingAnimation(AnimationState animation_state) { | |
| 467 return loading_animation_.ValidateLoadingAnimation(animation_state); | |
| 468 } | |
| 469 | |
| 470 void TabRendererGtk::PaintFaviconArea(GtkWidget* widget, cairo_t* cr) { | |
| 471 DCHECK(ShouldShowIcon()); | |
| 472 | |
| 473 cairo_rectangle(cr, | |
| 474 x() + favicon_bounds_.x(), | |
| 475 y() + favicon_bounds_.y(), | |
| 476 favicon_bounds_.width(), | |
| 477 favicon_bounds_.height()); | |
| 478 cairo_clip(cr); | |
| 479 | |
| 480 // The tab is rendered into a windowless widget whose offset is at the | |
| 481 // coordinate event->area. Translate by these offsets so we can render at | |
| 482 // (0,0) to match Windows' rendering metrics. | |
| 483 cairo_matrix_t cairo_matrix; | |
| 484 cairo_matrix_init_translate(&cairo_matrix, x(), y()); | |
| 485 cairo_set_matrix(cr, &cairo_matrix); | |
| 486 | |
| 487 // Which background should we be painting? | |
| 488 int theme_id; | |
| 489 int offset_y = 0; | |
| 490 if (IsActive()) { | |
| 491 theme_id = IDR_THEME_TOOLBAR; | |
| 492 } else { | |
| 493 theme_id = data_.incognito ? IDR_THEME_TAB_BACKGROUND_INCOGNITO : | |
| 494 IDR_THEME_TAB_BACKGROUND; | |
| 495 | |
| 496 if (!theme_service_->HasCustomImage(theme_id)) | |
| 497 offset_y = background_offset_y_; | |
| 498 } | |
| 499 | |
| 500 // Paint the background behind the favicon. | |
| 501 const gfx::Image tab_bg = theme_service_->GetImageNamed(theme_id); | |
| 502 tab_bg.ToCairo()->SetSource(cr, widget, -x(), -offset_y); | |
| 503 cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REPEAT); | |
| 504 cairo_rectangle(cr, | |
| 505 favicon_bounds_.x(), favicon_bounds_.y(), | |
| 506 favicon_bounds_.width(), favicon_bounds_.height()); | |
| 507 cairo_fill(cr); | |
| 508 | |
| 509 if (!IsActive()) { | |
| 510 double throb_value = GetThrobValue(); | |
| 511 if (throb_value > 0) { | |
| 512 cairo_push_group(cr); | |
| 513 gfx::Image active_bg = | |
| 514 theme_service_->GetImageNamed(IDR_THEME_TOOLBAR); | |
| 515 active_bg.ToCairo()->SetSource(cr, widget, -x(), 0); | |
| 516 cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REPEAT); | |
| 517 | |
| 518 cairo_rectangle(cr, | |
| 519 favicon_bounds_.x(), favicon_bounds_.y(), | |
| 520 favicon_bounds_.width(), favicon_bounds_.height()); | |
| 521 cairo_fill(cr); | |
| 522 | |
| 523 cairo_pop_group_to_source(cr); | |
| 524 cairo_paint_with_alpha(cr, throb_value); | |
| 525 } | |
| 526 } | |
| 527 | |
| 528 PaintIcon(widget, cr); | |
| 529 } | |
| 530 | |
| 531 void TabRendererGtk::MaybeAdjustLeftForMiniTab(gfx::Rect* icon_bounds) const { | |
| 532 if (!(mini() || data_.animating_mini_change) || | |
| 533 bounds_.width() >= kMiniTabRendererAsNormalTabWidth) | |
| 534 return; | |
| 535 const int mini_delta = kMiniTabRendererAsNormalTabWidth - GetMiniWidth(); | |
| 536 const int ideal_delta = bounds_.width() - GetMiniWidth(); | |
| 537 const int ideal_x = (GetMiniWidth() - icon_bounds->width()) / 2; | |
| 538 icon_bounds->set_x(icon_bounds->x() + static_cast<int>( | |
| 539 (1 - static_cast<float>(ideal_delta) / static_cast<float>(mini_delta)) * | |
| 540 (ideal_x - icon_bounds->x()))); | |
| 541 } | |
| 542 | |
| 543 // static | |
| 544 gfx::Size TabRendererGtk::GetMinimumUnselectedSize() { | |
| 545 InitResources(); | |
| 546 | |
| 547 gfx::Size minimum_size; | |
| 548 minimum_size.set_width(kLeftPadding + kRightPadding); | |
| 549 // Since we use bitmap images, the real minimum height of the image is | |
| 550 // defined most accurately by the height of the end cap images. | |
| 551 minimum_size.set_height(tab_active_l_height_ - kToolbarOverlap); | |
| 552 return minimum_size; | |
| 553 } | |
| 554 | |
| 555 // static | |
| 556 gfx::Size TabRendererGtk::GetMinimumSelectedSize() { | |
| 557 gfx::Size minimum_size = GetMinimumUnselectedSize(); | |
| 558 minimum_size.set_width(kLeftPadding + gfx::kFaviconSize + kRightPadding); | |
| 559 return minimum_size; | |
| 560 } | |
| 561 | |
| 562 // static | |
| 563 gfx::Size TabRendererGtk::GetStandardSize() { | |
| 564 gfx::Size standard_size = GetMinimumUnselectedSize(); | |
| 565 standard_size.Enlarge(kFaviconTitleSpacing + kStandardTitleWidth, 0); | |
| 566 return standard_size; | |
| 567 } | |
| 568 | |
| 569 // static | |
| 570 int TabRendererGtk::GetMiniWidth() { | |
| 571 return browser_defaults::kMiniTabWidth; | |
| 572 } | |
| 573 | |
| 574 // static | |
| 575 int TabRendererGtk::GetContentHeight() { | |
| 576 // The height of the content of the Tab is the largest of the favicon, | |
| 577 // the title text and the close button graphic. | |
| 578 int content_height = std::max(gfx::kFaviconSize, title_font_height_); | |
| 579 return std::max(content_height, close_button_height_); | |
| 580 } | |
| 581 | |
| 582 gfx::Rect TabRendererGtk::GetNonMirroredBounds(GtkWidget* parent) const { | |
| 583 // The tabstrip widget is a windowless widget so the tab widget's allocation | |
| 584 // is relative to the browser titlebar. We need the bounds relative to the | |
| 585 // tabstrip. | |
| 586 gfx::Rect bounds = GetWidgetBoundsRelativeToParent(parent, widget()); | |
| 587 bounds.set_x(gtk_util::MirroredLeftPointForRect(parent, bounds)); | |
| 588 return bounds; | |
| 589 } | |
| 590 | |
| 591 gfx::Rect TabRendererGtk::GetRequisition() const { | |
| 592 return gfx::Rect(requisition_.x(), requisition_.y(), | |
| 593 requisition_.width(), requisition_.height()); | |
| 594 } | |
| 595 | |
| 596 void TabRendererGtk::StartMiniTabTitleAnimation() { | |
| 597 if (!mini_title_animation_.get()) { | |
| 598 mini_title_animation_.reset(new gfx::ThrobAnimation(this)); | |
| 599 mini_title_animation_->SetThrobDuration(kMiniTitleChangeThrobDuration); | |
| 600 } | |
| 601 | |
| 602 if (!mini_title_animation_->is_animating()) | |
| 603 mini_title_animation_->StartThrobbing(-1); | |
| 604 } | |
| 605 | |
| 606 void TabRendererGtk::StopMiniTabTitleAnimation() { | |
| 607 if (mini_title_animation_.get()) | |
| 608 mini_title_animation_->Stop(); | |
| 609 } | |
| 610 | |
| 611 void TabRendererGtk::SetBounds(const gfx::Rect& bounds) { | |
| 612 requisition_ = bounds; | |
| 613 gtk_widget_set_size_request(tab_.get(), bounds.width(), bounds.height()); | |
| 614 } | |
| 615 | |
| 616 //////////////////////////////////////////////////////////////////////////////// | |
| 617 // TabRendererGtk, protected: | |
| 618 | |
| 619 void TabRendererGtk::Raise() const { | |
| 620 if (gtk_button_get_event_window(GTK_BUTTON(close_button_->widget()))) | |
| 621 gdk_window_raise(gtk_button_get_event_window( | |
| 622 GTK_BUTTON(close_button_->widget()))); | |
| 623 } | |
| 624 | |
| 625 base::string16 TabRendererGtk::GetTitle() const { | |
| 626 return data_.title; | |
| 627 } | |
| 628 | |
| 629 /////////////////////////////////////////////////////////////////////////////// | |
| 630 // TabRendererGtk, gfx::AnimationDelegate implementation: | |
| 631 | |
| 632 void TabRendererGtk::AnimationProgressed(const gfx::Animation* animation) { | |
| 633 gtk_widget_queue_draw(tab_.get()); | |
| 634 } | |
| 635 | |
| 636 void TabRendererGtk::AnimationCanceled(const gfx::Animation* animation) { | |
| 637 if (media_indicator_animation_ == animation) | |
| 638 animating_media_state_ = data_.media_state; | |
| 639 AnimationEnded(animation); | |
| 640 } | |
| 641 | |
| 642 void TabRendererGtk::AnimationEnded(const gfx::Animation* animation) { | |
| 643 if (media_indicator_animation_ == animation) | |
| 644 animating_media_state_ = data_.media_state; | |
| 645 gtk_widget_queue_draw(tab_.get()); | |
| 646 } | |
| 647 | |
| 648 //////////////////////////////////////////////////////////////////////////////// | |
| 649 // TabRendererGtk, private: | |
| 650 | |
| 651 void TabRendererGtk::StartCrashAnimation() { | |
| 652 if (!crash_animation_.get()) | |
| 653 crash_animation_.reset(new FaviconCrashAnimation(this)); | |
| 654 crash_animation_->Stop(); | |
| 655 crash_animation_->Start(); | |
| 656 } | |
| 657 | |
| 658 void TabRendererGtk::StopCrashAnimation() { | |
| 659 if (!crash_animation_.get()) | |
| 660 return; | |
| 661 crash_animation_->Stop(); | |
| 662 } | |
| 663 | |
| 664 bool TabRendererGtk::IsPerformingCrashAnimation() const { | |
| 665 return crash_animation_.get() && crash_animation_->is_animating(); | |
| 666 } | |
| 667 | |
| 668 void TabRendererGtk::StartMediaIndicatorAnimation() { | |
| 669 media_indicator_animation_ = | |
| 670 chrome::CreateTabMediaIndicatorFadeAnimation(data_.media_state); | |
| 671 media_indicator_animation_->set_delegate(this); | |
| 672 media_indicator_animation_->Start(); | |
| 673 } | |
| 674 | |
| 675 void TabRendererGtk::SetFaviconHidingOffset(int offset) { | |
| 676 favicon_hiding_offset_ = offset; | |
| 677 SchedulePaint(); | |
| 678 } | |
| 679 | |
| 680 void TabRendererGtk::DisplayCrashedFavicon() { | |
| 681 should_display_crashed_favicon_ = true; | |
| 682 } | |
| 683 | |
| 684 void TabRendererGtk::ResetCrashedFavicon() { | |
| 685 should_display_crashed_favicon_ = false; | |
| 686 } | |
| 687 | |
| 688 void TabRendererGtk::Paint(GtkWidget* widget, cairo_t* cr) { | |
| 689 // Don't paint if we're narrower than we can render correctly. (This should | |
| 690 // only happen during animations). | |
| 691 if (width() < GetMinimumUnselectedSize().width() && !mini()) | |
| 692 return; | |
| 693 | |
| 694 // See if the model changes whether the icons should be painted. | |
| 695 const bool show_icon = ShouldShowIcon(); | |
| 696 const bool show_media_indicator = ShouldShowMediaIndicator(); | |
| 697 const bool show_close_button = ShouldShowCloseBox(); | |
| 698 if (show_icon != showing_icon_ || | |
| 699 show_media_indicator != showing_media_indicator_ || | |
| 700 show_close_button != showing_close_button_) | |
| 701 Layout(); | |
| 702 | |
| 703 PaintTabBackground(widget, cr); | |
| 704 | |
| 705 if (!mini() || width() > kMiniTabRendererAsNormalTabWidth) | |
| 706 PaintTitle(widget, cr); | |
| 707 | |
| 708 if (show_icon) | |
| 709 PaintIcon(widget, cr); | |
| 710 | |
| 711 if (show_media_indicator) | |
| 712 PaintMediaIndicator(widget, cr); | |
| 713 } | |
| 714 | |
| 715 cairo_surface_t* TabRendererGtk::PaintToSurface(GtkWidget* widget, | |
| 716 cairo_t* cr) { | |
| 717 cairo_surface_t* target = cairo_get_target(cr); | |
| 718 cairo_surface_t* out_surface = cairo_surface_create_similar( | |
| 719 target, | |
| 720 CAIRO_CONTENT_COLOR_ALPHA, | |
| 721 width(), height()); | |
| 722 | |
| 723 cairo_t* out_cr = cairo_create(out_surface); | |
| 724 Paint(widget, out_cr); | |
| 725 cairo_destroy(out_cr); | |
| 726 | |
| 727 return out_surface; | |
| 728 } | |
| 729 | |
| 730 void TabRendererGtk::SchedulePaint() { | |
| 731 gtk_widget_queue_draw(tab_.get()); | |
| 732 } | |
| 733 | |
| 734 gfx::Rect TabRendererGtk::GetLocalBounds() { | |
| 735 return gfx::Rect(0, 0, bounds_.width(), bounds_.height()); | |
| 736 } | |
| 737 | |
| 738 void TabRendererGtk::Layout() { | |
| 739 gfx::Rect local_bounds = GetLocalBounds(); | |
| 740 if (local_bounds.IsEmpty()) | |
| 741 return; | |
| 742 local_bounds.Inset(kLeftPadding, kTopPadding, kRightPadding, kBottomPadding); | |
| 743 | |
| 744 // Figure out who is tallest. | |
| 745 int content_height = GetContentHeight(); | |
| 746 | |
| 747 // Size the Favicon. | |
| 748 showing_icon_ = ShouldShowIcon(); | |
| 749 if (showing_icon_) { | |
| 750 int favicon_top = kTopPadding + (content_height - gfx::kFaviconSize) / 2; | |
| 751 favicon_bounds_.SetRect(local_bounds.x(), favicon_top, | |
| 752 gfx::kFaviconSize, gfx::kFaviconSize); | |
| 753 MaybeAdjustLeftForMiniTab(&favicon_bounds_); | |
| 754 } else { | |
| 755 favicon_bounds_.SetRect(local_bounds.x(), local_bounds.y(), 0, 0); | |
| 756 } | |
| 757 | |
| 758 // Size the Close button. | |
| 759 showing_close_button_ = ShouldShowCloseBox(); | |
| 760 if (showing_close_button_) { | |
| 761 int close_button_top = kTopPadding + | |
| 762 (content_height - close_button_height_) / 2; | |
| 763 int close_button_left = | |
| 764 local_bounds.right() - close_button_width_ + kCloseButtonHorzFuzz; | |
| 765 close_button_bounds_.SetRect(close_button_left, | |
| 766 close_button_top, | |
| 767 close_button_width_, | |
| 768 close_button_height_); | |
| 769 | |
| 770 // If the close button color has changed, generate a new one. | |
| 771 if (theme_service_) { | |
| 772 SkColor tab_text_color = | |
| 773 theme_service_->GetColor(ThemeProperties::COLOR_TAB_TEXT); | |
| 774 if (!close_button_color_ || tab_text_color != close_button_color_) { | |
| 775 close_button_color_ = tab_text_color; | |
| 776 ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance(); | |
| 777 close_button_->SetBackground(close_button_color_, | |
| 778 rb.GetImageNamed(IDR_CLOSE_1).AsBitmap(), | |
| 779 rb.GetImageNamed(IDR_CLOSE_1_MASK).AsBitmap()); | |
| 780 } | |
| 781 } | |
| 782 } else { | |
| 783 close_button_bounds_.SetRect(0, 0, 0, 0); | |
| 784 } | |
| 785 | |
| 786 showing_media_indicator_ = ShouldShowMediaIndicator(); | |
| 787 if (showing_media_indicator_) { | |
| 788 const gfx::Image& media_indicator_image = | |
| 789 chrome::GetTabMediaIndicatorImage(animating_media_state_); | |
| 790 media_indicator_bounds_.set_width(media_indicator_image.Width()); | |
| 791 media_indicator_bounds_.set_height(media_indicator_image.Height()); | |
| 792 media_indicator_bounds_.set_y( | |
| 793 kTopPadding + (content_height - media_indicator_bounds_.height()) / 2); | |
| 794 const int right = showing_close_button_ ? | |
| 795 close_button_bounds_.x() : local_bounds.right(); | |
| 796 media_indicator_bounds_.set_x(std::max( | |
| 797 local_bounds.x(), right - media_indicator_bounds_.width())); | |
| 798 MaybeAdjustLeftForMiniTab(&media_indicator_bounds_); | |
| 799 } else { | |
| 800 media_indicator_bounds_.SetRect(local_bounds.x(), local_bounds.y(), 0, 0); | |
| 801 } | |
| 802 | |
| 803 if (!mini() || width() >= kMiniTabRendererAsNormalTabWidth) { | |
| 804 // Size the Title text to fill the remaining space. | |
| 805 int title_left = favicon_bounds_.right() + kFaviconTitleSpacing; | |
| 806 int title_top = kTopPadding; | |
| 807 | |
| 808 // If the user has big fonts, the title will appear rendered too far down | |
| 809 // on the y-axis if we use the regular top padding, so we need to adjust it | |
| 810 // so that the text appears centered. | |
| 811 gfx::Size minimum_size = GetMinimumUnselectedSize(); | |
| 812 int text_height = title_top + title_font_height_ + kBottomPadding; | |
| 813 if (text_height > minimum_size.height()) | |
| 814 title_top -= (text_height - minimum_size.height()) / 2; | |
| 815 | |
| 816 int title_width; | |
| 817 if (showing_media_indicator_) { | |
| 818 title_width = media_indicator_bounds_.x() - kTitleCloseButtonSpacing - | |
| 819 title_left; | |
| 820 } else if (close_button_bounds_.width() && close_button_bounds_.height()) { | |
| 821 title_width = close_button_bounds_.x() - kTitleCloseButtonSpacing - | |
| 822 title_left; | |
| 823 } else { | |
| 824 title_width = local_bounds.width() - title_left; | |
| 825 } | |
| 826 title_width = std::max(title_width, 0); | |
| 827 title_bounds_.SetRect(title_left, title_top, title_width, content_height); | |
| 828 } | |
| 829 | |
| 830 favicon_bounds_.set_x( | |
| 831 gtk_util::MirroredLeftPointForRect(tab_.get(), favicon_bounds_)); | |
| 832 media_indicator_bounds_.set_x( | |
| 833 gtk_util::MirroredLeftPointForRect(tab_.get(), media_indicator_bounds_)); | |
| 834 close_button_bounds_.set_x( | |
| 835 gtk_util::MirroredLeftPointForRect(tab_.get(), close_button_bounds_)); | |
| 836 title_bounds_.set_x( | |
| 837 gtk_util::MirroredLeftPointForRect(tab_.get(), title_bounds_)); | |
| 838 | |
| 839 MoveCloseButtonWidget(); | |
| 840 } | |
| 841 | |
| 842 void TabRendererGtk::MoveCloseButtonWidget() { | |
| 843 if (!close_button_bounds_.IsEmpty()) { | |
| 844 gtk_fixed_move(GTK_FIXED(tab_.get()), close_button_->widget(), | |
| 845 close_button_bounds_.x(), close_button_bounds_.y()); | |
| 846 gtk_widget_show(close_button_->widget()); | |
| 847 } else { | |
| 848 gtk_widget_hide(close_button_->widget()); | |
| 849 } | |
| 850 } | |
| 851 | |
| 852 void TabRendererGtk::PaintTab(GtkWidget* widget, GdkEventExpose* event) { | |
| 853 cairo_t* cr = gdk_cairo_create(gtk_widget_get_window(widget)); | |
| 854 gdk_cairo_rectangle(cr, &event->area); | |
| 855 cairo_clip(cr); | |
| 856 | |
| 857 // The tab is rendered into a windowless widget whose offset is at the | |
| 858 // coordinate event->area. Translate by these offsets so we can render at | |
| 859 // (0,0) to match Windows' rendering metrics. | |
| 860 cairo_matrix_t cairo_matrix; | |
| 861 cairo_matrix_init_translate(&cairo_matrix, event->area.x, event->area.y); | |
| 862 cairo_set_matrix(cr, &cairo_matrix); | |
| 863 | |
| 864 // Save the original x offset so we can position background images properly. | |
| 865 background_offset_x_ = event->area.x; | |
| 866 | |
| 867 Paint(widget, cr); | |
| 868 cairo_destroy(cr); | |
| 869 } | |
| 870 | |
| 871 void TabRendererGtk::PaintTitle(GtkWidget* widget, cairo_t* cr) { | |
| 872 if (title_bounds_.IsEmpty()) | |
| 873 return; | |
| 874 | |
| 875 // Paint the Title. | |
| 876 base::string16 title = data_.title; | |
| 877 if (title.empty()) { | |
| 878 title = data_.loading ? | |
| 879 l10n_util::GetStringUTF16(IDS_TAB_LOADING_TITLE) : | |
| 880 CoreTabHelper::GetDefaultTitle(); | |
| 881 } else { | |
| 882 Browser::FormatTitleForDisplay(&title); | |
| 883 } | |
| 884 | |
| 885 GtkAllocation allocation; | |
| 886 gtk_widget_get_allocation(widget, &allocation); | |
| 887 gfx::Rect bounds(allocation); | |
| 888 | |
| 889 // Draw the text directly onto the Cairo context. This is necessary for | |
| 890 // getting the draw order correct, and automatically applying transformations | |
| 891 // such as scaling when a tab is detached. | |
| 892 gfx::CanvasSkiaPaintCairo canvas(cr, bounds.size(), true); | |
| 893 | |
| 894 SkColor title_color = IsSelected() ? selected_title_color_ | |
| 895 : unselected_title_color_; | |
| 896 | |
| 897 // Disable subpixel rendering. This does not work because the canvas has a | |
| 898 // transparent background. | |
| 899 int flags = gfx::Canvas::NO_ELLIPSIS | gfx::Canvas::NO_SUBPIXEL_RENDERING; | |
| 900 canvas.DrawFadeTruncatingStringRectWithFlags( | |
| 901 title, gfx::Canvas::TruncateFadeTail, gfx::FontList(*title_font_), | |
| 902 title_color, title_bounds_, flags); | |
| 903 } | |
| 904 | |
| 905 void TabRendererGtk::PaintIcon(GtkWidget* widget, cairo_t* cr) { | |
| 906 if (loading_animation_.animation_state() != ANIMATION_NONE) { | |
| 907 PaintLoadingAnimation(widget, cr); | |
| 908 return; | |
| 909 } | |
| 910 | |
| 911 gfx::CairoCachedSurface* to_display = NULL; | |
| 912 if (should_display_crashed_favicon_) { | |
| 913 to_display = theme_service_->GetImageNamed(IDR_SAD_FAVICON).ToCairo(); | |
| 914 } else if (!data_.favicon.isNull()) { | |
| 915 if (data_.is_default_favicon && theme_service_->UsingNativeTheme()) { | |
| 916 to_display = GtkThemeService::GetDefaultFavicon(true).ToCairo(); | |
| 917 } else if (data_.cairo_favicon.valid()) { | |
| 918 to_display = &data_.cairo_favicon; | |
| 919 } | |
| 920 } | |
| 921 | |
| 922 if (to_display) { | |
| 923 to_display->SetSource(cr, widget, favicon_bounds_.x(), | |
| 924 favicon_bounds_.y() + favicon_hiding_offset_); | |
| 925 cairo_paint(cr); | |
| 926 } | |
| 927 } | |
| 928 | |
| 929 void TabRendererGtk::PaintMediaIndicator(GtkWidget* widget, cairo_t* cr) { | |
| 930 if (media_indicator_bounds_.IsEmpty() || !media_indicator_animation_) | |
| 931 return; | |
| 932 | |
| 933 double opaqueness = media_indicator_animation_->GetCurrentValue(); | |
| 934 if (data_.media_state == TAB_MEDIA_STATE_NONE) | |
| 935 opaqueness = 1.0 - opaqueness; // Fading out, not in. | |
| 936 | |
| 937 const gfx::Image& media_indicator_image = | |
| 938 chrome::GetTabMediaIndicatorImage(animating_media_state_); | |
| 939 media_indicator_image.ToCairo()->SetSource( | |
| 940 cr, widget, media_indicator_bounds_.x(), media_indicator_bounds_.y()); | |
| 941 cairo_paint_with_alpha(cr, opaqueness); | |
| 942 } | |
| 943 | |
| 944 void TabRendererGtk::PaintTabBackground(GtkWidget* widget, cairo_t* cr) { | |
| 945 if (IsActive()) { | |
| 946 PaintActiveTabBackground(widget, cr); | |
| 947 } else { | |
| 948 PaintInactiveTabBackground(widget, cr); | |
| 949 | |
| 950 double throb_value = GetThrobValue(); | |
| 951 if (throb_value > 0) { | |
| 952 cairo_push_group(cr); | |
| 953 PaintActiveTabBackground(widget, cr); | |
| 954 cairo_pop_group_to_source(cr); | |
| 955 cairo_paint_with_alpha(cr, throb_value); | |
| 956 } | |
| 957 } | |
| 958 } | |
| 959 | |
| 960 void TabRendererGtk::DrawTabBackground( | |
| 961 cairo_t* cr, | |
| 962 GtkWidget* widget, | |
| 963 const gfx::Image& tab_bg, | |
| 964 int offset_x, | |
| 965 int offset_y) { | |
| 966 tab_bg.ToCairo()->SetSource(cr, widget, -offset_x, -offset_y); | |
| 967 cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REPEAT); | |
| 968 | |
| 969 ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance(); | |
| 970 | |
| 971 // Draw left edge | |
| 972 gfx::Image& tab_l_mask = rb.GetNativeImageNamed(IDR_TAB_ALPHA_LEFT); | |
| 973 tab_l_mask.ToCairo()->MaskSource(cr, widget, 0, 0); | |
| 974 | |
| 975 // Draw center | |
| 976 cairo_rectangle(cr, | |
| 977 tab_active_l_width_, kDropShadowOffset, | |
| 978 width() - (2 * tab_active_l_width_), | |
| 979 tab_inactive_l_height_); | |
| 980 cairo_fill(cr); | |
| 981 | |
| 982 // Draw right edge | |
| 983 gfx::Image& tab_r_mask = rb.GetNativeImageNamed(IDR_TAB_ALPHA_RIGHT); | |
| 984 tab_r_mask.ToCairo()->MaskSource(cr, widget, | |
| 985 width() - tab_active_l_width_, 0); | |
| 986 } | |
| 987 | |
| 988 void TabRendererGtk::DrawTabShadow(cairo_t* cr, | |
| 989 GtkWidget* widget, | |
| 990 int left_idr, | |
| 991 int center_idr, | |
| 992 int right_idr) { | |
| 993 ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance(); | |
| 994 gfx::Image& active_image_l = rb.GetNativeImageNamed(left_idr); | |
| 995 gfx::Image& active_image_c = rb.GetNativeImageNamed(center_idr); | |
| 996 gfx::Image& active_image_r = rb.GetNativeImageNamed(right_idr); | |
| 997 | |
| 998 // Draw left drop shadow | |
| 999 active_image_l.ToCairo()->SetSource(cr, widget, 0, 0); | |
| 1000 cairo_paint(cr); | |
| 1001 | |
| 1002 // Draw the center shadow | |
| 1003 active_image_c.ToCairo()->SetSource(cr, widget, 0, 0); | |
| 1004 cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REPEAT); | |
| 1005 cairo_rectangle(cr, tab_active_l_width_, 0, | |
| 1006 width() - (2 * tab_active_l_width_), | |
| 1007 height()); | |
| 1008 cairo_fill(cr); | |
| 1009 | |
| 1010 // Draw right drop shadow | |
| 1011 active_image_r.ToCairo()->SetSource( | |
| 1012 cr, widget, width() - active_image_r.ToCairo()->Width(), 0); | |
| 1013 cairo_paint(cr); | |
| 1014 } | |
| 1015 | |
| 1016 void TabRendererGtk::PaintInactiveTabBackground(GtkWidget* widget, | |
| 1017 cairo_t* cr) { | |
| 1018 int theme_id = data_.incognito ? | |
| 1019 IDR_THEME_TAB_BACKGROUND_INCOGNITO : IDR_THEME_TAB_BACKGROUND; | |
| 1020 | |
| 1021 gfx::Image tab_bg = theme_service_->GetImageNamed(theme_id); | |
| 1022 | |
| 1023 // If the theme is providing a custom background image, then its top edge | |
| 1024 // should be at the top of the tab. Otherwise, we assume that the background | |
| 1025 // image is a composited foreground + frame image. | |
| 1026 int offset_y = theme_service_->HasCustomImage(theme_id) ? | |
| 1027 0 : background_offset_y_; | |
| 1028 | |
| 1029 DrawTabBackground(cr, widget, tab_bg, background_offset_x_, offset_y); | |
| 1030 | |
| 1031 DrawTabShadow(cr, widget, IDR_TAB_INACTIVE_LEFT, IDR_TAB_INACTIVE_CENTER, | |
| 1032 IDR_TAB_INACTIVE_RIGHT); | |
| 1033 } | |
| 1034 | |
| 1035 void TabRendererGtk::PaintActiveTabBackground(GtkWidget* widget, | |
| 1036 cairo_t* cr) { | |
| 1037 gfx::Image tab_bg = theme_service_->GetImageNamed(IDR_THEME_TOOLBAR); | |
| 1038 | |
| 1039 DrawTabBackground(cr, widget, tab_bg, background_offset_x_, 0); | |
| 1040 DrawTabShadow(cr, widget, IDR_TAB_ACTIVE_LEFT, IDR_TAB_ACTIVE_CENTER, | |
| 1041 IDR_TAB_ACTIVE_RIGHT); | |
| 1042 } | |
| 1043 | |
| 1044 void TabRendererGtk::PaintLoadingAnimation(GtkWidget* widget, | |
| 1045 cairo_t* cr) { | |
| 1046 int id = loading_animation_.animation_state() == ANIMATION_WAITING ? | |
| 1047 IDR_THROBBER_WAITING : IDR_THROBBER; | |
| 1048 gfx::Image throbber = theme_service_->GetImageNamed(id); | |
| 1049 | |
| 1050 const int image_size = throbber.ToCairo()->Height(); | |
| 1051 const int image_offset = loading_animation_.animation_frame() * image_size; | |
| 1052 DCHECK(image_size == favicon_bounds_.height()); | |
| 1053 DCHECK(image_size == favicon_bounds_.width()); | |
| 1054 | |
| 1055 throbber.ToCairo()->SetSource(cr, widget, favicon_bounds_.x() - image_offset, | |
| 1056 favicon_bounds_.y()); | |
| 1057 cairo_rectangle(cr, favicon_bounds_.x(), favicon_bounds_.y(), | |
| 1058 image_size, image_size); | |
| 1059 cairo_fill(cr); | |
| 1060 } | |
| 1061 | |
| 1062 int TabRendererGtk::IconCapacity() const { | |
| 1063 if (height() < GetMinimumUnselectedSize().height()) | |
| 1064 return 0; | |
| 1065 const int available_width = | |
| 1066 std::max(0, width() - kLeftPadding - kRightPadding); | |
| 1067 const int kPaddingBetweenIcons = 2; | |
| 1068 if (available_width >= gfx::kFaviconSize && | |
| 1069 available_width < (gfx::kFaviconSize + kPaddingBetweenIcons)) { | |
| 1070 return 1; | |
| 1071 } | |
| 1072 return available_width / (gfx::kFaviconSize + kPaddingBetweenIcons); | |
| 1073 } | |
| 1074 | |
| 1075 bool TabRendererGtk::ShouldShowIcon() const { | |
| 1076 return chrome::ShouldTabShowFavicon( | |
| 1077 IconCapacity(), mini(), IsActive(), data_.show_icon, | |
| 1078 animating_media_state_); | |
| 1079 } | |
| 1080 | |
| 1081 bool TabRendererGtk::ShouldShowMediaIndicator() const { | |
| 1082 return chrome::ShouldTabShowMediaIndicator( | |
| 1083 IconCapacity(), mini(), IsActive(), data_.show_icon, | |
| 1084 animating_media_state_); | |
| 1085 } | |
| 1086 | |
| 1087 bool TabRendererGtk::ShouldShowCloseBox() const { | |
| 1088 return chrome::ShouldTabShowCloseButton(IconCapacity(), mini(), IsActive()); | |
| 1089 } | |
| 1090 | |
| 1091 CustomDrawButton* TabRendererGtk::MakeCloseButton() { | |
| 1092 CustomDrawButton* button = CustomDrawButton::CloseButtonBar(theme_service_); | |
| 1093 button->ForceChromeTheme(); | |
| 1094 | |
| 1095 g_signal_connect(button->widget(), "clicked", | |
| 1096 G_CALLBACK(OnCloseButtonClickedThunk), this); | |
| 1097 g_signal_connect(button->widget(), "button-release-event", | |
| 1098 G_CALLBACK(OnCloseButtonMouseReleaseThunk), this); | |
| 1099 g_signal_connect(button->widget(), "enter-notify-event", | |
| 1100 G_CALLBACK(OnEnterNotifyEventThunk), this); | |
| 1101 g_signal_connect(button->widget(), "leave-notify-event", | |
| 1102 G_CALLBACK(OnLeaveNotifyEventThunk), this); | |
| 1103 gtk_widget_set_can_focus(button->widget(), FALSE); | |
| 1104 gtk_fixed_put(GTK_FIXED(tab_.get()), button->widget(), 0, 0); | |
| 1105 | |
| 1106 return button; | |
| 1107 } | |
| 1108 | |
| 1109 double TabRendererGtk::GetThrobValue() { | |
| 1110 bool is_selected = IsSelected(); | |
| 1111 double min = is_selected ? kSelectedTabOpacity : 0; | |
| 1112 double scale = is_selected ? kSelectedTabThrobScale : 1; | |
| 1113 | |
| 1114 if (mini_title_animation_.get() && mini_title_animation_->is_animating()) { | |
| 1115 return mini_title_animation_->GetCurrentValue() * | |
| 1116 kMiniTitleChangeThrobOpacity * scale + min; | |
| 1117 } | |
| 1118 | |
| 1119 if (hover_animation_.get()) | |
| 1120 return kHoverOpacity * hover_animation_->GetCurrentValue() * scale + min; | |
| 1121 | |
| 1122 return is_selected ? kSelectedTabOpacity : 0; | |
| 1123 } | |
| 1124 | |
| 1125 void TabRendererGtk::CloseButtonClicked() { | |
| 1126 // Nothing to do. | |
| 1127 } | |
| 1128 | |
| 1129 void TabRendererGtk::OnCloseButtonClicked(GtkWidget* widget) { | |
| 1130 CloseButtonClicked(); | |
| 1131 } | |
| 1132 | |
| 1133 gboolean TabRendererGtk::OnCloseButtonMouseRelease(GtkWidget* widget, | |
| 1134 GdkEventButton* event) { | |
| 1135 if (event->button == 2) { | |
| 1136 CloseButtonClicked(); | |
| 1137 return TRUE; | |
| 1138 } | |
| 1139 | |
| 1140 return FALSE; | |
| 1141 } | |
| 1142 | |
| 1143 gboolean TabRendererGtk::OnExposeEvent(GtkWidget* widget, | |
| 1144 GdkEventExpose* event) { | |
| 1145 TRACE_EVENT0("ui::gtk", "TabRendererGtk::OnExposeEvent"); | |
| 1146 | |
| 1147 PaintTab(widget, event); | |
| 1148 gtk_container_propagate_expose(GTK_CONTAINER(tab_.get()), | |
| 1149 close_button_->widget(), event); | |
| 1150 return TRUE; | |
| 1151 } | |
| 1152 | |
| 1153 void TabRendererGtk::OnSizeAllocate(GtkWidget* widget, | |
| 1154 GtkAllocation* allocation) { | |
| 1155 gfx::Rect bounds = gfx::Rect(allocation->x, allocation->y, | |
| 1156 allocation->width, allocation->height); | |
| 1157 | |
| 1158 // Nothing to do if the bounds are the same. If we don't catch this, we'll | |
| 1159 // get an infinite loop of size-allocate signals. | |
| 1160 if (bounds_ == bounds) | |
| 1161 return; | |
| 1162 | |
| 1163 bounds_ = bounds; | |
| 1164 Layout(); | |
| 1165 } | |
| 1166 | |
| 1167 gboolean TabRendererGtk::OnEnterNotifyEvent(GtkWidget* widget, | |
| 1168 GdkEventCrossing* event) { | |
| 1169 hover_animation_->SetTweenType(gfx::Tween::EASE_OUT); | |
| 1170 hover_animation_->Show(); | |
| 1171 return FALSE; | |
| 1172 } | |
| 1173 | |
| 1174 gboolean TabRendererGtk::OnLeaveNotifyEvent(GtkWidget* widget, | |
| 1175 GdkEventCrossing* event) { | |
| 1176 hover_animation_->SetTweenType(gfx::Tween::EASE_IN); | |
| 1177 hover_animation_->Hide(); | |
| 1178 return FALSE; | |
| 1179 } | |
| 1180 | |
| 1181 // static | |
| 1182 void TabRendererGtk::InitResources() { | |
| 1183 if (initialized_) | |
| 1184 return; | |
| 1185 | |
| 1186 // Grab the pixel sizes of our masking images. | |
| 1187 ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance(); | |
| 1188 GdkPixbuf* tab_active_l = rb.GetNativeImageNamed( | |
| 1189 IDR_TAB_ACTIVE_LEFT).ToGdkPixbuf(); | |
| 1190 tab_active_l_width_ = gdk_pixbuf_get_width(tab_active_l); | |
| 1191 tab_active_l_height_ = gdk_pixbuf_get_height(tab_active_l); | |
| 1192 | |
| 1193 GdkPixbuf* tab_inactive_l = rb.GetNativeImageNamed( | |
| 1194 IDR_TAB_INACTIVE_LEFT).ToGdkPixbuf(); | |
| 1195 tab_inactive_l_height_ = gdk_pixbuf_get_height(tab_inactive_l); | |
| 1196 | |
| 1197 GdkPixbuf* tab_close = rb.GetNativeImageNamed(IDR_CLOSE_1).ToGdkPixbuf(); | |
| 1198 close_button_width_ = gdk_pixbuf_get_width(tab_close); | |
| 1199 close_button_height_ = gdk_pixbuf_get_height(tab_close); | |
| 1200 | |
| 1201 const gfx::Font& base_font = rb.GetFont(ui::ResourceBundle::BaseFont); | |
| 1202 title_font_ = new gfx::Font(base_font.GetFontName(), kFontPixelSize); | |
| 1203 title_font_height_ = title_font_->GetHeight(); | |
| 1204 | |
| 1205 initialized_ = true; | |
| 1206 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 231733005:
Delete the GTK+ port of Chrome. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src