[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() {
+  const int kDialogSpacing = 30;
+
+  widget_.Own(gtk_vbox_new(FALSE, 0));
+  GtkWidget* vbox = widget_.get();
+
+  // Create throbber
+  ThrobberGtk* throbber = new ThrobberGtk(theme_service_);
+  GtkWidget* throbber_alignment = gtk_alignment_new(0.5, 0.5, 0, 0);
+  gtk_alignment_set_padding(GTK_ALIGNMENT(throbber_alignment), kDialogSpacing,
+                            kMainContentPixelSize, 0, 0);
+  gtk_container_add(GTK_CONTAINER(throbber_alignment), throbber->widget());
+  gtk_box_pack_start(GTK_BOX(vbox), throbber_alignment, TRUE, TRUE, 0);
+
+  // Add the message text.
+  GtkWidget* message_label = theme_service_->BuildLabel(
+      l10n_util::GetStringUTF8(IDS_INTENT_PICKER_WAIT_FOR_CWS).c_str(),
+      ui::kGdkBlack);
+
+  GtkWidget* label_alignment = gtk_alignment_new(0.5, 0.5, 0, 0);
+  gtk_alignment_set_padding(GTK_ALIGNMENT(label_alignment),
+                            kMainContentPixelSize, kDialogSpacing, 0, 0);
+  gtk_container_add(GTK_CONTAINER(label_alignment), message_label);
+  gtk_box_pack_start(GTK_BOX(vbox), label_alignment, TRUE, TRUE, 0);
+
+  // TODO(groby): use IDR_SPEECH_INPUT_SPINNER. Pending fix for ThrobberGtk.
+  // 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() {

[Greg Billock, 2012/08/10 18:46:57]

What's the difference between InitContents and InitMainContents? How about
InitWaitContents() if IsWaitingForSuggestions?

Also, we're showing this if we can't load the DB? I don't think we should do
full contents replacement just if the CWS can't load and there are other
options. That is, it seems like there should be some more checks to see whether
the model has non-CWS stuff.

[groby-ooo-7-16, 2012/08/10 18:57:27]

InitContents: Just initializes contents_

It currently creates the waiting dialog since this means pickers _with_ the wait
dialog (Gtk) and _without_ (Views, Cocoa) have an identical API and can be
driven by the same controller. More refactoring to come on that ;)

InitMainContents: The "meat" of the picker dialog. Titles, buttons, inline dispo
surface, etc. Will be further split up into selection dialog and inline dispo.

On 2012/08/10 18:46:57, Greg Billock wrote:

+  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();
 }