| 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/custom_button.h" | |
| 6 | |
| 7 #include "base/basictypes.h" | |
| 8 #include "base/debug/trace_event.h" | |
| 9 #include "base/logging.h" | |
| 10 #include "chrome/browser/chrome_notification_types.h" | |
| 11 #include "chrome/browser/ui/gtk/gtk_chrome_button.h" | |
| 12 #include "chrome/browser/ui/gtk/gtk_theme_service.h" | |
| 13 #include "chrome/browser/ui/gtk/gtk_util.h" | |
| 14 #include "content/public/browser/notification_source.h" | |
| 15 #include "grit/theme_resources.h" | |
| 16 #include "grit/ui_resources.h" | |
| 17 #include "third_party/skia/include/core/SkBitmap.h" | |
| 18 #include "ui/base/resource/resource_bundle.h" | |
| 19 #include "ui/gfx/gtk_util.h" | |
| 20 #include "ui/gfx/image/cairo_cached_surface.h" | |
| 21 #include "ui/gfx/image/image.h" | |
| 22 #include "ui/gfx/skbitmap_operations.h" | |
| 23 | |
| 24 namespace { | |
| 25 | |
| 26 GdkPixbuf* GetImage(int resource_id) { | |
| 27 if (!resource_id) | |
| 28 return NULL; | |
| 29 return ui::ResourceBundle::GetSharedInstance().GetNativeImageNamed( | |
| 30 resource_id, ui::ResourceBundle::RTL_ENABLED).ToGdkPixbuf(); | |
| 31 } | |
| 32 | |
| 33 } // namespace | |
| 34 | |
| 35 CustomDrawButtonBase::CustomDrawButtonBase(GtkThemeService* theme_provider, | |
| 36 int normal_id, | |
| 37 int pressed_id, | |
| 38 int hover_id, | |
| 39 int disabled_id) | |
| 40 : paint_override_(-1), | |
| 41 normal_id_(normal_id), | |
| 42 pressed_id_(pressed_id), | |
| 43 hover_id_(hover_id), | |
| 44 disabled_id_(disabled_id), | |
| 45 theme_service_(theme_provider), | |
| 46 flipped_(false) { | |
| 47 for (int i = 0; i < (GTK_STATE_INSENSITIVE + 1); ++i) | |
| 48 surfaces_[i].reset(new gfx::CairoCachedSurface); | |
| 49 background_image_.reset(new gfx::CairoCachedSurface); | |
| 50 | |
| 51 if (theme_provider) { | |
| 52 // Load images by pretending that we got a BROWSER_THEME_CHANGED | |
| 53 // notification. | |
| 54 theme_provider->InitThemesFor(this); | |
| 55 | |
| 56 registrar_.Add(this, | |
| 57 chrome::NOTIFICATION_BROWSER_THEME_CHANGED, | |
| 58 content::Source<ThemeService>(theme_provider)); | |
| 59 } else { | |
| 60 // Load the button images from the resource bundle. | |
| 61 surfaces_[GTK_STATE_NORMAL]->UsePixbuf(GetImage(normal_id_)); | |
| 62 surfaces_[GTK_STATE_ACTIVE]->UsePixbuf(GetImage(pressed_id_)); | |
| 63 surfaces_[GTK_STATE_PRELIGHT]->UsePixbuf(GetImage(hover_id_)); | |
| 64 surfaces_[GTK_STATE_SELECTED]->UsePixbuf(NULL); | |
| 65 surfaces_[GTK_STATE_INSENSITIVE]->UsePixbuf(GetImage(disabled_id_)); | |
| 66 } | |
| 67 } | |
| 68 | |
| 69 CustomDrawButtonBase::~CustomDrawButtonBase() { | |
| 70 } | |
| 71 | |
| 72 int CustomDrawButtonBase::Width() const { | |
| 73 return surfaces_[0]->Width(); | |
| 74 } | |
| 75 | |
| 76 int CustomDrawButtonBase::Height() const { | |
| 77 return surfaces_[0]->Height(); | |
| 78 } | |
| 79 | |
| 80 gboolean CustomDrawButtonBase::OnExpose(GtkWidget* widget, | |
| 81 GdkEventExpose* e, | |
| 82 gdouble hover_state) { | |
| 83 TRACE_EVENT0("ui::gtk", "CustomDrawButtonBase::OnExpose"); | |
| 84 int paint_state = paint_override_ >= 0 ? | |
| 85 paint_override_ : gtk_widget_get_state(widget); | |
| 86 | |
| 87 // If the paint state is PRELIGHT then set it to NORMAL (we will paint the | |
| 88 // hover state according to |hover_state_|). | |
| 89 if (paint_state == GTK_STATE_PRELIGHT) | |
| 90 paint_state = GTK_STATE_NORMAL; | |
| 91 bool animating_hover = hover_state > 0.0 && | |
| 92 paint_state == GTK_STATE_NORMAL; | |
| 93 gfx::CairoCachedSurface* pixbuf = PixbufForState(paint_state); | |
| 94 gfx::CairoCachedSurface* hover_pixbuf = PixbufForState(GTK_STATE_PRELIGHT); | |
| 95 | |
| 96 if (!pixbuf || !pixbuf->valid()) | |
| 97 return FALSE; | |
| 98 if (animating_hover && (!hover_pixbuf || !hover_pixbuf->valid())) | |
| 99 return FALSE; | |
| 100 | |
| 101 cairo_t* cairo_context = gdk_cairo_create(GDK_DRAWABLE( | |
| 102 gtk_widget_get_window(widget))); | |
| 103 GtkAllocation allocation; | |
| 104 gtk_widget_get_allocation(widget, &allocation); | |
| 105 cairo_translate(cairo_context, allocation.x, allocation.y); | |
| 106 | |
| 107 if (flipped_) { | |
| 108 // Horizontally flip the image for non-LTR/RTL reasons. | |
| 109 cairo_translate(cairo_context, allocation.width, 0.0f); | |
| 110 cairo_scale(cairo_context, -1.0f, 1.0f); | |
| 111 } | |
| 112 | |
| 113 // The widget might be larger than the pixbuf. Paint the pixbuf flush with the | |
| 114 // start of the widget (left for LTR, right for RTL) and its bottom. | |
| 115 gfx::Rect bounds = gfx::Rect(0, 0, pixbuf->Width(), 0); | |
| 116 int x = gtk_util::MirroredLeftPointForRect(widget, bounds); | |
| 117 int y = allocation.height - pixbuf->Height(); | |
| 118 | |
| 119 if (background_image_->valid()) { | |
| 120 background_image_->SetSource(cairo_context, widget, x, y); | |
| 121 cairo_paint(cairo_context); | |
| 122 } | |
| 123 | |
| 124 pixbuf->SetSource(cairo_context, widget, x, y); | |
| 125 cairo_paint(cairo_context); | |
| 126 | |
| 127 if (animating_hover) { | |
| 128 hover_pixbuf->SetSource(cairo_context, widget, x, y); | |
| 129 cairo_paint_with_alpha(cairo_context, hover_state); | |
| 130 } | |
| 131 | |
| 132 cairo_destroy(cairo_context); | |
| 133 | |
| 134 GtkWidget* child = gtk_bin_get_child(GTK_BIN(widget)); | |
| 135 if (child) | |
| 136 gtk_container_propagate_expose(GTK_CONTAINER(widget), child, e); | |
| 137 | |
| 138 return TRUE; | |
| 139 } | |
| 140 | |
| 141 void CustomDrawButtonBase::SetBackground(SkColor color, | |
| 142 const SkBitmap& image, | |
| 143 const SkBitmap& mask) { | |
| 144 if (image.isNull() || mask.isNull()) { | |
| 145 if (background_image_->valid()) { | |
| 146 background_image_->UsePixbuf(NULL); | |
| 147 } | |
| 148 } else { | |
| 149 SkBitmap img = | |
| 150 SkBitmapOperations::CreateButtonBackground(color, image, mask); | |
| 151 | |
| 152 GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(img); | |
| 153 background_image_->UsePixbuf(pixbuf); | |
| 154 g_object_unref(pixbuf); | |
| 155 } | |
| 156 } | |
| 157 | |
| 158 void CustomDrawButtonBase::Observe(int type, | |
| 159 const content::NotificationSource& source, | |
| 160 const content::NotificationDetails& details) { | |
| 161 DCHECK(theme_service_); | |
| 162 DCHECK(chrome::NOTIFICATION_BROWSER_THEME_CHANGED == type); | |
| 163 | |
| 164 surfaces_[GTK_STATE_NORMAL]->UsePixbuf(normal_id_ ? | |
| 165 theme_service_->GetRTLEnabledPixbufNamed(normal_id_) : NULL); | |
| 166 surfaces_[GTK_STATE_ACTIVE]->UsePixbuf(pressed_id_ ? | |
| 167 theme_service_->GetRTLEnabledPixbufNamed(pressed_id_) : NULL); | |
| 168 surfaces_[GTK_STATE_PRELIGHT]->UsePixbuf(hover_id_ ? | |
| 169 theme_service_->GetRTLEnabledPixbufNamed(hover_id_) : NULL); | |
| 170 surfaces_[GTK_STATE_SELECTED]->UsePixbuf(NULL); | |
| 171 surfaces_[GTK_STATE_INSENSITIVE]->UsePixbuf(disabled_id_ ? | |
| 172 theme_service_->GetRTLEnabledPixbufNamed(disabled_id_) : NULL); | |
| 173 } | |
| 174 | |
| 175 gfx::CairoCachedSurface* CustomDrawButtonBase::PixbufForState(int state) { | |
| 176 gfx::CairoCachedSurface* pixbuf = surfaces_[state].get(); | |
| 177 | |
| 178 // Fall back to the default image if we don't have one for this state. | |
| 179 if (!pixbuf || !pixbuf->valid()) | |
| 180 pixbuf = surfaces_[GTK_STATE_NORMAL].get(); | |
| 181 | |
| 182 return pixbuf; | |
| 183 } | |
| 184 | |
| 185 // CustomDrawHoverController --------------------------------------------------- | |
| 186 | |
| 187 CustomDrawHoverController::CustomDrawHoverController(GtkWidget* widget) | |
| 188 : slide_animation_(this), | |
| 189 widget_(NULL) { | |
| 190 Init(widget); | |
| 191 } | |
| 192 | |
| 193 CustomDrawHoverController::CustomDrawHoverController() | |
| 194 : slide_animation_(this), | |
| 195 widget_(NULL) { | |
| 196 } | |
| 197 | |
| 198 CustomDrawHoverController::~CustomDrawHoverController() { | |
| 199 } | |
| 200 | |
| 201 void CustomDrawHoverController::Init(GtkWidget* widget) { | |
| 202 DCHECK(widget_ == NULL); | |
| 203 widget_ = widget; | |
| 204 g_signal_connect(widget_, "enter-notify-event", | |
| 205 G_CALLBACK(OnEnterThunk), this); | |
| 206 g_signal_connect(widget_, "leave-notify-event", | |
| 207 G_CALLBACK(OnLeaveThunk), this); | |
| 208 } | |
| 209 | |
| 210 void CustomDrawHoverController::AnimationProgressed( | |
| 211 const gfx::Animation* animation) { | |
| 212 gtk_widget_queue_draw(widget_); | |
| 213 } | |
| 214 | |
| 215 gboolean CustomDrawHoverController::OnEnter( | |
| 216 GtkWidget* widget, | |
| 217 GdkEventCrossing* event) { | |
| 218 slide_animation_.Show(); | |
| 219 return FALSE; | |
| 220 } | |
| 221 | |
| 222 gboolean CustomDrawHoverController::OnLeave( | |
| 223 GtkWidget* widget, | |
| 224 GdkEventCrossing* event) { | |
| 225 // When the user is holding a mouse button, we don't want to animate. | |
| 226 if (event->state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK)) | |
| 227 slide_animation_.Reset(); | |
| 228 else | |
| 229 slide_animation_.Hide(); | |
| 230 return FALSE; | |
| 231 } | |
| 232 | |
| 233 // CustomDrawButton ------------------------------------------------------------ | |
| 234 | |
| 235 CustomDrawButton::CustomDrawButton(int normal_id, | |
| 236 int pressed_id, | |
| 237 int hover_id, | |
| 238 int disabled_id) | |
| 239 : button_base_(NULL, normal_id, pressed_id, hover_id, disabled_id), | |
| 240 theme_service_(NULL), | |
| 241 forcing_chrome_theme_(false) { | |
| 242 Init(); | |
| 243 | |
| 244 // Initialize the theme stuff with no theme_provider. | |
| 245 SetBrowserTheme(); | |
| 246 } | |
| 247 | |
| 248 CustomDrawButton::CustomDrawButton(GtkThemeService* theme_provider, | |
| 249 int normal_id, | |
| 250 int pressed_id, | |
| 251 int hover_id, | |
| 252 int disabled_id, | |
| 253 const char* stock_id, | |
| 254 GtkIconSize stock_size) | |
| 255 : button_base_(theme_provider, normal_id, pressed_id, hover_id, | |
| 256 disabled_id), | |
| 257 theme_service_(theme_provider), | |
| 258 forcing_chrome_theme_(false) { | |
| 259 native_widget_.Own(gtk_image_new_from_stock(stock_id, stock_size)); | |
| 260 | |
| 261 Init(); | |
| 262 | |
| 263 theme_service_->InitThemesFor(this); | |
| 264 registrar_.Add(this, | |
| 265 chrome::NOTIFICATION_BROWSER_THEME_CHANGED, | |
| 266 content::Source<ThemeService>(theme_provider)); | |
| 267 } | |
| 268 | |
| 269 CustomDrawButton::CustomDrawButton(GtkThemeService* theme_provider, | |
| 270 int normal_id, | |
| 271 int pressed_id, | |
| 272 int hover_id, | |
| 273 int disabled_id, | |
| 274 GtkWidget* native_widget) | |
| 275 : button_base_(theme_provider, normal_id, pressed_id, hover_id, | |
| 276 disabled_id), | |
| 277 native_widget_(native_widget), | |
| 278 theme_service_(theme_provider), | |
| 279 forcing_chrome_theme_(false) { | |
| 280 Init(); | |
| 281 | |
| 282 theme_service_->InitThemesFor(this); | |
| 283 registrar_.Add(this, | |
| 284 chrome::NOTIFICATION_BROWSER_THEME_CHANGED, | |
| 285 content::Source<ThemeService>(theme_provider)); | |
| 286 } | |
| 287 | |
| 288 CustomDrawButton::~CustomDrawButton() { | |
| 289 widget_.Destroy(); | |
| 290 native_widget_.Destroy(); | |
| 291 } | |
| 292 | |
| 293 void CustomDrawButton::Init() { | |
| 294 widget_.Own(gtk_chrome_button_new()); | |
| 295 gtk_widget_set_can_focus(widget(), FALSE); | |
| 296 g_signal_connect(widget(), "expose-event", | |
| 297 G_CALLBACK(OnCustomExposeThunk), this); | |
| 298 hover_controller_.Init(widget()); | |
| 299 } | |
| 300 | |
| 301 void CustomDrawButton::ForceChromeTheme() { | |
| 302 forcing_chrome_theme_ = true; | |
| 303 SetBrowserTheme(); | |
| 304 } | |
| 305 | |
| 306 void CustomDrawButton::Observe(int type, | |
| 307 const content::NotificationSource& source, | |
| 308 const content::NotificationDetails& details) { | |
| 309 DCHECK(chrome::NOTIFICATION_BROWSER_THEME_CHANGED == type); | |
| 310 SetBrowserTheme(); | |
| 311 } | |
| 312 | |
| 313 GtkAllocation CustomDrawButton::WidgetAllocation() const { | |
| 314 GtkAllocation allocation; | |
| 315 gtk_widget_get_allocation(widget_.get(), &allocation); | |
| 316 return allocation; | |
| 317 } | |
| 318 | |
| 319 int CustomDrawButton::SurfaceWidth() const { | |
| 320 return button_base_.Width(); | |
| 321 } | |
| 322 | |
| 323 int CustomDrawButton::SurfaceHeight() const { | |
| 324 return button_base_.Height(); | |
| 325 } | |
| 326 | |
| 327 void CustomDrawButton::SetPaintOverride(GtkStateType state) { | |
| 328 button_base_.set_paint_override(state); | |
| 329 gtk_chrome_button_set_paint_state(GTK_CHROME_BUTTON(widget()), state); | |
| 330 gtk_widget_queue_draw(widget()); | |
| 331 } | |
| 332 | |
| 333 void CustomDrawButton::UnsetPaintOverride() { | |
| 334 button_base_.set_paint_override(-1); | |
| 335 gtk_chrome_button_unset_paint_state(GTK_CHROME_BUTTON(widget())); | |
| 336 gtk_widget_queue_draw(widget()); | |
| 337 } | |
| 338 | |
| 339 void CustomDrawButton::SetBackground(SkColor color, | |
| 340 const SkBitmap& image, | |
| 341 const SkBitmap& mask) { | |
| 342 button_base_.SetBackground(color, image, mask); | |
| 343 } | |
| 344 | |
| 345 gboolean CustomDrawButton::OnCustomExpose(GtkWidget* sender, | |
| 346 GdkEventExpose* e) { | |
| 347 UNSHIPPED_TRACE_EVENT0("ui::gtk", "CustomDrawButtonBase::OnCustomExpose"); | |
| 348 if (UseGtkTheme()) { | |
| 349 // Continue processing this expose event. | |
| 350 return FALSE; | |
| 351 } else { | |
| 352 double hover_state = hover_controller_.GetCurrentValue(); | |
| 353 return button_base_.OnExpose(sender, e, hover_state); | |
| 354 } | |
| 355 } | |
| 356 | |
| 357 // static | |
| 358 CustomDrawButton* CustomDrawButton::CloseButtonBar( | |
| 359 GtkThemeService* theme_provider) { | |
| 360 CustomDrawButton* button = new CustomDrawButton(theme_provider, | |
| 361 IDR_CLOSE_1, IDR_CLOSE_1_P, IDR_CLOSE_1_H, 0, | |
| 362 GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU); | |
| 363 return button; | |
| 364 } | |
| 365 | |
| 366 // static | |
| 367 CustomDrawButton* CustomDrawButton::CloseButtonBubble( | |
| 368 GtkThemeService* theme_provider) { | |
| 369 CustomDrawButton* button = new CustomDrawButton(theme_provider, | |
| 370 IDR_CLOSE_2, IDR_CLOSE_2_P, IDR_CLOSE_2_H, 0, | |
| 371 GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU); | |
| 372 return button; | |
| 373 } | |
| 374 | |
| 375 void CustomDrawButton::SetBrowserTheme() { | |
| 376 if (UseGtkTheme()) { | |
| 377 if (native_widget_.get()) | |
| 378 gtk_button_set_image(GTK_BUTTON(widget()), native_widget_.get()); | |
| 379 gtk_widget_set_size_request(widget(), -1, -1); | |
| 380 gtk_widget_set_app_paintable(widget(), FALSE); | |
| 381 } else { | |
| 382 if (native_widget_.get()) | |
| 383 gtk_button_set_image(GTK_BUTTON(widget()), NULL); | |
| 384 gtk_widget_set_size_request(widget(), button_base_.Width(), | |
| 385 button_base_.Height()); | |
| 386 | |
| 387 gtk_widget_set_app_paintable(widget(), TRUE); | |
| 388 } | |
| 389 | |
| 390 gtk_chrome_button_set_use_gtk_rendering( | |
| 391 GTK_CHROME_BUTTON(widget()), UseGtkTheme()); | |
| 392 } | |
| 393 | |
| 394 bool CustomDrawButton::UseGtkTheme() { | |
| 395 return !forcing_chrome_theme_ && theme_service_ && | |
| 396 theme_service_->UsingNativeTheme(); | |
| 397 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 231733005:
Delete the GTK+ port of Chrome. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src