[WebIntents, Gtk] "Waiting for Suggestion" dialog

chrome/browser/ui/gtk/web_intent_picker_gtk.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/gtk/web_intent_picker_gtk.h"
 
 #include <algorithm>
 
 #include "base/i18n/rtl.h"
 #include "base/utf_string_conversions.h"
@@ skipping 119 matching lines @@
         ui::ResourceBundle::RTL_ENABLED).ToGdkPixbuf();
     gtk_box_pack_start(GTK_BOX(hbox), gtk_image_new_from_pixbuf(star),
                        FALSE, FALSE, 0);
   }
 
   return hbox;
 }
 
 } // namespace
 
+// Create a new Widget for the "waiting for CWS" display.
+
+class WaitingDialog {
+ public:
+  explicit WaitingDialog(GtkThemeService* theme_service);
+  ~WaitingDialog();
+
+  GtkWidget* widget() const { return widget_.get(); }
+ private:
+  // Initialize the widget.
+  void Init();
+
+  // The actual GtkWidget
+  ui::OwnedWidgetGtk widget_;
+
+  // Waiting throbber.
+  scoped_ptr<ThrobberGtk> throbber_;
+
+  // Weak pointer to theme service.
+  GtkThemeService* theme_service_;
+};
+
+WaitingDialog::WaitingDialog(GtkThemeService* theme_service)
+    : theme_service_(theme_service) {
+  DCHECK(theme_service_);
+  Init();
+}
+
+WaitingDialog::~WaitingDialog() {
+  widget_.Destroy();
+}
+
+void WaitingDialog::Init() {
+  widget_.Own(gtk_hbox_new(FALSE, 0));
+  GtkWidget* hbox = widget_.get();
+
+  // Add the message text.
+  GtkWidget* message_label = theme_service_->BuildLabel(
+      l10n_util::GetStringUTF8(IDS_INTENT_PICKER_NO_SERVICES).c_str(),
+      ui::kGdkBlack);
+  gtk_label_set_line_wrap(GTK_LABEL(message_label), TRUE);
+  gtk_misc_set_alignment(GTK_MISC(message_label), 0, 0);
+  // Set the label width to the size of the main content width minus borders.
+  gtk_util::SetLabelWidth(message_label,
+                          kMainContentWidth - 2 * ui::kContentAreaBorder);
+  gtk_box_pack_start(GTK_BOX(hbox), message_label, TRUE, TRUE, 0);
+
+  // Create throbber
+  throbber_.reset(new ThrobberGtk(theme_service_));
+  gtk_box_pack_start(GTK_BOX(hbox), throbber_->widget(), TRUE, TRUE, 0);
+
+  // TODO(groby): use large spinner.
+  // IDR_SPEECH_INPUT_SPINNER
+  // Animate throbber
+  throbber_->Start();
+}
 // static
 WebIntentPicker* WebIntentPicker::Create(TabContents* tab_contents,
                                          WebIntentPickerDelegate* delegate,
                                          WebIntentPickerModel* model) {
   return new WebIntentPickerGtk(tab_contents, delegate, model);
 }
 
 WebIntentPickerGtk::WebIntentPickerGtk(TabContents* tab_contents,
                                        WebIntentPickerDelegate* delegate,
                                        WebIntentPickerModel* model)
@@ skipping 26 matching lines @@
 }
 
 void WebIntentPickerGtk::Close() {
   window_->CloseConstrainedWindow();
   if (inline_disposition_tab_contents_.get())
     inline_disposition_tab_contents_->web_contents()->OnCloseStarted();
 }
 
 void WebIntentPickerGtk::SetActionString(const string16& action) {
   header_label_text_ = action;
-  gtk_label_set_text(GTK_LABEL(header_label_), UTF16ToUTF8(action).c_str());
+  if (header_label_)
+    gtk_label_set_text(GTK_LABEL(header_label_), UTF16ToUTF8(action).c_str());
 }
 
 void WebIntentPickerGtk::OnExtensionInstallSuccess(const std::string& id) {
   RemoveThrobber();
 }
 
 void WebIntentPickerGtk::OnExtensionInstallFailure(const std::string& id) {
   // The throbber has an alignment as its parent, so it must be used instead of
   // the throbber to find the extension row.
   size_t index =
       GetExtensionWidgetRow(gtk_widget_get_parent(throbber_->widget()));
   GList* vbox_list =
       gtk_container_get_children(GTK_CONTAINER(extensions_vbox_));
   GtkWidget* hbox = static_cast<GtkWidget*>(g_list_nth_data(vbox_list, index));
 
   RemoveThrobber();
   gtk_widget_show_all(hbox);
   g_list_free(vbox_list);
   SetWidgetsEnabled(true);
 }
 
 void WebIntentPickerGtk::OnModelChanged(WebIntentPickerModel* model) {
+  if (waiting_dialog_.get() && !model->IsWaitingForSuggestions()) {
+    waiting_dialog_.reset();
+    InitMainContents();
+  }
   UpdateInstalledServices();
   UpdateCWSLabel();
   UpdateSuggestedExtensions();
+  SetActionString(header_label_text_);
 }
 
 void WebIntentPickerGtk::OnFaviconChanged(WebIntentPickerModel* model,
                                           size_t index) {
   UpdateInstalledServices();
 }
 
 void WebIntentPickerGtk::OnExtensionIconChanged(WebIntentPickerModel* model,
                                                 const string16& extension_id) {
   UpdateSuggestedExtensions();
@@ skipping 103 matching lines @@
 
   // Replace the picker contents with dialog box.
   gtk_util::RemoveAllChildren(contents_);
 
   GtkWidget* sub_contents = CreateSubContents(contents_);
 
   AddCloseButton(contents_);
   AddTitle(sub_contents);
 
   // Replace the dialog header.
+  DCHECK(header_label_);
   gtk_label_set_text(
       GTK_LABEL(header_label_),
       l10n_util::GetStringUTF8(IDS_INTENT_PICKER_NO_SERVICES_TITLE).c_str());
 
   // Add the message text.
   GtkWidget* hbox = gtk_hbox_new(FALSE, 0);
   gtk_box_pack_start(GTK_BOX(sub_contents), hbox, TRUE, TRUE, 0);
   GtkThemeService* theme_service = GetThemeService(tab_contents_);
   GtkWidget* no_service_label = theme_service->BuildLabel(
       l10n_util::GetStringUTF8(IDS_INTENT_PICKER_NO_SERVICES).c_str(),
@@ skipping 24 matching lines @@
 }
 
 bool WebIntentPickerGtk::ShouldHaveBorderPadding() const {
   return false;
 }
 
 void WebIntentPickerGtk::Observe(int type,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
   DCHECK_EQ(type, chrome::NOTIFICATION_BROWSER_THEME_CHANGED);
-  GtkThemeService* theme_service = GetThemeService(tab_contents_);
-  if (theme_service->UsingNativeTheme())
-    gtk_util::UndoForceFontSize(header_label_);
-  else
-    gtk_util::ForceFontSizePixels(header_label_, kHeaderLabelPixelSize);
-
+  if (header_label_) {
+    GtkThemeService* theme_service = GetThemeService(tab_contents_);
+    if (theme_service->UsingNativeTheme())
+      gtk_util::UndoForceFontSize(header_label_);
+    else
+      gtk_util::ForceFontSizePixels(header_label_, kHeaderLabelPixelSize);
+  }
   UpdateInstalledServices();
   UpdateSuggestedExtensions();
 }
 
 void WebIntentPickerGtk::OnDestroy(GtkWidget* button) {
   // Destroy this object when the contents widget is destroyed. It can't be
   // "delete this" because this function happens in a callback.
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   model_->set_observer(NULL);
   window_ = NULL;
@@ skipping 68 matching lines @@
   GtkThemeService* theme_service = GetThemeService(tab_contents_);
 
   // Main contents vbox.
   if (!contents_) {
     contents_ = gtk_vbox_new(FALSE, 0);
     g_signal_connect(contents_, "destroy", G_CALLBACK(&OnDestroyThunk), this);
   }
 
   gtk_widget_set_size_request(contents_, kMainContentWidth, -1);
 
+  if (model_ && model_->IsWaitingForSuggestions()) {
+    gtk_util::RemoveAllChildren(contents_);
+    AddCloseButton(contents_);
+    waiting_dialog_.reset(new WaitingDialog(theme_service));
+    gtk_box_pack_start(GTK_BOX(contents_), waiting_dialog_->widget(),
+                       TRUE, TRUE, 0);
+  } else {
+    InitMainContents();
+  }
+}
+
+void WebIntentPickerGtk::InitMainContents() {
+  GtkThemeService* theme_service = GetThemeService(tab_contents_);
+
+  gtk_util::RemoveAllChildren(contents_);
+
   AddCloseButton(contents_);
   GtkWidget* sub_contents = CreateSubContents(contents_);
+
   AddTitle(sub_contents);
 
   // Add separation between the installed services list and the app suggestions.
   GtkWidget* button_alignment = gtk_alignment_new(0.5, 0, 0, 0);
   gtk_alignment_set_padding(GTK_ALIGNMENT(button_alignment), 0,
                             kMainContentPixelSize * 2, 0, 0);
 
   // Vbox containing all service buttons.
   button_vbox_ = gtk_vbox_new(FALSE, ui::kControlSpacing);
   gtk_container_add(GTK_CONTAINER(button_alignment), button_vbox_);
@@ skipping 34 matching lines @@
       GTK_CHROME_LINK_BUTTON(more_suggestions_link)->label,
       kMainContentPixelSize);
   g_signal_connect(more_suggestions_link, "clicked",
                    G_CALLBACK(OnMoreSuggestionsLinkClickThunk), this);
 
   GtkWidget* indent_link = gtk_util::IndentWidget(link_alignment);
   gtk_box_pack_start(GTK_BOX(sub_contents), indent_link, TRUE, TRUE, 0);
 
   // Throbber, which will be added to the hierarchy when necessary.
   throbber_.reset(new ThrobberGtk(theme_service));
+
+  gtk_widget_show_all(contents_);
 }
 
 void WebIntentPickerGtk::ResetContents() {
   // Wipe out all currently displayed widgets.
   gtk_util::RemoveAllChildren(contents_);
 
   // Reset potential inline disposition data.
   inline_disposition_delegate_.reset(NULL);
   tab_contents_container_.reset(NULL);
   inline_disposition_tab_contents_.reset(NULL);
 
   // Re-initialize picker widgets and data.
-  InitContents();
+  InitMainContents();
   UpdateInstalledServices();
   UpdateCWSLabel();
   UpdateSuggestedExtensions();
   SetActionString(header_label_text_);
 
   gtk_widget_show_all(contents_);
 }
 
 GtkWidget* WebIntentPickerGtk::CreateSubContents(GtkWidget* box) {
   GtkWidget* alignment = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
@@ skipping 29 matching lines @@
 
   // Label text will be set in the call to SetActionString().
   header_label_ = GetThemeService(tab_contents_)->BuildLabel(
       std::string(), ui::kGdkBlack);
   gtk_util::ForceFontSizePixels(header_label_, kHeaderLabelPixelSize);
   gtk_box_pack_start(GTK_BOX(header_hbox), header_label_, TRUE, TRUE, 0);
   gtk_misc_set_alignment(GTK_MISC(header_label_), 0, 0);
 }
 
 void WebIntentPickerGtk::UpdateInstalledServices() {
+  if (!button_vbox_)
+    return;
+
   gtk_util::RemoveAllChildren(button_vbox_);
 
   if (model_->GetInstalledServiceCount() == 0) {
     gtk_widget_hide(gtk_widget_get_parent(button_vbox_));
     return;
   }
 
   for (size_t i = 0; i < model_->GetInstalledServiceCount(); ++i) {
     const WebIntentPickerModel::InstalledService& installed_service =
         model_->GetInstalledServiceAt(i);
@@ skipping 13 matching lines @@
     // Must be called after SetServiceButtonImage as the internal label widget
     // is replaced in that call.
     SetWidgetFontSize(button, kMainContentPixelSize);
   }
 
   gtk_widget_show_all(button_vbox_);
   gtk_widget_show(gtk_widget_get_parent(button_vbox_));
 }
 
 void WebIntentPickerGtk::UpdateCWSLabel() {
+  if (!button_vbox_)
+    return;
+
   gtk_widget_set_visible(gtk_widget_get_parent(button_vbox_),
                          model_->GetInstalledServiceCount() != 0);
 
   std::string label_text = UTF16ToUTF8(model_->GetSuggestionsLinkText());
   gtk_label_set_text(GTK_LABEL(cws_label_), label_text.c_str());
   gtk_widget_set_visible(cws_label_, !label_text.empty());
 }
 
 void WebIntentPickerGtk::UpdateSuggestedExtensions() {
+  if (!extensions_vbox_)
+    return;
+
   GtkThemeService* theme_service = GetThemeService(tab_contents_);
 
   gtk_util::RemoveAllChildren(extensions_vbox_);
 
   if (model_->GetSuggestedExtensionCount() == 0) {
     gtk_widget_hide(gtk_widget_get_parent(extensions_vbox_));
     return;
   }
 
   gtk_widget_show(gtk_widget_get_parent(extensions_vbox_));
@@ skipping 37 matching lines @@
                      G_CALLBACK(OnExtensionInstallButtonClickThunk), this);
     gtk_box_pack_end(GTK_BOX(hbox), install_button, FALSE, FALSE, 0);
   }
 
   gtk_widget_show_all(extensions_vbox_);
   gtk_widget_show(gtk_widget_get_parent(extensions_vbox_));
 }
 
 void WebIntentPickerGtk::SetWidgetsEnabled(bool enabled) {
   gboolean data = enabled;
-  gtk_container_foreach(GTK_CONTAINER(button_vbox_), EnableWidgetCallback,
-                        &data);
-  gtk_container_foreach(GTK_CONTAINER(extensions_vbox_), EnableWidgetCallback,
-                        &data);
+  if (button_vbox_)
+    gtk_container_foreach(GTK_CONTAINER(button_vbox_), EnableWidgetCallback,
+                          &data);
+  if (extensions_vbox_)
+    gtk_container_foreach(GTK_CONTAINER(extensions_vbox_), EnableWidgetCallback,
+                          &data);
 }
 
 GtkWidget* WebIntentPickerGtk::AddThrobberToExtensionAt(size_t index) {
   // The throbber should be unparented.
   DCHECK(!gtk_widget_get_parent(throbber_->widget()));
   GList* vbox_list =
       gtk_container_get_children(GTK_CONTAINER(extensions_vbox_));
   GtkWidget* hbox = static_cast<GtkWidget*>(g_list_nth_data(vbox_list, index));
   GtkWidget* alignment = gtk_alignment_new(0.5, 0.5, 0, 0);
   gtk_container_add(GTK_CONTAINER(alignment), throbber_->widget());
   gtk_box_pack_end(GTK_BOX(hbox), alignment, FALSE, FALSE, 0);
   g_list_free(vbox_list);
   throbber_->Start();
   return alignment;
 }
 
 void WebIntentPickerGtk::RemoveThrobber() {
   GtkWidget* alignment = gtk_widget_get_parent(throbber_->widget());
   DCHECK(alignment);
   gtk_container_remove(GTK_CONTAINER(alignment), throbber_->widget());
   gtk_widget_destroy(alignment);
   throbber_->Stop();
 }