Localized Chromoting Host on Mac and Linux.

remoting/host/disconnect_window_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 <gtk/gtk.h>
 #include <math.h>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "remoting/base/string_resources.h"
 #include "remoting/host/client_session_control.h"
 #include "remoting/host/host_window.h"
-#include "remoting/host/ui_strings.h"
 #include "ui/base/gtk/gtk_signal.h"
+#include "ui/base/l10n/l10n_util.h"
 
 namespace remoting {
 
 namespace {
 
 class DisconnectWindowGtk : public HostWindow {
  public:
-  explicit DisconnectWindowGtk(const UiStrings& ui_strings);
+  DisconnectWindowGtk();
   virtual ~DisconnectWindowGtk();
 
   // HostWindow overrides.
   virtual void Start(
       const base::WeakPtr<ClientSessionControl>& client_session_control)
       OVERRIDE;
 
  private:
   CHROMEGTK_CALLBACK_1(DisconnectWindowGtk, gboolean, OnDelete, GdkEvent*);
   CHROMEGTK_CALLBACK_0(DisconnectWindowGtk, void, OnClicked);
   CHROMEGTK_CALLBACK_1(DisconnectWindowGtk, gboolean, OnConfigure,
                        GdkEventConfigure*);
   CHROMEGTK_CALLBACK_1(DisconnectWindowGtk, gboolean, OnButtonPress,
                        GdkEventButton*);
 
   // Used to disconnect the client session.
   base::WeakPtr<ClientSessionControl> client_session_control_;
 
-  // Localized UI strings.
-  UiStrings ui_strings_;
-
   GtkWidget* disconnect_window_;
   GtkWidget* message_;
   GtkWidget* button_;
 
   // Used to distinguish resize events from other types of "configure-event"
   // notifications.
   int current_width_;
   int current_height_;
 
   DISALLOW_COPY_AND_ASSIGN(DisconnectWindowGtk);
 };
 
 // Helper function for creating a rectangular path with rounded corners, as
 // Cairo doesn't have this facility.  |radius| is the arc-radius of each
 // corner.  The bounding rectangle extends from (0, 0) to (width, height).
 void AddRoundRectPath(cairo_t* cairo_context, int width, int height,
                       int radius) {
   cairo_new_sub_path(cairo_context);
   cairo_arc(cairo_context, width - radius, radius, radius, -M_PI_2, 0);
   cairo_arc(cairo_context, width - radius, height - radius, radius, 0, M_PI_2);
   cairo_arc(cairo_context, radius, height - radius, radius, M_PI_2, 2 * M_PI_2);
   cairo_arc(cairo_context, radius, radius, radius, 2 * M_PI_2, 3 * M_PI_2);
   cairo_close_path(cairo_context);
 }
 
-DisconnectWindowGtk::DisconnectWindowGtk(const UiStrings& ui_strings)
-    : ui_strings_(ui_strings),
-      disconnect_window_(NULL),
+DisconnectWindowGtk::DisconnectWindowGtk()
+    : disconnect_window_(NULL),
       current_width_(0),
       current_height_(0) {
 }
 
 DisconnectWindowGtk::~DisconnectWindowGtk() {
   DCHECK(CalledOnValidThread());
 
   if (disconnect_window_) {
     gtk_widget_destroy(disconnect_window_);
     disconnect_window_ = NULL;
   }
 }
 
 void DisconnectWindowGtk::Start(
     const base::WeakPtr<ClientSessionControl>& client_session_control) {
   DCHECK(CalledOnValidThread());
   DCHECK(!client_session_control_.get());
   DCHECK(client_session_control.get());
   DCHECK(!disconnect_window_);
 
   client_session_control_ = client_session_control;
 
   // Create the window.
   disconnect_window_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   GtkWindow* window = GTK_WINDOW(disconnect_window_);
 
   g_signal_connect(disconnect_window_, "delete-event",
                    G_CALLBACK(OnDeleteThunk), this);
-  gtk_window_set_title(window, UTF16ToUTF8(ui_strings_.product_name).c_str());
+  gtk_window_set_title(window,
+                       l10n_util::GetStringUTF8(IDR_PRODUCT_NAME).c_str());
   gtk_window_set_resizable(window, FALSE);
 
   // Try to keep the window always visible.
   gtk_window_stick(window);
   gtk_window_set_keep_above(window, TRUE);
 
   // Remove window titlebar.
   gtk_window_set_decorated(window, FALSE);
 
   // In case the titlebar is still there, try to remove some of the buttons.
@@ skipping 23 matching lines @@
   // left and right.  The left margin is made larger to accommodate the
   // window movement gripper.
   GtkWidget* align = gtk_alignment_new(0, 0, 1, 1);
   gtk_alignment_set_padding(GTK_ALIGNMENT(align), 8, 8, 24, 12);
   gtk_container_add(GTK_CONTAINER(window), align);
 
   GtkWidget* button_row = gtk_hbox_new(FALSE, 12);
   gtk_container_add(GTK_CONTAINER(align), button_row);
 
   button_ = gtk_button_new_with_label(
-      UTF16ToUTF8(ui_strings_.disconnect_button_text).c_str());
+      l10n_util::GetStringUTF8(IDR_STOP_SHARING_BUTTON).c_str());
   gtk_box_pack_end(GTK_BOX(button_row), button_, FALSE, FALSE, 0);
 
   g_signal_connect(button_, "clicked", G_CALLBACK(OnClickedThunk), this);
 
   message_ = gtk_label_new(NULL);
   gtk_box_pack_end(GTK_BOX(button_row), message_, FALSE, FALSE, 0);
 
   // Override any theme setting for the text color, so that the text is
   // readable against the window's background pixmap.
   PangoAttrList* attributes = pango_attr_list_new();
   PangoAttribute* text_color = pango_attr_foreground_new(0, 0, 0);
   pango_attr_list_insert(attributes, text_color);
   gtk_label_set_attributes(GTK_LABEL(message_), attributes);
   pango_attr_list_unref(attributes);
 
   gtk_widget_show_all(disconnect_window_);
 
   // Extract the user name from the JID.
   std::string client_jid = client_session_control_->client_jid();
   string16 username = UTF8ToUTF16(client_jid.substr(0, client_jid.find('/')));
-  string16 text =
-      ReplaceStringPlaceholders(ui_strings_.disconnect_message, username, NULL);
-  gtk_label_set_text(GTK_LABEL(message_), UTF16ToUTF8(text).c_str());
+  gtk_label_set_text(
+      GTK_LABEL(message_),
+      l10n_util::GetStringFUTF8(IDR_MESSAGE_SHARED, username).c_str());
   gtk_window_present(window);
 }
 
 void DisconnectWindowGtk::OnClicked(GtkWidget* button) {
   DCHECK(CalledOnValidThread());
 
   if (client_session_control_.get())
     client_session_control_->DisconnectSession();
 }
 
@@ skipping 102 matching lines @@
                              event->button,
                              event->x_root,
                              event->y_root,
                              event->time);
   return FALSE;
 }
 
 }  // namespace
 
 // static
-scoped_ptr<HostWindow> HostWindow::CreateDisconnectWindow(
-    const UiStrings& ui_strings) {
-  return scoped_ptr<HostWindow>(new DisconnectWindowGtk(ui_strings));
+scoped_ptr<HostWindow> HostWindow::CreateDisconnectWindow() {
+  return scoped_ptr<HostWindow>(new DisconnectWindowGtk());
 }
 
 }  // namespace remoting