Host process i18n and Linux implementation.

remoting/host/disconnect_window_linux.cc

 // Copyright (c) 2011 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 "remoting/host/disconnect_window.h"
 
 #include <gtk/gtk.h>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "remoting/host/chromoting_host.h"
+#include "remoting/host/ui_strings.h"
 #include "ui/base/gtk/gtk_signal.h"
 
+namespace {
+// The width in pixels at which the message will wrap. Given that the message
+// contains an un-splittable email address, it's unlikely that a fixed width
+// is going to look aesthetically pleasing in all languages.
+// TODO(jamiewalch): Replace this with a layout that only uses a single line,
+// and which is docked at the top or bottom of the host screen, as in our
+// UI mocks.
+const int kMessageWidth = 300;
+}
+
 namespace remoting {
 
 class DisconnectWindowLinux : public DisconnectWindow {
  public:
   DisconnectWindowLinux();
   virtual ~DisconnectWindowLinux();
 
   virtual void Show(ChromotingHost* host,
                     const std::string& username) OVERRIDE;
   virtual void Hide() OVERRIDE;
 
  private:
   CHROMEGTK_CALLBACK_1(DisconnectWindowLinux, void, OnResponse, int);
 
-  void CreateWindow();
+  void CreateWindow(UiStrings* ui_strings);
 
   ChromotingHost* host_;
   GtkWidget* disconnect_window_;
-  GtkWidget* user_label_;
+  GtkWidget* message_;
 
   DISALLOW_COPY_AND_ASSIGN(DisconnectWindowLinux);
 };
 
 DisconnectWindowLinux::DisconnectWindowLinux()
     : host_(NULL),
       disconnect_window_(NULL) {
 }
 
 DisconnectWindowLinux::~DisconnectWindowLinux() {
 }
 
-void DisconnectWindowLinux::CreateWindow() {
+void DisconnectWindowLinux::CreateWindow(UiStrings* ui_strings) {
   if (disconnect_window_) return;
 
-  std::string disconnect_button(kDisconnectButton);
-  disconnect_button += kDisconnectKeysLinux;
+  std::string buttonLabel = ui_strings->disconnectButtonText + " (" +

[Sergey Ulanov, 2011/08/13 01:11:36]

Whole string must be localizible, and not some parts of it. In some languages it
may be necessary to use some symbols different from parentheses, etc. A better
solution would be to have disconnectButtonText set to something like "Disconnect
(%s)" and then substitute the shortcut here. Or just localize the whole string

[Jamie, 2011/08/13 01:34:03]

Unfortunately on Windows we need to remove the shortcut if we fail to register
it, so it has to be separate. Would it be better to have the parentheses
included in the localizable string?

[Sergey Ulanov, 2011/08/13 01:37:26]

Then I think the right solution in this case is to have two strings, one with
shortcut and one without.

[Jamie, 2011/08/13 02:20:15]

Done.

+      ui_strings->disconnectButtonShortcut + ")";
+
   disconnect_window_ = gtk_dialog_new_with_buttons(
-      kTitle,
+      ui_strings->productName.c_str(),
       NULL,
       GTK_DIALOG_NO_SEPARATOR,
-      disconnect_button.c_str(), GTK_RESPONSE_OK,
+      buttonLabel.c_str(), GTK_RESPONSE_OK,
       NULL);
 
   GtkWindow* window = GTK_WINDOW(disconnect_window_);
   gtk_window_set_resizable(window, FALSE);
   // Try to keep the window always visible.
   gtk_window_stick(window);
   gtk_window_set_keep_above(window, TRUE);
   // Utility windows have no minimize button or taskbar presence.
   gtk_window_set_type_hint(window, GDK_WINDOW_TYPE_HINT_UTILITY);
   gtk_window_set_deletable(window, FALSE);
 
   g_signal_connect(disconnect_window_, "response",
                    G_CALLBACK(OnResponseThunk), this);
 
   GtkWidget* content_area =
       gtk_dialog_get_content_area(GTK_DIALOG(disconnect_window_));
 
-  GtkWidget* username_row = gtk_hbox_new(FALSE, 0);
+  GtkWidget* message_row = gtk_hbox_new(FALSE, 0);
   // TODO(lambroslambrou): Replace the magic number with an appropriate
   // constant from a header file (such as chrome/browser/ui/gtk/gtk_util.h
   // but check_deps disallows its #inclusion here).
-  gtk_container_set_border_width(GTK_CONTAINER(username_row), 12);
-  gtk_container_add(GTK_CONTAINER(content_area), username_row);
+  gtk_container_set_border_width(GTK_CONTAINER(message_row), 12);
+  gtk_container_add(GTK_CONTAINER(content_area), message_row);
 
-  GtkWidget* share_label = gtk_label_new(kSharingWith);
-  gtk_container_add(GTK_CONTAINER(username_row), share_label);
-
-  user_label_ = gtk_label_new(NULL);
-  gtk_container_add(GTK_CONTAINER(username_row), user_label_);
+  message_ = gtk_label_new(NULL);
+  gtk_widget_set_size_request(message_, kMessageWidth, -1);
+  gtk_label_set_line_wrap(GTK_LABEL(message_), true);
+  gtk_container_add(GTK_CONTAINER(message_row), message_);
 
   gtk_widget_show_all(content_area);
 }
 
 void DisconnectWindowLinux::Show(ChromotingHost* host,
-                                 const std::string& username) {
+                                 const std::string& /* unused */) {
   host_ = host;
-  CreateWindow();
-  gtk_label_set_text(GTK_LABEL(user_label_), username.c_str());
+  CreateWindow(host->ui_strings());
+  gtk_label_set_text(GTK_LABEL(message_),
+                     host->ui_strings()->disconnectMessage.c_str());
   gtk_window_present(GTK_WINDOW(disconnect_window_));
 }
 
 void DisconnectWindowLinux::Hide() {
   if (disconnect_window_) {
     gtk_widget_destroy(disconnect_window_);
     disconnect_window_ = NULL;
   }
 }
 
 void DisconnectWindowLinux::OnResponse(GtkWidget* dialog, int response_id) {
   // |response_id| is ignored, because there is only one button, and pressing
   // it should have the same effect as closing the window (if the window Close
   // button were visible).
   CHECK(host_);
 
   host_->Shutdown(NULL);
   Hide();
 }
 
 DisconnectWindow* DisconnectWindow::Create() {
   return new DisconnectWindowLinux;
 }
 
 }  // namespace remoting