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/libgtk2ui/gtk2_ui.h"
6
7 #include <set>
8
9 #include "base/command_line.h"
10 #include "base/environment.h"
11 #include "base/i18n/rtl.h"
12 #include "base/logging.h"
13 #include "base/nix/mime_util_xdg.h"
14 #include "base/stl_util.h"
15 #include "base/strings/stringprintf.h"
16 #include "chrome/browser/themes/theme_properties.h"
17 #include "chrome/browser/ui/libgtk2ui/app_indicator_icon.h"
18 #include "chrome/browser/ui/libgtk2ui/chrome_gtk_frame.h"
19 #include "chrome/browser/ui/libgtk2ui/gtk2_util.h"
20 #include "chrome/browser/ui/libgtk2ui/native_theme_gtk2.h"
21 #include "chrome/browser/ui/libgtk2ui/select_file_dialog_impl.h"
22 #include "chrome/browser/ui/libgtk2ui/skia_utils_gtk2.h"
23 #include "chrome/browser/ui/libgtk2ui/unity_service.h"
24 #include "chrome/browser/ui/libgtk2ui/x11_input_method_context_impl_gtk2.h"
25 #include "grit/theme_resources.h"
26 #include "grit/ui_resources.h"
27 #include "third_party/skia/include/core/SkBitmap.h"
28 #include "third_party/skia/include/core/SkCanvas.h"
29 #include "third_party/skia/include/core/SkColor.h"
30 #include "third_party/skia/include/core/SkShader.h"
31 #include "ui/base/resource/resource_bundle.h"
32 #include "ui/gfx/canvas.h"
33 #include "ui/gfx/image/image.h"
34 #include "ui/gfx/rect.h"
35 #include "ui/gfx/size.h"
36 #include "ui/gfx/skbitmap_operations.h"
37 #include "ui/gfx/skia_util.h"
38 #include "ui/views/linux_ui/window_button_order_observer.h"
39
40 #if defined(USE_GCONF)
41 #include "chrome/browser/ui/libgtk2ui/gconf_titlebar_listener.h"
42 #endif
43
44 // A minimized port of GtkThemeService into something that can provide colors
45 // and images for aura.
46 //
47 // TODO(erg): There's still a lot that needs ported or done for the first time:
48 //
49 // - Inject default favicon/folder icons into views somehow.
50 // - Render and inject the button overlay from the gtk theme.
51 // - Render and inject the omnibox background.
52 // - Listen for the "style-set" signal on |fake_frame_| and recreate theme
53 // colors and images.
54 // - Allow not using the theme.
55 // - Make sure to test with a light on dark theme, too.
56 // - Everything else that we're not doing.
57
58 namespace {
59
60 struct GObjectDeleter {
operator ()__anon076cd6c70111::GObjectDeleter61 void operator()(void* ptr) {
62 g_object_unref(ptr);
63 }
64 };
65 struct GtkIconInfoDeleter {
operator ()__anon076cd6c70111::GtkIconInfoDeleter66 void operator()(GtkIconInfo* ptr) {
67 gtk_icon_info_free(ptr);
68 }
69 };
70 typedef scoped_ptr<GIcon, GObjectDeleter> ScopedGIcon;
71 typedef scoped_ptr<GtkIconInfo, GtkIconInfoDeleter> ScopedGtkIconInfo;
72 typedef scoped_ptr<GdkPixbuf, GObjectDeleter> ScopedGdkPixbuf;
73
74 // Prefix for app indicator ids
75 const char kAppIndicatorIdPrefix[] = "chrome_app_indicator_";
76
77 // Number of app indicators used (used as part of app-indicator id).
78 int indicators_count;
79
80 // The size of the rendered toolbar image.
81 const int kToolbarImageWidth = 64;
82 const int kToolbarImageHeight = 128;
83
84 // How much to tint the GTK+ color lighter at the top of the window.
85 const color_utils::HSL kGtkFrameShift = { -1, -1, 0.58 };
86
87 // How much to tint the GTK+ color when an explicit frame color hasn't been
88 // specified.
89 const color_utils::HSL kDefaultFrameShift = { -1, -1, 0.4 };
90
91 // Values used as the new luminance and saturation values in the inactive tab
92 // text color.
93 const double kDarkInactiveLuminance = 0.85;
94 const double kLightInactiveLuminance = 0.15;
95 const double kHeavyInactiveSaturation = 0.7;
96 const double kLightInactiveSaturation = 0.3;
97
98 // Default color for links on the NTP when the GTK+ theme doesn't define a
99 // link color. Constant taken from gtklinkbutton.c.
100 const GdkColor kDefaultLinkColor = { 0, 0, 0, 0xeeee };
101
102 const int kSkiaToGDKMultiplier = 257;
103
104 // TODO(erg): ThemeService has a whole interface just for reading default
105 // constants. Figure out what to do with that more long term; for now, just
106 // copy the constants themselves here.
107 //
108 // Default tints.
109 const color_utils::HSL kDefaultTintButtons = { -1, -1, -1 };
110 const color_utils::HSL kDefaultTintFrame = { -1, -1, -1 };
111 const color_utils::HSL kDefaultTintFrameInactive = { -1, -1, 0.75f };
112 const color_utils::HSL kDefaultTintFrameIncognito = { -1, 0.2f, 0.35f };
113 const color_utils::HSL kDefaultTintFrameIncognitoInactive = { -1, 0.3f, 0.6f };
114 const color_utils::HSL kDefaultTintBackgroundTab = { -1, 0.5, 0.75 };
115
116 // A list of images that we provide while in gtk mode.
117 const int kThemeImages[] = {
118 IDR_THEME_TOOLBAR,
119 IDR_THEME_TAB_BACKGROUND,
120 IDR_THEME_TAB_BACKGROUND_INCOGNITO,
121 IDR_THEME_FRAME,
122 IDR_THEME_FRAME_INACTIVE,
123 IDR_THEME_FRAME_INCOGNITO,
124 IDR_THEME_FRAME_INCOGNITO_INACTIVE,
125 };
126
127 // A list of icons used in the autocomplete view that should be tinted to the
128 // current gtk theme selection color so they stand out against the GtkEntry's
129 // base color.
130 // TODO(erg): Decide what to do about other icons that appear in the omnibox,
131 // e.g. content settings icons.
132 const int kAutocompleteImages[] = {
133 IDR_OMNIBOX_EXTENSION_APP,
134 IDR_OMNIBOX_HTTP,
135 IDR_OMNIBOX_HTTP_DARK,
136 IDR_OMNIBOX_SEARCH,
137 IDR_OMNIBOX_SEARCH_DARK,
138 IDR_OMNIBOX_STAR,
139 IDR_OMNIBOX_STAR_DARK,
140 IDR_OMNIBOX_TTS,
141 IDR_OMNIBOX_TTS_DARK,
142 };
143
144 // This table converts button ids into a pair of gtk-stock id and state.
145 struct IDRGtkMapping {
146 int idr;
147 const char* stock_id;
148 GtkStateType gtk_state;
149 } const kGtkIcons[] = {
150 { IDR_BACK, GTK_STOCK_GO_BACK, GTK_STATE_NORMAL },
151 { IDR_BACK_D, GTK_STOCK_GO_BACK, GTK_STATE_INSENSITIVE },
152 { IDR_BACK_H, GTK_STOCK_GO_BACK, GTK_STATE_PRELIGHT },
153 { IDR_BACK_P, GTK_STOCK_GO_BACK, GTK_STATE_ACTIVE },
154
155 { IDR_FORWARD, GTK_STOCK_GO_FORWARD, GTK_STATE_NORMAL },
156 { IDR_FORWARD_D, GTK_STOCK_GO_FORWARD, GTK_STATE_INSENSITIVE },
157 { IDR_FORWARD_H, GTK_STOCK_GO_FORWARD, GTK_STATE_PRELIGHT },
158 { IDR_FORWARD_P, GTK_STOCK_GO_FORWARD, GTK_STATE_ACTIVE },
159
160 { IDR_HOME, GTK_STOCK_HOME, GTK_STATE_NORMAL },
161 { IDR_HOME_H, GTK_STOCK_HOME, GTK_STATE_PRELIGHT },
162 { IDR_HOME_P, GTK_STOCK_HOME, GTK_STATE_ACTIVE },
163
164 { IDR_RELOAD, GTK_STOCK_REFRESH, GTK_STATE_NORMAL },
165 { IDR_RELOAD_H, GTK_STOCK_REFRESH, GTK_STATE_PRELIGHT },
166 { IDR_RELOAD_P, GTK_STOCK_REFRESH, GTK_STATE_ACTIVE },
167
168 { IDR_STOP, GTK_STOCK_STOP, GTK_STATE_NORMAL },
169 { IDR_STOP_D, GTK_STOCK_STOP, GTK_STATE_INSENSITIVE },
170 { IDR_STOP_H, GTK_STOCK_STOP, GTK_STATE_PRELIGHT },
171 { IDR_STOP_P, GTK_STOCK_STOP, GTK_STATE_ACTIVE },
172 };
173
174 // The image resources that will be tinted by the 'button' tint value.
175 const int kOtherToolbarButtonIDs[] = {
176 IDR_TOOLBAR_BEZEL_HOVER,
177 IDR_TOOLBAR_BEZEL_PRESSED,
178 IDR_BROWSER_ACTION_H,
179 IDR_BROWSER_ACTION_P,
180 IDR_BROWSER_ACTIONS_OVERFLOW,
181 IDR_BROWSER_ACTIONS_OVERFLOW_H,
182 IDR_BROWSER_ACTIONS_OVERFLOW_P,
183 IDR_THROBBER,
184 IDR_THROBBER_WAITING,
185 IDR_THROBBER_LIGHT,
186
187 // TODO(erg): The dropdown arrow should be tinted because we're injecting
188 // various background GTK colors, but the code that accesses them needs to be
189 // modified so that they ask their ui::ThemeProvider instead of the
190 // ResourceBundle. (i.e. in a light on dark theme, the dropdown arrow will be
191 // dark on dark)
192 IDR_MENU_DROPARROW
193 };
194
IsOverridableImage(int id)195 bool IsOverridableImage(int id) {
196 CR_DEFINE_STATIC_LOCAL(std::set<int>, images, ());
197 if (images.empty()) {
198 images.insert(kThemeImages, kThemeImages + arraysize(kThemeImages));
199 images.insert(kAutocompleteImages,
200 kAutocompleteImages + arraysize(kAutocompleteImages));
201
202 for (unsigned int i = 0; i < arraysize(kGtkIcons); ++i)
203 images.insert(kGtkIcons[i].idr);
204
205 images.insert(kOtherToolbarButtonIDs,
206 kOtherToolbarButtonIDs + arraysize(kOtherToolbarButtonIDs));
207 }
208
209 return images.count(id) > 0;
210 }
211
212 // Picks a button tint from a set of background colors. While
213 // |accent_gdk_color| will usually be the same color through a theme, this
214 // function will get called with the normal GtkLabel |text_color|/GtkWindow
215 // |background_color| pair and the GtkEntry |text_color|/|background_color|
216 // pair. While 3/4 of the time the resulting tint will be the same, themes that
217 // have a dark window background (with light text) and a light text entry (with
218 // dark text) will get better icons with this separated out.
PickButtonTintFromColors(const GdkColor & accent_gdk_color,const GdkColor & text_color,const GdkColor & background_color,color_utils::HSL * tint)219 void PickButtonTintFromColors(const GdkColor& accent_gdk_color,
220 const GdkColor& text_color,
221 const GdkColor& background_color,
222 color_utils::HSL* tint) {
223 SkColor accent_color = libgtk2ui::GdkColorToSkColor(accent_gdk_color);
224 color_utils::HSL accent_tint;
225 color_utils::SkColorToHSL(accent_color, &accent_tint);
226
227 color_utils::HSL text_tint;
228 color_utils::SkColorToHSL(libgtk2ui::GdkColorToSkColor(text_color),
229 &text_tint);
230
231 color_utils::HSL background_tint;
232 color_utils::SkColorToHSL(libgtk2ui::GdkColorToSkColor(background_color),
233 &background_tint);
234
235 // If the accent color is gray, then our normal HSL tomfoolery will bring out
236 // whatever color is oddly dominant (for example, in rgb space [125, 128,
237 // 125] will tint green instead of gray). Slight differences (+/-10 (4%) to
238 // all color components) should be interpreted as this color being gray and
239 // we should switch into a special grayscale mode.
240 int rb_diff = abs(SkColorGetR(accent_color) - SkColorGetB(accent_color));
241 int rg_diff = abs(SkColorGetR(accent_color) - SkColorGetG(accent_color));
242 int bg_diff = abs(SkColorGetB(accent_color) - SkColorGetG(accent_color));
243 if (rb_diff < 10 && rg_diff < 10 && bg_diff < 10) {
244 // Our accent is white/gray/black. Only the luminance of the accent color
245 // matters.
246 tint->h = -1;
247
248 // Use the saturation of the text.
249 tint->s = text_tint.s;
250
251 // Use the luminance of the accent color UNLESS there isn't enough
252 // luminance contrast between the accent color and the base color.
253 if (fabs(accent_tint.l - background_tint.l) > 0.3)
254 tint->l = accent_tint.l;
255 else
256 tint->l = text_tint.l;
257 } else {
258 // Our accent is a color.
259 tint->h = accent_tint.h;
260
261 // Don't modify the saturation; the amount of color doesn't matter.
262 tint->s = -1;
263
264 // If the text wants us to darken the icon, don't change the luminance (the
265 // icons are already dark enough). Otherwise, lighten the icon by no more
266 // than 0.9 since we don't want a pure-white icon even if the text is pure
267 // white.
268 if (text_tint.l < 0.5)
269 tint->l = -1;
270 else if (text_tint.l <= 0.9)
271 tint->l = text_tint.l;
272 else
273 tint->l = 0.9;
274 }
275 }
276
277 // Applies an HSL shift to a GdkColor (instead of an SkColor)
GdkColorHSLShift(const color_utils::HSL & shift,GdkColor * frame_color)278 void GdkColorHSLShift(const color_utils::HSL& shift, GdkColor* frame_color) {
279 SkColor shifted = color_utils::HSLShift(
280 libgtk2ui::GdkColorToSkColor(*frame_color), shift);
281
282 frame_color->pixel = 0;
283 frame_color->red = SkColorGetR(shifted) * kSkiaToGDKMultiplier;
284 frame_color->green = SkColorGetG(shifted) * kSkiaToGDKMultiplier;
285 frame_color->blue = SkColorGetB(shifted) * kSkiaToGDKMultiplier;
286 }
287
288 // Copied Default blah sections from ThemeService.
GetDefaultTint(int id)289 color_utils::HSL GetDefaultTint(int id) {
290 switch (id) {
291 case ThemeProperties::TINT_FRAME:
292 return kDefaultTintFrame;
293 case ThemeProperties::TINT_FRAME_INACTIVE:
294 return kDefaultTintFrameInactive;
295 case ThemeProperties::TINT_FRAME_INCOGNITO:
296 return kDefaultTintFrameIncognito;
297 case ThemeProperties::TINT_FRAME_INCOGNITO_INACTIVE:
298 return kDefaultTintFrameIncognitoInactive;
299 case ThemeProperties::TINT_BUTTONS:
300 return kDefaultTintButtons;
301 case ThemeProperties::TINT_BACKGROUND_TAB:
302 return kDefaultTintBackgroundTab;
303 default:
304 color_utils::HSL result = {-1, -1, -1};
305 return result;
306 }
307 }
308
309 } // namespace
310
311 namespace libgtk2ui {
312
Gtk2UI()313 Gtk2UI::Gtk2UI() : use_gtk_(false) {
314 GtkInitFromCommandLine(*CommandLine::ForCurrentProcess());
315 }
316
Initialize()317 void Gtk2UI::Initialize() {
318 // Create our fake widgets.
319 fake_window_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
320 fake_frame_ = chrome_gtk_frame_new();
321 fake_label_.Own(gtk_label_new(""));
322 fake_entry_.Own(gtk_entry_new());
323
324 // Only realized widgets receive style-set notifications, which we need to
325 // broadcast new theme images and colors. Only realized widgets have style
326 // properties, too, which we query for some colors.
327 gtk_widget_realize(fake_frame_);
328 gtk_widget_realize(fake_window_);
329 // TODO: Also listen for "style-set" on the fake frame.
330
331 // TODO(erg): Be lazy about generating this data and connect it to the
332 // style-set signal handler.
333 LoadGtkValues();
334 SetXDGIconTheme();
335
336 #if defined(USE_GCONF)
337 // We must build this after GTK gets initialized.
338 titlebar_listener_.reset(new GConfTitlebarListener(this));
339 #endif // defined(USE_GCONF)
340
341 indicators_count = 0;
342 }
343
~Gtk2UI()344 Gtk2UI::~Gtk2UI() {
345 gtk_widget_destroy(fake_window_);
346 gtk_widget_destroy(fake_frame_);
347 fake_label_.Destroy();
348 fake_entry_.Destroy();
349
350 ClearAllThemeData();
351 }
352
GetThemeImageNamed(int id) const353 gfx::Image Gtk2UI::GetThemeImageNamed(int id) const {
354 // Try to get our cached version:
355 ImageCache::const_iterator it = gtk_images_.find(id);
356 if (it != gtk_images_.end())
357 return it->second;
358
359 if (/*use_gtk_ && */ IsOverridableImage(id)) {
360 gfx::Image image = gfx::Image(
361 gfx::ImageSkia::CreateFrom1xBitmap(GenerateGtkThemeBitmap(id)));
362 gtk_images_[id] = image;
363 return image;
364 }
365
366 return gfx::Image();
367 }
368
GetColor(int id,SkColor * color) const369 bool Gtk2UI::GetColor(int id, SkColor* color) const {
370 ColorMap::const_iterator it = colors_.find(id);
371 if (it != colors_.end()) {
372 *color = it->second;
373 return true;
374 }
375
376 return false;
377 }
378
HasCustomImage(int id) const379 bool Gtk2UI::HasCustomImage(int id) const {
380 return IsOverridableImage(id);
381 }
382
GetFocusRingColor() const383 SkColor Gtk2UI::GetFocusRingColor() const {
384 return focus_ring_color_;
385 }
386
GetThumbActiveColor() const387 SkColor Gtk2UI::GetThumbActiveColor() const {
388 return thumb_active_color_;
389 }
390
GetThumbInactiveColor() const391 SkColor Gtk2UI::GetThumbInactiveColor() const {
392 return thumb_inactive_color_;
393 }
394
GetTrackColor() const395 SkColor Gtk2UI::GetTrackColor() const {
396 return track_color_;
397 }
398
GetActiveSelectionBgColor() const399 SkColor Gtk2UI::GetActiveSelectionBgColor() const {
400 return active_selection_bg_color_;
401 }
402
GetActiveSelectionFgColor() const403 SkColor Gtk2UI::GetActiveSelectionFgColor() const {
404 return active_selection_fg_color_;
405 }
406
GetInactiveSelectionBgColor() const407 SkColor Gtk2UI::GetInactiveSelectionBgColor() const {
408 return inactive_selection_bg_color_;
409 }
410
GetInactiveSelectionFgColor() const411 SkColor Gtk2UI::GetInactiveSelectionFgColor() const {
412 return inactive_selection_fg_color_;
413 }
414
GetCursorBlinkInterval() const415 double Gtk2UI::GetCursorBlinkInterval() const {
416 // From http://library.gnome.org/devel/gtk/unstable/GtkSettings.html, this is
417 // the default value for gtk-cursor-blink-time.
418 static const gint kGtkDefaultCursorBlinkTime = 1200;
419
420 // Dividing GTK's cursor blink cycle time (in milliseconds) by this value
421 // yields an appropriate value for
422 // content::RendererPreferences::caret_blink_interval. This matches the
423 // logic in the WebKit GTK port.
424 static const double kGtkCursorBlinkCycleFactor = 2000.0;
425
426 gint cursor_blink_time = kGtkDefaultCursorBlinkTime;
427 gboolean cursor_blink = TRUE;
428 g_object_get(gtk_settings_get_default(),
429 "gtk-cursor-blink-time", &cursor_blink_time,
430 "gtk-cursor-blink", &cursor_blink,
431 NULL);
432 return cursor_blink ? (cursor_blink_time / kGtkCursorBlinkCycleFactor) : 0.0;
433 }
434
GetNativeTheme() const435 ui::NativeTheme* Gtk2UI::GetNativeTheme() const {
436 return use_gtk_ ? NativeThemeGtk2::instance() :
437 ui::NativeTheme::instance();
438 }
439
SetUseSystemTheme(bool use_system_theme)440 void Gtk2UI::SetUseSystemTheme(bool use_system_theme) {
441 use_gtk_ = use_system_theme;
442 }
443
GetDefaultUsesSystemTheme() const444 bool Gtk2UI::GetDefaultUsesSystemTheme() const {
445 scoped_ptr<base::Environment> env(base::Environment::Create());
446
447 switch (base::nix::GetDesktopEnvironment(env.get())) {
448 case base::nix::DESKTOP_ENVIRONMENT_GNOME:
449 case base::nix::DESKTOP_ENVIRONMENT_UNITY:
450 case base::nix::DESKTOP_ENVIRONMENT_XFCE:
451 return true;
452 case base::nix::DESKTOP_ENVIRONMENT_KDE3:
453 case base::nix::DESKTOP_ENVIRONMENT_KDE4:
454 case base::nix::DESKTOP_ENVIRONMENT_OTHER:
455 return false;
456 }
457 // Unless GetDesktopEnvironment() badly misbehaves, this should never happen.
458 NOTREACHED();
459 return false;
460 }
461
SetDownloadCount(int count) const462 void Gtk2UI::SetDownloadCount(int count) const {
463 if (unity::IsRunning())
464 unity::SetDownloadCount(count);
465 }
466
SetProgressFraction(float percentage) const467 void Gtk2UI::SetProgressFraction(float percentage) const {
468 if (unity::IsRunning())
469 unity::SetProgressFraction(percentage);
470 }
471
IsStatusIconSupported() const472 bool Gtk2UI::IsStatusIconSupported() const {
473 return AppIndicatorIcon::CouldOpen();
474 }
475
CreateLinuxStatusIcon(const gfx::ImageSkia & image,const base::string16 & tool_tip) const476 scoped_ptr<views::StatusIconLinux> Gtk2UI::CreateLinuxStatusIcon(
477 const gfx::ImageSkia& image,
478 const base::string16& tool_tip) const {
479 if (AppIndicatorIcon::CouldOpen()) {
480 ++indicators_count;
481 return scoped_ptr<views::StatusIconLinux>(new AppIndicatorIcon(
482 base::StringPrintf("%s%d", kAppIndicatorIdPrefix, indicators_count),
483 image,
484 tool_tip));
485 } else {
486 return scoped_ptr<views::StatusIconLinux>();
487 }
488 }
489
GetIconForContentType(const std::string & content_type,int size) const490 gfx::Image Gtk2UI::GetIconForContentType(
491 const std::string& content_type,
492 int size) const {
493 // This call doesn't take a reference.
494 GtkIconTheme* theme = gtk_icon_theme_get_default();
495
496 ScopedGIcon icon(g_content_type_get_icon(content_type.c_str()));
497 ScopedGtkIconInfo icon_info(
498 gtk_icon_theme_lookup_by_gicon(
499 theme, icon.get(), size,
500 static_cast<GtkIconLookupFlags>(GTK_ICON_LOOKUP_FORCE_SIZE)));
501 if (!icon_info)
502 return gfx::Image();
503 ScopedGdkPixbuf pixbuf(gtk_icon_info_load_icon(icon_info.get(), NULL));
504 if (!pixbuf)
505 return gfx::Image();
506
507 SkBitmap bitmap = GdkPixbufToImageSkia(pixbuf.get());
508 DCHECK_EQ(size, bitmap.width());
509 DCHECK_EQ(size, bitmap.height());
510 gfx::ImageSkia image_skia = gfx::ImageSkia::CreateFrom1xBitmap(bitmap);
511 image_skia.MakeThreadSafe();
512 return gfx::Image(image_skia);
513 }
514
AddWindowButtonOrderObserver(views::WindowButtonOrderObserver * observer)515 void Gtk2UI::AddWindowButtonOrderObserver(
516 views::WindowButtonOrderObserver* observer) {
517 if (!leading_buttons_.empty() || !trailing_buttons_.empty()) {
518 observer->OnWindowButtonOrderingChange(leading_buttons_,
519 trailing_buttons_);
520 }
521
522 observer_list_.AddObserver(observer);
523 }
524
RemoveWindowButtonOrderObserver(views::WindowButtonOrderObserver * observer)525 void Gtk2UI::RemoveWindowButtonOrderObserver(
526 views::WindowButtonOrderObserver* observer) {
527 observer_list_.RemoveObserver(observer);
528 }
529
SetWindowButtonOrdering(const std::vector<views::FrameButton> & leading_buttons,const std::vector<views::FrameButton> & trailing_buttons)530 void Gtk2UI::SetWindowButtonOrdering(
531 const std::vector<views::FrameButton>& leading_buttons,
532 const std::vector<views::FrameButton>& trailing_buttons) {
533 leading_buttons_ = leading_buttons;
534 trailing_buttons_ = trailing_buttons;
535
536 FOR_EACH_OBSERVER(views::WindowButtonOrderObserver, observer_list_,
537 OnWindowButtonOrderingChange(leading_buttons_,
538 trailing_buttons_));
539 }
540
CreateInputMethodContext(ui::LinuxInputMethodContextDelegate * delegate) const541 scoped_ptr<ui::LinuxInputMethodContext> Gtk2UI::CreateInputMethodContext(
542 ui::LinuxInputMethodContextDelegate* delegate) const {
543 return scoped_ptr<ui::LinuxInputMethodContext>(
544 new X11InputMethodContextImplGtk2(delegate));
545 }
546
CreateSelectFileDialog(ui::SelectFileDialog::Listener * listener,ui::SelectFilePolicy * policy) const547 ui::SelectFileDialog* Gtk2UI::CreateSelectFileDialog(
548 ui::SelectFileDialog::Listener* listener,
549 ui::SelectFilePolicy* policy) const {
550 return SelectFileDialogImpl::Create(listener, policy);
551 }
552
UnityIsRunning()553 bool Gtk2UI::UnityIsRunning() {
554 return unity::IsRunning();
555 }
556
GetScrollbarColors(GdkColor * thumb_active_color,GdkColor * thumb_inactive_color,GdkColor * track_color)557 void Gtk2UI::GetScrollbarColors(GdkColor* thumb_active_color,
558 GdkColor* thumb_inactive_color,
559 GdkColor* track_color) {
560 const GdkColor* theme_thumb_active = NULL;
561 const GdkColor* theme_thumb_inactive = NULL;
562 const GdkColor* theme_trough_color = NULL;
563 gtk_widget_style_get(GTK_WIDGET(fake_frame_),
564 "scrollbar-slider-prelight-color", &theme_thumb_active,
565 "scrollbar-slider-normal-color", &theme_thumb_inactive,
566 "scrollbar-trough-color", &theme_trough_color,
567 NULL);
568
569 // Ask the theme if the theme specifies all the scrollbar colors and short
570 // circuit the expensive painting/compositing if we have all of them.
571 if (theme_thumb_active && theme_thumb_inactive && theme_trough_color) {
572 *thumb_active_color = *theme_thumb_active;
573 *thumb_inactive_color = *theme_thumb_inactive;
574 *track_color = *theme_trough_color;
575 return;
576 }
577
578 // Create window containing scrollbar elements
579 GtkWidget* window = gtk_window_new(GTK_WINDOW_POPUP);
580 GtkWidget* fixed = gtk_fixed_new();
581 GtkWidget* scrollbar = gtk_hscrollbar_new(NULL);
582 gtk_container_add(GTK_CONTAINER(window), fixed);
583 gtk_container_add(GTK_CONTAINER(fixed), scrollbar);
584 gtk_widget_realize(window);
585 gtk_widget_realize(scrollbar);
586
587 // Draw scrollbar thumb part and track into offscreen image
588 const int kWidth = 100;
589 const int kHeight = 20;
590 GtkStyle* style = gtk_rc_get_style(scrollbar);
591 GdkWindow* gdk_window = gtk_widget_get_window(window);
592 GdkPixmap* pm = gdk_pixmap_new(gdk_window, kWidth, kHeight, -1);
593 GdkRectangle rect = { 0, 0, kWidth, kHeight };
594 unsigned char data[3 * kWidth * kHeight];
595 for (int i = 0; i < 3; ++i) {
596 if (i < 2) {
597 // Thumb part
598 gtk_paint_slider(style, pm,
599 i == 0 ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL,
600 GTK_SHADOW_OUT, &rect, scrollbar, "slider", 0, 0,
601 kWidth, kHeight, GTK_ORIENTATION_HORIZONTAL);
602 } else {
603 // Track
604 gtk_paint_box(style, pm, GTK_STATE_ACTIVE, GTK_SHADOW_IN, &rect,
605 scrollbar, "trough-upper", 0, 0, kWidth, kHeight);
606 }
607 GdkPixbuf* pb = gdk_pixbuf_new_from_data(data, GDK_COLORSPACE_RGB,
608 FALSE, 8, kWidth, kHeight,
609 3 * kWidth, 0, 0);
610 gdk_pixbuf_get_from_drawable(pb, pm, NULL, 0, 0, 0, 0, kWidth, kHeight);
611
612 // Sample pixels
613 int components[3] = { 0 };
614 for (int y = 2; y < kHeight - 2; ++y) {
615 for (int c = 0; c < 3; ++c) {
616 // Sample a vertical slice of pixels at about one-thirds from the
617 // left edge. This allows us to avoid any fixed graphics that might be
618 // located at the edges or in the center of the scrollbar.
619 // Each pixel is made up of a red, green, and blue component; taking up
620 // a total of three bytes.
621 components[c] += data[3 * (kWidth / 3 + y * kWidth) + c];
622 }
623 }
624 GdkColor* color = i == 0 ? thumb_active_color :
625 i == 1 ? thumb_inactive_color :
626 track_color;
627 color->pixel = 0;
628 // We sampled pixels across the full height of the image, ignoring a two
629 // pixel border. In some themes, the border has a completely different
630 // color which we do not want to factor into our average color computation.
631 //
632 // We now need to scale the colors from the 0..255 range, to the wider
633 // 0..65535 range, and we need to actually compute the average color; so,
634 // we divide by the total number of pixels in the sample.
635 color->red = components[0] * 65535 / (255 * (kHeight - 4));
636 color->green = components[1] * 65535 / (255 * (kHeight - 4));
637 color->blue = components[2] * 65535 / (255 * (kHeight - 4));
638
639 g_object_unref(pb);
640 }
641 g_object_unref(pm);
642
643 gtk_widget_destroy(window);
644
645 // Override any of the default colors with ones that were specified by the
646 // theme.
647 if (theme_thumb_active)
648 *thumb_active_color = *theme_thumb_active;
649
650 if (theme_thumb_inactive)
651 *thumb_inactive_color = *theme_thumb_inactive;
652
653 if (theme_trough_color)
654 *track_color = *theme_trough_color;
655 }
656
SetXDGIconTheme()657 void Gtk2UI::SetXDGIconTheme() {
658 gchar* gtk_theme_name;
659 g_object_get(gtk_settings_get_default(),
660 "gtk-icon-theme-name",
661 >k_theme_name, NULL);
662 base::nix::SetIconThemeName(gtk_theme_name);
663 g_free(gtk_theme_name);
664 }
665
LoadGtkValues()666 void Gtk2UI::LoadGtkValues() {
667 // TODO(erg): GtkThemeService had a comment here about having to muck with
668 // the raw Prefs object to remove prefs::kCurrentThemeImages or else we'd
669 // regress startup time. Figure out how to do that when we can't access the
670 // prefs system from here.
671
672 GtkStyle* frame_style = gtk_rc_get_style(fake_frame_);
673
674 GtkStyle* window_style = gtk_rc_get_style(fake_window_);
675 SetThemeColorFromGtk(ThemeProperties::COLOR_CONTROL_BACKGROUND,
676 &window_style->bg[GTK_STATE_NORMAL]);
677
678 GdkColor toolbar_color = window_style->bg[GTK_STATE_NORMAL];
679 SetThemeColorFromGtk(ThemeProperties::COLOR_TOOLBAR, &toolbar_color);
680
681 GdkColor button_color = window_style->bg[GTK_STATE_SELECTED];
682 SetThemeTintFromGtk(ThemeProperties::TINT_BUTTONS, &button_color);
683
684 GtkStyle* label_style = gtk_rc_get_style(fake_label_.get());
685 GdkColor label_color = label_style->fg[GTK_STATE_NORMAL];
686 SetThemeColorFromGtk(ThemeProperties::COLOR_TAB_TEXT, &label_color);
687 SetThemeColorFromGtk(ThemeProperties::COLOR_BOOKMARK_TEXT, &label_color);
688 SetThemeColorFromGtk(ThemeProperties::COLOR_STATUS_BAR_TEXT, &label_color);
689
690 // Build the various icon tints.
691 GetNormalButtonTintHSL(&button_tint_);
692 GetNormalEntryForegroundHSL(&entry_tint_);
693 GetSelectedEntryForegroundHSL(&selected_entry_tint_);
694 GdkColor frame_color = BuildFrameColors(frame_style);
695
696 // The inactive frame color never occurs naturally in the theme, as it is a
697 // tinted version of |frame_color|. We generate another color based on the
698 // background tab color, with the lightness and saturation moved in the
699 // opposite direction. (We don't touch the hue, since there should be subtle
700 // hints of the color in the text.)
701 color_utils::HSL inactive_tab_text_hsl =
702 tints_[ThemeProperties::TINT_BACKGROUND_TAB];
703 if (inactive_tab_text_hsl.l < 0.5)
704 inactive_tab_text_hsl.l = kDarkInactiveLuminance;
705 else
706 inactive_tab_text_hsl.l = kLightInactiveLuminance;
707
708 if (inactive_tab_text_hsl.s < 0.5)
709 inactive_tab_text_hsl.s = kHeavyInactiveSaturation;
710 else
711 inactive_tab_text_hsl.s = kLightInactiveSaturation;
712
713 colors_[ThemeProperties::COLOR_BACKGROUND_TAB_TEXT] =
714 color_utils::HSLToSkColor(inactive_tab_text_hsl, 255);
715
716 // We pick the text and background colors for the NTP out of the colors for a
717 // GtkEntry. We do this because GtkEntries background color is never the same
718 // as |toolbar_color|, is usually a white, and when it isn't a white,
719 // provides sufficient contrast to |toolbar_color|. Try this out with
720 // Darklooks, HighContrastInverse or ThinIce.
721 GtkStyle* entry_style = gtk_rc_get_style(fake_entry_.get());
722 GdkColor ntp_background = entry_style->base[GTK_STATE_NORMAL];
723 GdkColor ntp_foreground = entry_style->text[GTK_STATE_NORMAL];
724 SetThemeColorFromGtk(ThemeProperties::COLOR_NTP_BACKGROUND,
725 &ntp_background);
726 SetThemeColorFromGtk(ThemeProperties::COLOR_NTP_TEXT,
727 &ntp_foreground);
728
729 // The NTP header is the color that surrounds the current active thumbnail on
730 // the NTP, and acts as the border of the "Recent Links" box. It would be
731 // awesome if they were separated so we could use GetBorderColor() for the
732 // border around the "Recent Links" section, but matching the frame color is
733 // more important.
734 SetThemeColorFromGtk(ThemeProperties::COLOR_NTP_HEADER,
735 &frame_color);
736 SetThemeColorFromGtk(ThemeProperties::COLOR_NTP_SECTION,
737 &toolbar_color);
738 SetThemeColorFromGtk(ThemeProperties::COLOR_NTP_SECTION_TEXT,
739 &label_color);
740
741 // Override the link color if the theme provides it.
742 const GdkColor* link_color = NULL;
743 gtk_widget_style_get(GTK_WIDGET(fake_window_),
744 "link-color", &link_color, NULL);
745
746 bool is_default_link_color = false;
747 if (!link_color) {
748 link_color = &kDefaultLinkColor;
749 is_default_link_color = true;
750 }
751
752 SetThemeColorFromGtk(ThemeProperties::COLOR_NTP_LINK,
753 link_color);
754 SetThemeColorFromGtk(ThemeProperties::COLOR_NTP_LINK_UNDERLINE,
755 link_color);
756 SetThemeColorFromGtk(ThemeProperties::COLOR_NTP_SECTION_LINK,
757 link_color);
758 SetThemeColorFromGtk(ThemeProperties::COLOR_NTP_SECTION_LINK_UNDERLINE,
759 link_color);
760
761 if (!is_default_link_color)
762 gdk_color_free(const_cast<GdkColor*>(link_color));
763
764 // Generate the colors that we pass to WebKit.
765 focus_ring_color_ = GdkColorToSkColor(frame_color);
766
767 GdkColor thumb_active_color, thumb_inactive_color, track_color;
768 Gtk2UI::GetScrollbarColors(&thumb_active_color,
769 &thumb_inactive_color,
770 &track_color);
771 thumb_active_color_ = GdkColorToSkColor(thumb_active_color);
772 thumb_inactive_color_ = GdkColorToSkColor(thumb_inactive_color);
773 track_color_ = GdkColorToSkColor(track_color);
774
775 // Some GTK themes only define the text selection colors on the GtkEntry
776 // class, so we need to use that for getting selection colors.
777 active_selection_bg_color_ =
778 GdkColorToSkColor(entry_style->base[GTK_STATE_SELECTED]);
779 active_selection_fg_color_ =
780 GdkColorToSkColor(entry_style->text[GTK_STATE_SELECTED]);
781 inactive_selection_bg_color_ =
782 GdkColorToSkColor(entry_style->base[GTK_STATE_ACTIVE]);
783 inactive_selection_fg_color_ =
784 GdkColorToSkColor(entry_style->text[GTK_STATE_ACTIVE]);
785 }
786
BuildFrameColors(GtkStyle * frame_style)787 GdkColor Gtk2UI::BuildFrameColors(GtkStyle* frame_style) {
788 GdkColor* theme_frame = NULL;
789 GdkColor* theme_inactive_frame = NULL;
790 GdkColor* theme_incognito_frame = NULL;
791 GdkColor* theme_incognito_inactive_frame = NULL;
792 gtk_widget_style_get(GTK_WIDGET(fake_frame_),
793 "frame-color", &theme_frame,
794 "inactive-frame-color", &theme_inactive_frame,
795 "incognito-frame-color", &theme_incognito_frame,
796 "incognito-inactive-frame-color",
797 &theme_incognito_inactive_frame,
798 NULL);
799
800 GdkColor frame_color = BuildAndSetFrameColor(
801 &frame_style->bg[GTK_STATE_SELECTED],
802 theme_frame,
803 kDefaultFrameShift,
804 ThemeProperties::COLOR_FRAME,
805 ThemeProperties::TINT_FRAME);
806 if (theme_frame)
807 gdk_color_free(theme_frame);
808 SetThemeTintFromGtk(ThemeProperties::TINT_BACKGROUND_TAB, &frame_color);
809
810 BuildAndSetFrameColor(
811 &frame_style->bg[GTK_STATE_INSENSITIVE],
812 theme_inactive_frame,
813 kDefaultFrameShift,
814 ThemeProperties::COLOR_FRAME_INACTIVE,
815 ThemeProperties::TINT_FRAME_INACTIVE);
816 if (theme_inactive_frame)
817 gdk_color_free(theme_inactive_frame);
818
819 BuildAndSetFrameColor(
820 &frame_color,
821 theme_incognito_frame,
822 GetDefaultTint(ThemeProperties::TINT_FRAME_INCOGNITO),
823 ThemeProperties::COLOR_FRAME_INCOGNITO,
824 ThemeProperties::TINT_FRAME_INCOGNITO);
825 if (theme_incognito_frame)
826 gdk_color_free(theme_incognito_frame);
827
828 BuildAndSetFrameColor(
829 &frame_color,
830 theme_incognito_inactive_frame,
831 GetDefaultTint(ThemeProperties::TINT_FRAME_INCOGNITO_INACTIVE),
832 ThemeProperties::COLOR_FRAME_INCOGNITO_INACTIVE,
833 ThemeProperties::TINT_FRAME_INCOGNITO_INACTIVE);
834 if (theme_incognito_inactive_frame)
835 gdk_color_free(theme_incognito_inactive_frame);
836
837 return frame_color;
838 }
839
SetThemeColorFromGtk(int id,const GdkColor * color)840 void Gtk2UI::SetThemeColorFromGtk(int id, const GdkColor* color) {
841 colors_[id] = GdkColorToSkColor(*color);
842 }
843
SetThemeTintFromGtk(int id,const GdkColor * color)844 void Gtk2UI::SetThemeTintFromGtk(int id, const GdkColor* color) {
845 color_utils::HSL default_tint = GetDefaultTint(id);
846 color_utils::HSL hsl;
847 color_utils::SkColorToHSL(GdkColorToSkColor(*color), &hsl);
848
849 if (default_tint.s != -1)
850 hsl.s = default_tint.s;
851
852 if (default_tint.l != -1)
853 hsl.l = default_tint.l;
854
855 tints_[id] = hsl;
856 }
857
BuildAndSetFrameColor(const GdkColor * base,const GdkColor * gtk_base,const color_utils::HSL & tint,int color_id,int tint_id)858 GdkColor Gtk2UI::BuildAndSetFrameColor(const GdkColor* base,
859 const GdkColor* gtk_base,
860 const color_utils::HSL& tint,
861 int color_id,
862 int tint_id) {
863 GdkColor out_color = *base;
864 if (gtk_base) {
865 // The theme author specified a color to use, use it without modification.
866 out_color = *gtk_base;
867 } else {
868 // Tint the basic color since this is a heuristic color instead of one
869 // specified by the theme author.
870 GdkColorHSLShift(tint, &out_color);
871 }
872 SetThemeColorFromGtk(color_id, &out_color);
873 SetThemeTintFromGtk(tint_id, &out_color);
874
875 return out_color;
876 }
877
GenerateGtkThemeBitmap(int id) const878 SkBitmap Gtk2UI::GenerateGtkThemeBitmap(int id) const {
879 switch (id) {
880 case IDR_THEME_TOOLBAR: {
881 GtkStyle* style = gtk_rc_get_style(fake_window_);
882 GdkColor* color = &style->bg[GTK_STATE_NORMAL];
883 SkBitmap bitmap;
884 bitmap.setConfig(SkBitmap::kARGB_8888_Config,
885 kToolbarImageWidth, kToolbarImageHeight);
886 bitmap.allocPixels();
887 bitmap.eraseRGB(color->red >> 8, color->green >> 8, color->blue >> 8);
888 return bitmap;
889 }
890 case IDR_THEME_TAB_BACKGROUND:
891 return GenerateTabImage(IDR_THEME_FRAME);
892 case IDR_THEME_TAB_BACKGROUND_INCOGNITO:
893 return GenerateTabImage(IDR_THEME_FRAME_INCOGNITO);
894 case IDR_THEME_FRAME:
895 return GenerateFrameImage(ThemeProperties::COLOR_FRAME,
896 "frame-gradient-color");
897 case IDR_THEME_FRAME_INACTIVE:
898 return GenerateFrameImage(ThemeProperties::COLOR_FRAME_INACTIVE,
899 "inactive-frame-gradient-color");
900 case IDR_THEME_FRAME_INCOGNITO:
901 return GenerateFrameImage(ThemeProperties::COLOR_FRAME_INCOGNITO,
902 "incognito-frame-gradient-color");
903 case IDR_THEME_FRAME_INCOGNITO_INACTIVE: {
904 return GenerateFrameImage(
905 ThemeProperties::COLOR_FRAME_INCOGNITO_INACTIVE,
906 "incognito-inactive-frame-gradient-color");
907 }
908 // Icons that sit inside the omnibox shouldn't receive TINT_BUTTONS and
909 // instead should tint based on the foreground text entry color in GTK+
910 // mode because some themes that try to be dark *and* light have very
911 // different colors between the omnibox and the normal background area.
912 // TODO(erg): Decide what to do about other icons that appear in the
913 // omnibox, e.g. content settings icons.
914 case IDR_OMNIBOX_EXTENSION_APP:
915 case IDR_OMNIBOX_HTTP:
916 case IDR_OMNIBOX_SEARCH:
917 case IDR_OMNIBOX_STAR:
918 case IDR_OMNIBOX_TTS: {
919 return GenerateTintedIcon(id, entry_tint_);
920 }
921 // In GTK mode, the dark versions of the omnibox icons only ever appear in
922 // the autocomplete popup and only against the current theme's GtkEntry
923 // base[GTK_STATE_SELECTED] color, so tint the icons so they won't collide
924 // with the selected color.
925 case IDR_OMNIBOX_EXTENSION_APP_DARK:
926 case IDR_OMNIBOX_HTTP_DARK:
927 case IDR_OMNIBOX_SEARCH_DARK:
928 case IDR_OMNIBOX_STAR_DARK:
929 case IDR_OMNIBOX_TTS_DARK: {
930 return GenerateTintedIcon(id, selected_entry_tint_);
931 }
932 // In GTK mode, we need to manually render several icons.
933 case IDR_BACK:
934 case IDR_BACK_D:
935 case IDR_BACK_H:
936 case IDR_BACK_P:
937 case IDR_FORWARD:
938 case IDR_FORWARD_D:
939 case IDR_FORWARD_H:
940 case IDR_FORWARD_P:
941 case IDR_HOME:
942 case IDR_HOME_H:
943 case IDR_HOME_P:
944 case IDR_RELOAD:
945 case IDR_RELOAD_H:
946 case IDR_RELOAD_P:
947 case IDR_STOP:
948 case IDR_STOP_D:
949 case IDR_STOP_H:
950 case IDR_STOP_P: {
951 return GenerateGTKIcon(id);
952 }
953 case IDR_TOOLBAR_BEZEL_HOVER:
954 return GenerateToolbarBezel(GTK_STATE_PRELIGHT, IDR_TOOLBAR_BEZEL_HOVER);
955 case IDR_TOOLBAR_BEZEL_PRESSED:
956 return GenerateToolbarBezel(GTK_STATE_ACTIVE, IDR_TOOLBAR_BEZEL_PRESSED);
957 case IDR_BROWSER_ACTION_H:
958 return GenerateToolbarBezel(GTK_STATE_PRELIGHT, IDR_BROWSER_ACTION_H);
959 case IDR_BROWSER_ACTION_P:
960 return GenerateToolbarBezel(GTK_STATE_ACTIVE, IDR_BROWSER_ACTION_P);
961 default: {
962 return GenerateTintedIcon(id, button_tint_);
963 }
964 }
965
966 return SkBitmap();
967 }
968
GenerateFrameImage(int color_id,const char * gradient_name) const969 SkBitmap Gtk2UI::GenerateFrameImage(
970 int color_id,
971 const char* gradient_name) const {
972 // We use two colors: the main color (passed in) and a lightened version of
973 // that color (which is supposed to match the light gradient at the top of
974 // several GTK+ themes, such as Ambiance, Clearlooks or Bluebird).
975 ColorMap::const_iterator it = colors_.find(color_id);
976 DCHECK(it != colors_.end());
977 SkColor base = it->second;
978
979 gfx::Canvas canvas(gfx::Size(kToolbarImageWidth, kToolbarImageHeight),
980 1.0f, true);
981
982 int gradient_size;
983 GdkColor* gradient_top_color = NULL;
984 gtk_widget_style_get(GTK_WIDGET(fake_frame_),
985 "frame-gradient-size", &gradient_size,
986 gradient_name, &gradient_top_color,
987 NULL);
988 if (gradient_size) {
989 SkColor lighter = gradient_top_color ?
990 GdkColorToSkColor(*gradient_top_color) :
991 color_utils::HSLShift(base, kGtkFrameShift);
992 if (gradient_top_color)
993 gdk_color_free(gradient_top_color);
994 skia::RefPtr<SkShader> shader = gfx::CreateGradientShader(
995 0, gradient_size, lighter, base);
996 SkPaint paint;
997 paint.setStyle(SkPaint::kFill_Style);
998 paint.setAntiAlias(true);
999 paint.setShader(shader.get());
1000
1001 canvas.DrawRect(gfx::Rect(0, 0, kToolbarImageWidth, gradient_size), paint);
1002 }
1003
1004 canvas.FillRect(gfx::Rect(0, gradient_size, kToolbarImageWidth,
1005 kToolbarImageHeight - gradient_size), base);
1006 return canvas.ExtractImageRep().sk_bitmap();
1007 }
1008
GenerateTabImage(int base_id) const1009 SkBitmap Gtk2UI::GenerateTabImage(int base_id) const {
1010 const SkBitmap* base_image = GetThemeImageNamed(base_id).ToSkBitmap();
1011 SkBitmap bg_tint = SkBitmapOperations::CreateHSLShiftedBitmap(
1012 *base_image, GetDefaultTint(ThemeProperties::TINT_BACKGROUND_TAB));
1013 return SkBitmapOperations::CreateTiledBitmap(
1014 bg_tint, 0, 0, bg_tint.width(), bg_tint.height());
1015 }
1016
GenerateTintedIcon(int base_id,const color_utils::HSL & tint) const1017 SkBitmap Gtk2UI::GenerateTintedIcon(
1018 int base_id,
1019 const color_utils::HSL& tint) const {
1020 ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
1021 return SkBitmapOperations::CreateHSLShiftedBitmap(
1022 rb.GetImageNamed(base_id).AsBitmap(), tint);
1023 }
1024
GenerateGTKIcon(int base_id) const1025 SkBitmap Gtk2UI::GenerateGTKIcon(int base_id) const {
1026 const char* stock_id = NULL;
1027 GtkStateType gtk_state = GTK_STATE_NORMAL;
1028 for (unsigned int i = 0; i < arraysize(kGtkIcons); ++i) {
1029 if (kGtkIcons[i].idr == base_id) {
1030 stock_id = kGtkIcons[i].stock_id;
1031 gtk_state = kGtkIcons[i].gtk_state;
1032 break;
1033 }
1034 }
1035 DCHECK(stock_id);
1036
1037 ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
1038 SkBitmap default_bitmap = rb.GetImageNamed(base_id).AsBitmap();
1039
1040 gtk_widget_ensure_style(fake_frame_);
1041 GtkStyle* style = gtk_widget_get_style(fake_frame_);
1042 GtkIconSet* icon_set = gtk_style_lookup_icon_set(style, stock_id);
1043 if (!icon_set)
1044 return default_bitmap;
1045
1046 // Ask GTK to render the icon to a buffer, which we will steal from.
1047 GdkPixbuf* gdk_icon = gtk_icon_set_render_icon(
1048 icon_set,
1049 style,
1050 base::i18n::IsRTL() ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR,
1051 gtk_state,
1052 GTK_ICON_SIZE_SMALL_TOOLBAR,
1053 fake_frame_,
1054 NULL);
1055
1056 if (!gdk_icon) {
1057 // This can theoretically happen if an icon theme doesn't provide a
1058 // specific image. This should realistically never happen, but I bet there
1059 // are some theme authors who don't reliably provide all icons.
1060 return default_bitmap;
1061 }
1062
1063 SkBitmap retval;
1064 retval.setConfig(SkBitmap::kARGB_8888_Config,
1065 default_bitmap.width(),
1066 default_bitmap.height());
1067 retval.allocPixels();
1068 retval.eraseColor(0);
1069
1070 const SkBitmap icon = GdkPixbufToImageSkia(gdk_icon);
1071 g_object_unref(gdk_icon);
1072
1073 SkCanvas canvas(retval);
1074
1075 if (gtk_state == GTK_STATE_ACTIVE || gtk_state == GTK_STATE_PRELIGHT) {
1076 SkBitmap border = DrawGtkButtonBorder(gtk_state,
1077 default_bitmap.width(),
1078 default_bitmap.height());
1079 canvas.drawBitmap(border, 0, 0);
1080 }
1081
1082 canvas.drawBitmap(icon,
1083 (default_bitmap.width() / 2) - (icon.width() / 2),
1084 (default_bitmap.height() / 2) - (icon.height() / 2));
1085
1086 return retval;
1087 }
1088
GenerateToolbarBezel(int gtk_state,int sizing_idr) const1089 SkBitmap Gtk2UI::GenerateToolbarBezel(int gtk_state, int sizing_idr) const {
1090 ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
1091 SkBitmap default_bitmap =
1092 rb.GetImageNamed(sizing_idr).AsBitmap();
1093
1094 SkBitmap retval;
1095 retval.setConfig(SkBitmap::kARGB_8888_Config,
1096 default_bitmap.width(),
1097 default_bitmap.height());
1098 retval.allocPixels();
1099 retval.eraseColor(0);
1100
1101 SkCanvas canvas(retval);
1102 SkBitmap border = DrawGtkButtonBorder(
1103 gtk_state,
1104 default_bitmap.width(),
1105 default_bitmap.height());
1106 canvas.drawBitmap(border, 0, 0);
1107
1108 return retval;
1109 }
1110
GetNormalButtonTintHSL(color_utils::HSL * tint) const1111 void Gtk2UI::GetNormalButtonTintHSL(color_utils::HSL* tint) const {
1112 GtkStyle* window_style = gtk_rc_get_style(fake_window_);
1113 const GdkColor accent_gdk_color = window_style->bg[GTK_STATE_SELECTED];
1114 const GdkColor base_color = window_style->base[GTK_STATE_NORMAL];
1115
1116 GtkStyle* label_style = gtk_rc_get_style(fake_label_.get());
1117 const GdkColor text_color = label_style->fg[GTK_STATE_NORMAL];
1118
1119 PickButtonTintFromColors(accent_gdk_color, text_color, base_color, tint);
1120 }
1121
GetNormalEntryForegroundHSL(color_utils::HSL * tint) const1122 void Gtk2UI::GetNormalEntryForegroundHSL(color_utils::HSL* tint) const {
1123 GtkStyle* window_style = gtk_rc_get_style(fake_window_);
1124 const GdkColor accent_gdk_color = window_style->bg[GTK_STATE_SELECTED];
1125
1126 GtkStyle* style = gtk_rc_get_style(fake_entry_.get());
1127 const GdkColor text_color = style->text[GTK_STATE_NORMAL];
1128 const GdkColor base_color = style->base[GTK_STATE_NORMAL];
1129
1130 PickButtonTintFromColors(accent_gdk_color, text_color, base_color, tint);
1131 }
1132
GetSelectedEntryForegroundHSL(color_utils::HSL * tint) const1133 void Gtk2UI::GetSelectedEntryForegroundHSL(color_utils::HSL* tint) const {
1134 // The simplest of all the tints. We just use the selected text in the entry
1135 // since the icons tinted this way will only be displayed against
1136 // base[GTK_STATE_SELECTED].
1137 GtkStyle* style = gtk_rc_get_style(fake_entry_.get());
1138 const GdkColor color = style->text[GTK_STATE_SELECTED];
1139 color_utils::SkColorToHSL(GdkColorToSkColor(color), tint);
1140 }
1141
DrawGtkButtonBorder(int gtk_state,int width,int height) const1142 SkBitmap Gtk2UI::DrawGtkButtonBorder(int gtk_state,
1143 int width, int height) const {
1144 // Create a temporary GTK button to snapshot
1145 GtkWidget* window = gtk_offscreen_window_new();
1146 GtkWidget* button = gtk_button_new();
1147 gtk_widget_set_size_request(button, width, height);
1148 gtk_container_add(GTK_CONTAINER(window), button);
1149 gtk_widget_realize(window);
1150 gtk_widget_realize(button);
1151 gtk_widget_show(button);
1152 gtk_widget_show(window);
1153
1154 gtk_widget_set_state(button, static_cast<GtkStateType>(gtk_state));
1155
1156 GdkPixmap* pixmap = gtk_widget_get_snapshot(button, NULL);
1157 int w, h;
1158 gdk_drawable_get_size(GDK_DRAWABLE(pixmap), &w, &h);
1159 DCHECK_EQ(w, width);
1160 DCHECK_EQ(h, height);
1161
1162 // We render the Pixmap to a Pixbuf. This can be slow, as we're scrapping
1163 // bits from X.
1164 GdkColormap* colormap = gdk_drawable_get_colormap(pixmap);
1165 GdkPixbuf* pixbuf = gdk_pixbuf_get_from_drawable(NULL,
1166 GDK_DRAWABLE(pixmap),
1167 colormap,
1168 0, 0, 0, 0, w, h);
1169
1170 // Finally, we convert our pixbuf into a type we can use.
1171 SkBitmap border = GdkPixbufToImageSkia(pixbuf);
1172 g_object_unref(pixbuf);
1173 g_object_unref(pixmap);
1174 gtk_widget_destroy(window);
1175
1176 return border;
1177 }
1178
ClearAllThemeData()1179 void Gtk2UI::ClearAllThemeData() {
1180 gtk_images_.clear();
1181 }
1182
1183 } // namespace libgtk2ui
1184
BuildGtk2UI()1185 views::LinuxUI* BuildGtk2UI() {
1186 return new libgtk2ui::Gtk2UI;
1187 }
1188