Home | History | Annotate | Download | only in gtk 
      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/speech/speech_recognition_bubble.h"
      6 
      7 #include "base/strings/utf_string_conversions.h"
      8 #include "chrome/browser/profiles/profile.h"
      9 #include "chrome/browser/ui/browser.h"
     10 #include "chrome/browser/ui/browser_finder.h"
     11 #include "chrome/browser/ui/gtk/browser_toolbar_gtk.h"
     12 #include "chrome/browser/ui/gtk/browser_window_gtk.h"
     13 #include "chrome/browser/ui/gtk/bubble/bubble_gtk.h"
     14 #include "chrome/browser/ui/gtk/gtk_chrome_link_button.h"
     15 #include "chrome/browser/ui/gtk/gtk_theme_service.h"
     16 #include "chrome/browser/ui/gtk/gtk_util.h"
     17 #include "chrome/browser/ui/gtk/location_bar_view_gtk.h"
     18 #include "content/public/browser/resource_context.h"
     19 #include "content/public/browser/speech_recognition_manager.h"
     20 #include "content/public/browser/web_contents.h"
     21 #include "content/public/browser/web_contents_view.h"
     22 #include "grit/generated_resources.h"
     23 #include "grit/theme_resources.h"
     24 #include "ui/base/gtk/gtk_hig_constants.h"
     25 #include "ui/base/gtk/owned_widget_gtk.h"
     26 #include "ui/base/l10n/l10n_util.h"
     27 #include "ui/base/resource/resource_bundle.h"
     28 #include "ui/gfx/gtk_util.h"
     29 #include "ui/gfx/rect.h"
     30 
     31 using content::WebContents;
     32 
     33 namespace {
     34 
     35 const int kBubbleControlVerticalSpacing = 5;
     36 const int kBubbleControlHorizontalSpacing = 20;
     37 const int kIconHorizontalPadding = 10;
     38 const int kButtonBarHorizontalSpacing = 10;
     39 
     40 // Use black for text labels since the bubble has white background.
     41 const GdkColor& kLabelTextColor = ui::kGdkBlack;
     42 
     43 // Implementation of SpeechRecognitionBubble for GTK. This shows a speech
     44 // recognition bubble on screen.
     45 class SpeechRecognitionBubbleGtk : public SpeechRecognitionBubbleBase,
     46                                    public BubbleDelegateGtk {
     47  public:
     48   SpeechRecognitionBubbleGtk(WebContents* web_contents,
     49                              Delegate* delegate,
     50                              const gfx::Rect& element_rect);
     51   virtual ~SpeechRecognitionBubbleGtk();
     52 
     53  private:
     54   // SpeechRecognitionBubbleBase:
     55   virtual void Show() OVERRIDE;
     56   virtual void Hide() OVERRIDE;
     57   virtual void UpdateLayout() OVERRIDE;
     58   virtual void UpdateImage() OVERRIDE;
     59 
     60   // BubbleDelegateGtk:
     61   virtual void BubbleClosing(BubbleGtk* bubble, bool closed_by_escape) OVERRIDE;
     62 
     63   CHROMEGTK_CALLBACK_0(SpeechRecognitionBubbleGtk, void, OnCancelClicked);
     64   CHROMEGTK_CALLBACK_0(SpeechRecognitionBubbleGtk, void, OnTryAgainClicked);
     65   CHROMEGTK_CALLBACK_0(SpeechRecognitionBubbleGtk, void, OnMicSettingsClicked);
     66 
     67   Delegate* delegate_;
     68   BubbleGtk* bubble_;
     69   gfx::Rect element_rect_;
     70   bool did_invoke_close_;
     71 
     72   GtkWidget* label_;
     73   GtkWidget* cancel_button_;
     74   GtkWidget* try_again_button_;
     75   GtkWidget* icon_;
     76   GtkWidget* icon_container_;
     77   GtkWidget* mic_settings_;
     78 
     79   DISALLOW_COPY_AND_ASSIGN(SpeechRecognitionBubbleGtk);
     80 };
     81 
     82 SpeechRecognitionBubbleGtk::SpeechRecognitionBubbleGtk(
     83     WebContents* web_contents, Delegate* delegate,
     84     const gfx::Rect& element_rect)
     85     : SpeechRecognitionBubbleBase(web_contents),
     86       delegate_(delegate),
     87       bubble_(NULL),
     88       element_rect_(element_rect),
     89       did_invoke_close_(false),
     90       label_(NULL),
     91       cancel_button_(NULL),
     92       try_again_button_(NULL),
     93       icon_(NULL),
     94       icon_container_(NULL),
     95       mic_settings_(NULL) {
     96 }
     97 
     98 SpeechRecognitionBubbleGtk::~SpeechRecognitionBubbleGtk() {
     99   // The |Close| call below invokes our |BubbleClosing| method. Since we were
    100   // destroyed by the caller we don't need to call them back, hence set this
    101   // flag here.
    102   did_invoke_close_ = true;
    103   Hide();
    104 }
    105 
    106 void SpeechRecognitionBubbleGtk::OnCancelClicked(GtkWidget* widget) {
    107   delegate_->InfoBubbleButtonClicked(BUTTON_CANCEL);
    108 }
    109 
    110 void SpeechRecognitionBubbleGtk::OnTryAgainClicked(GtkWidget* widget) {
    111   delegate_->InfoBubbleButtonClicked(BUTTON_TRY_AGAIN);
    112 }
    113 
    114 void SpeechRecognitionBubbleGtk::OnMicSettingsClicked(GtkWidget* widget) {
    115   content::SpeechRecognitionManager::GetInstance()->ShowAudioInputSettings();
    116   Hide();
    117 }
    118 
    119 void SpeechRecognitionBubbleGtk::Show() {
    120   if (bubble_)
    121     return;  // Nothing further to do since the bubble is already visible.
    122 
    123   // We use a vbox to arrange the controls (label, image, button bar) vertically
    124   // and the button bar is a hbox holding the 2 buttons (try again and cancel).
    125   // To get horizontal space around them we place this vbox with padding in a
    126   // GtkAlignment below.
    127   GtkWidget* vbox = gtk_vbox_new(FALSE, 0);
    128 
    129   // The icon with a some padding on the left and right.
    130   icon_container_ = gtk_alignment_new(0, 0, 0, 0);
    131   icon_ = gtk_image_new();
    132   gtk_container_add(GTK_CONTAINER(icon_container_), icon_);
    133   gtk_box_pack_start(GTK_BOX(vbox), icon_container_, FALSE, FALSE,
    134                      kBubbleControlVerticalSpacing);
    135 
    136   label_ = gtk_label_new(NULL);
    137   gtk_util::SetLabelColor(label_, &kLabelTextColor);
    138   gtk_box_pack_start(GTK_BOX(vbox), label_, FALSE, FALSE,
    139                      kBubbleControlVerticalSpacing);
    140 
    141   Profile* profile = Profile::FromBrowserContext(
    142       GetWebContents()->GetBrowserContext());
    143 
    144   // TODO(tommi): The audio_manager property can only be accessed from the
    145   // IO thread, so we can't call CanShowAudioInputSettings directly here if
    146   // we can show the input settings.  For now, we always show the link (like
    147   // we do on other platforms).
    148   if (true) {
    149     mic_settings_ = gtk_chrome_link_button_new(
    150         l10n_util::GetStringUTF8(IDS_SPEECH_INPUT_MIC_SETTINGS).c_str());
    151     gtk_box_pack_start(GTK_BOX(vbox), mic_settings_, FALSE, FALSE,
    152                        kBubbleControlVerticalSpacing);
    153     g_signal_connect(mic_settings_, "clicked",
    154                      G_CALLBACK(&OnMicSettingsClickedThunk), this);
    155   }
    156 
    157   GtkWidget* button_bar = gtk_hbox_new(FALSE, kButtonBarHorizontalSpacing);
    158   gtk_box_pack_start(GTK_BOX(vbox), button_bar, FALSE, FALSE,
    159                      kBubbleControlVerticalSpacing);
    160 
    161   cancel_button_ = gtk_button_new_with_label(
    162       l10n_util::GetStringUTF8(IDS_CANCEL).c_str());
    163   gtk_box_pack_start(GTK_BOX(button_bar), cancel_button_, TRUE, FALSE, 0);
    164   g_signal_connect(cancel_button_, "clicked",
    165                    G_CALLBACK(&OnCancelClickedThunk), this);
    166 
    167   try_again_button_ = gtk_button_new_with_label(
    168       l10n_util::GetStringUTF8(IDS_SPEECH_INPUT_TRY_AGAIN).c_str());
    169   gtk_box_pack_start(GTK_BOX(button_bar), try_again_button_, TRUE, FALSE, 0);
    170   g_signal_connect(try_again_button_, "clicked",
    171                    G_CALLBACK(&OnTryAgainClickedThunk), this);
    172 
    173   GtkWidget* content = gtk_alignment_new(0, 0, 0, 0);
    174   gtk_alignment_set_padding(GTK_ALIGNMENT(content),
    175       kBubbleControlVerticalSpacing, kBubbleControlVerticalSpacing,
    176       kBubbleControlHorizontalSpacing, kBubbleControlHorizontalSpacing);
    177   gtk_container_add(GTK_CONTAINER(content), vbox);
    178 
    179   GtkThemeService* theme_provider = GtkThemeService::GetFrom(profile);
    180   GtkWidget* reference_widget = GetWebContents()->GetView()->GetNativeView();
    181   gfx::Rect container_rect;
    182   GetWebContents()->GetView()->GetContainerBounds(&container_rect);
    183   gfx::Rect target_rect(element_rect_.right() - kBubbleTargetOffsetX,
    184       element_rect_.bottom(), 1, 1);
    185 
    186   if (target_rect.x() < 0 || target_rect.y() < 0 ||
    187       target_rect.x() > container_rect.width() ||
    188       target_rect.y() > container_rect.height()) {
    189     // Target is not in screen view, so point to wrench.
    190     Browser* browser = chrome::FindBrowserWithWebContents(GetWebContents());
    191     BrowserWindowGtk* browser_window =
    192         BrowserWindowGtk::GetBrowserWindowForNativeWindow(
    193             browser->window()->GetNativeWindow());
    194     reference_widget = browser_window->GetToolbar()->GetLocationBarView()
    195         ->location_icon_widget();
    196     target_rect = gtk_util::WidgetBounds(reference_widget);
    197   }
    198   bubble_ = BubbleGtk::Show(reference_widget,
    199                             &target_rect,
    200                             content,
    201                             BubbleGtk::ANCHOR_TOP_LEFT,
    202                             BubbleGtk::POPUP_WINDOW | BubbleGtk::GRAB_INPUT,
    203                             theme_provider,
    204                             this);
    205 
    206   UpdateLayout();
    207 }
    208 
    209 void SpeechRecognitionBubbleGtk::Hide() {
    210   if (bubble_)
    211     bubble_->Close();
    212 }
    213 
    214 void SpeechRecognitionBubbleGtk::UpdateLayout() {
    215   if (!bubble_)
    216     return;
    217 
    218   if (display_mode() == DISPLAY_MODE_MESSAGE) {
    219     // Message text and the Try Again + Cancel buttons are visible, hide the
    220     // icon.
    221     gtk_label_set_text(GTK_LABEL(label_),
    222                        UTF16ToUTF8(message_text()).c_str());
    223     gtk_widget_show(label_);
    224     gtk_widget_show(try_again_button_);
    225     if (mic_settings_)
    226       gtk_widget_show(mic_settings_);
    227     gtk_widget_hide(icon_);
    228   } else {
    229     // Heading text, icon and cancel button are visible, hide the Try Again
    230     // button.
    231     gtk_label_set_text(GTK_LABEL(label_),
    232         l10n_util::GetStringUTF8(IDS_SPEECH_INPUT_BUBBLE_HEADING).c_str());
    233     if (display_mode() == DISPLAY_MODE_RECORDING) {
    234       gtk_widget_show(label_);
    235     } else {
    236       gtk_widget_hide(label_);
    237     }
    238     UpdateImage();
    239     gtk_widget_show(icon_);
    240     gtk_widget_hide(try_again_button_);
    241     if (mic_settings_)
    242       gtk_widget_hide(mic_settings_);
    243     if (display_mode() == DISPLAY_MODE_WARM_UP) {
    244       gtk_widget_hide(cancel_button_);
    245 
    246       // The text label and cancel button are hidden in this mode, but we want
    247       // the popup to appear the same size as it would once recording starts,
    248       // so as to reduce UI jank when recording starts. So we calculate the
    249       // difference in size between the two sets of controls and add that as
    250       // padding around the icon here.
    251       GtkRequisition cancel_size;
    252       gtk_widget_get_child_requisition(cancel_button_, &cancel_size);
    253       GtkRequisition label_size;
    254       gtk_widget_get_child_requisition(label_, &label_size);
    255       gfx::ImageSkia* volume = ResourceBundle::GetSharedInstance().
    256           GetImageSkiaNamed(IDR_SPEECH_INPUT_MIC_EMPTY);
    257       int desired_width = std::max(volume->width(), cancel_size.width) +
    258                           kIconHorizontalPadding * 2;
    259       int desired_height = volume->height() + label_size.height +
    260                            cancel_size.height +
    261                            kBubbleControlVerticalSpacing * 2;
    262       int diff_width = desired_width - icon_image().width();
    263       int diff_height = desired_height - icon_image().height();
    264       gtk_alignment_set_padding(GTK_ALIGNMENT(icon_container_),
    265                                 diff_height / 2, diff_height - diff_height / 2,
    266                                 diff_width / 2, diff_width - diff_width / 2);
    267     } else {
    268       // Reset the padding done above.
    269       gtk_alignment_set_padding(GTK_ALIGNMENT(icon_container_), 0, 0,
    270                                 kIconHorizontalPadding, kIconHorizontalPadding);
    271       gtk_widget_show(cancel_button_);
    272     }
    273   }
    274 }
    275 
    276 void SpeechRecognitionBubbleGtk::UpdateImage() {
    277   gfx::ImageSkia image = icon_image();
    278   if (image.isNull() || !bubble_)
    279     return;
    280 
    281   GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(*image.bitmap());
    282   gtk_image_set_from_pixbuf(GTK_IMAGE(icon_), pixbuf);
    283   g_object_unref(pixbuf);
    284 }
    285 
    286 void SpeechRecognitionBubbleGtk::BubbleClosing(BubbleGtk* bubble,
    287                                                bool closed_by_escape) {
    288   bubble_ = NULL;
    289   if (!did_invoke_close_)
    290     delegate_->InfoBubbleFocusChanged();
    291 }
    292 
    293 }  // namespace
    294 
    295 SpeechRecognitionBubble* SpeechRecognitionBubble::CreateNativeBubble(
    296     WebContents* web_contents,
    297     Delegate* delegate,
    298     const gfx::Rect& element_rect) {
    299   return new SpeechRecognitionBubbleGtk(web_contents, delegate, element_rect);
    300 }
    301