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 <gtk/gtk.h>
6#include <math.h>
7
8#include "base/compiler_specific.h"
9#include "base/logging.h"
10#include "base/strings/string_util.h"
11#include "base/strings/utf_string_conversions.h"
12#include "remoting/base/string_resources.h"
13#include "remoting/host/client_session_control.h"
14#include "remoting/host/host_window.h"
15#include "ui/base/gtk/gtk_signal.h"
16#include "ui/base/l10n/l10n_util.h"
17
18namespace remoting {
19
20namespace {
21
22class DisconnectWindowGtk : public HostWindow {
23 public:
24  DisconnectWindowGtk();
25  virtual ~DisconnectWindowGtk();
26
27  // HostWindow overrides.
28  virtual void Start(
29      const base::WeakPtr<ClientSessionControl>& client_session_control)
30      OVERRIDE;
31
32 private:
33  CHROMEGTK_CALLBACK_1(DisconnectWindowGtk, gboolean, OnDelete, GdkEvent*);
34  CHROMEGTK_CALLBACK_0(DisconnectWindowGtk, void, OnClicked);
35  CHROMEGTK_CALLBACK_1(DisconnectWindowGtk, gboolean, OnConfigure,
36                       GdkEventConfigure*);
37  CHROMEGTK_CALLBACK_1(DisconnectWindowGtk, gboolean, OnButtonPress,
38                       GdkEventButton*);
39
40  // Used to disconnect the client session.
41  base::WeakPtr<ClientSessionControl> client_session_control_;
42
43  GtkWidget* disconnect_window_;
44  GtkWidget* message_;
45  GtkWidget* button_;
46
47  // Used to distinguish resize events from other types of "configure-event"
48  // notifications.
49  int current_width_;
50  int current_height_;
51
52  DISALLOW_COPY_AND_ASSIGN(DisconnectWindowGtk);
53};
54
55// Helper function for creating a rectangular path with rounded corners, as
56// Cairo doesn't have this facility.  |radius| is the arc-radius of each
57// corner.  The bounding rectangle extends from (0, 0) to (width, height).
58void AddRoundRectPath(cairo_t* cairo_context, int width, int height,
59                      int radius) {
60  cairo_new_sub_path(cairo_context);
61  cairo_arc(cairo_context, width - radius, radius, radius, -M_PI_2, 0);
62  cairo_arc(cairo_context, width - radius, height - radius, radius, 0, M_PI_2);
63  cairo_arc(cairo_context, radius, height - radius, radius, M_PI_2, 2 * M_PI_2);
64  cairo_arc(cairo_context, radius, radius, radius, 2 * M_PI_2, 3 * M_PI_2);
65  cairo_close_path(cairo_context);
66}
67
68DisconnectWindowGtk::DisconnectWindowGtk()
69    : disconnect_window_(NULL),
70      current_width_(0),
71      current_height_(0) {
72}
73
74DisconnectWindowGtk::~DisconnectWindowGtk() {
75  DCHECK(CalledOnValidThread());
76
77  if (disconnect_window_) {
78    gtk_widget_destroy(disconnect_window_);
79    disconnect_window_ = NULL;
80  }
81}
82
83void DisconnectWindowGtk::Start(
84    const base::WeakPtr<ClientSessionControl>& client_session_control) {
85  DCHECK(CalledOnValidThread());
86  DCHECK(!client_session_control_.get());
87  DCHECK(client_session_control.get());
88  DCHECK(!disconnect_window_);
89
90  client_session_control_ = client_session_control;
91
92  // Create the window.
93  disconnect_window_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
94  GtkWindow* window = GTK_WINDOW(disconnect_window_);
95
96  g_signal_connect(disconnect_window_, "delete-event",
97                   G_CALLBACK(OnDeleteThunk), this);
98  gtk_window_set_title(window,
99                       l10n_util::GetStringUTF8(IDR_PRODUCT_NAME).c_str());
100  gtk_window_set_resizable(window, FALSE);
101
102  // Try to keep the window always visible.
103  gtk_window_stick(window);
104  gtk_window_set_keep_above(window, TRUE);
105
106  // Remove window titlebar.
107  gtk_window_set_decorated(window, FALSE);
108
109  // In case the titlebar is still there, try to remove some of the buttons.
110  // Utility windows have no minimize button or taskbar presence.
111  gtk_window_set_type_hint(window, GDK_WINDOW_TYPE_HINT_UTILITY);
112  gtk_window_set_deletable(window, FALSE);
113
114  // Allow custom rendering of the background pixmap.
115  gtk_widget_set_app_paintable(disconnect_window_, TRUE);
116
117  // Handle window resizing, to regenerate the background pixmap and window
118  // shape bitmap.  The stored width & height need to be initialized here
119  // in case the window is created a second time (the size of the previous
120  // window would be remembered, preventing the generation of bitmaps for the
121  // new window).
122  current_height_ = current_width_ = 0;
123  g_signal_connect(disconnect_window_, "configure-event",
124                   G_CALLBACK(OnConfigureThunk), this);
125
126  // Handle mouse events to allow the user to drag the window around.
127  gtk_widget_set_events(disconnect_window_, GDK_BUTTON_PRESS_MASK);
128  g_signal_connect(disconnect_window_, "button-press-event",
129                   G_CALLBACK(OnButtonPressThunk), this);
130
131  // All magic numbers taken from screen shots provided by UX.
132  // The alignment sets narrow margins at the top and bottom, compared with
133  // left and right.  The left margin is made larger to accommodate the
134  // window movement gripper.
135  GtkWidget* align = gtk_alignment_new(0, 0, 1, 1);
136  gtk_alignment_set_padding(GTK_ALIGNMENT(align), 8, 8, 24, 12);
137  gtk_container_add(GTK_CONTAINER(window), align);
138
139  GtkWidget* button_row = gtk_hbox_new(FALSE, 12);
140  gtk_container_add(GTK_CONTAINER(align), button_row);
141
142  button_ = gtk_button_new_with_label(
143      l10n_util::GetStringUTF8(IDR_STOP_SHARING_BUTTON).c_str());
144  gtk_box_pack_end(GTK_BOX(button_row), button_, FALSE, FALSE, 0);
145
146  g_signal_connect(button_, "clicked", G_CALLBACK(OnClickedThunk), this);
147
148  message_ = gtk_label_new(NULL);
149  gtk_box_pack_end(GTK_BOX(button_row), message_, FALSE, FALSE, 0);
150
151  // Override any theme setting for the text color, so that the text is
152  // readable against the window's background pixmap.
153  PangoAttrList* attributes = pango_attr_list_new();
154  PangoAttribute* text_color = pango_attr_foreground_new(0, 0, 0);
155  pango_attr_list_insert(attributes, text_color);
156  gtk_label_set_attributes(GTK_LABEL(message_), attributes);
157  pango_attr_list_unref(attributes);
158
159  gtk_widget_show_all(disconnect_window_);
160
161  // Extract the user name from the JID.
162  std::string client_jid = client_session_control_->client_jid();
163  base::string16 username =
164      UTF8ToUTF16(client_jid.substr(0, client_jid.find('/')));
165  gtk_label_set_text(
166      GTK_LABEL(message_),
167      l10n_util::GetStringFUTF8(IDR_MESSAGE_SHARED, username).c_str());
168  gtk_window_present(window);
169}
170
171void DisconnectWindowGtk::OnClicked(GtkWidget* button) {
172  DCHECK(CalledOnValidThread());
173
174  if (client_session_control_.get())
175    client_session_control_->DisconnectSession();
176}
177
178gboolean DisconnectWindowGtk::OnDelete(GtkWidget* window,
179                                       GdkEvent* event) {
180  DCHECK(CalledOnValidThread());
181
182  if (client_session_control_.get())
183    client_session_control_->DisconnectSession();
184  return TRUE;
185}
186
187gboolean DisconnectWindowGtk::OnConfigure(GtkWidget* widget,
188                                          GdkEventConfigure* event) {
189  DCHECK(CalledOnValidThread());
190
191  // Only generate bitmaps if the size has actually changed.
192  if (event->width == current_width_ && event->height == current_height_)
193    return FALSE;
194
195  current_width_ = event->width;
196  current_height_ = event->height;
197
198  // Create the depth 1 pixmap for the window shape.
199  GdkPixmap* shape_mask = gdk_pixmap_new(NULL, current_width_, current_height_,
200                                         1);
201  cairo_t* cairo_context = gdk_cairo_create(shape_mask);
202
203  // Set the arc radius for the corners.
204  const int kCornerRadius = 6;
205
206  // Initialize the whole bitmap to be transparent.
207  cairo_set_source_rgba(cairo_context, 0, 0, 0, 0);
208  cairo_set_operator(cairo_context, CAIRO_OPERATOR_SOURCE);
209  cairo_paint(cairo_context);
210
211  // Paint an opaque round rect covering the whole area (leaving the extreme
212  // corners transparent).
213  cairo_set_source_rgba(cairo_context, 1, 1, 1, 1);
214  cairo_set_operator(cairo_context, CAIRO_OPERATOR_SOURCE);
215  AddRoundRectPath(cairo_context, current_width_, current_height_,
216                   kCornerRadius);
217  cairo_fill(cairo_context);
218
219  cairo_destroy(cairo_context);
220  gdk_window_shape_combine_mask(widget->window, shape_mask, 0, 0);
221  g_object_unref(shape_mask);
222
223  // Create a full-color pixmap for the window background image.
224  GdkPixmap* background = gdk_pixmap_new(NULL, current_width_, current_height_,
225                                         24);
226  cairo_context = gdk_cairo_create(background);
227
228  // Paint the whole bitmap one color.
229  cairo_set_source_rgb(cairo_context, 0.91, 0.91, 0.91);
230  cairo_paint(cairo_context);
231
232  // Paint the round-rectangle edge.
233  cairo_set_source_rgb(cairo_context, 0.13, 0.69, 0.11);
234  cairo_set_line_width(cairo_context, 6);
235  AddRoundRectPath(cairo_context, current_width_, current_height_,
236                   kCornerRadius);
237  cairo_stroke(cairo_context);
238
239  // Render the window-gripper.  In order for a straight line to light up
240  // single pixels, Cairo requires the coordinates to have fractional
241  // components of 0.5 (so the "/ 2" is a deliberate integer division).
242  double gripper_top = current_height_ / 2 - 10.5;
243  double gripper_bottom = current_height_ / 2 + 10.5;
244  cairo_set_line_width(cairo_context, 1);
245
246  double x = 12.5;
247  cairo_set_source_rgb(cairo_context, 0.70, 0.70, 0.70);
248  cairo_move_to(cairo_context, x, gripper_top);
249  cairo_line_to(cairo_context, x, gripper_bottom);
250  cairo_stroke(cairo_context);
251  x += 3;
252  cairo_move_to(cairo_context, x, gripper_top);
253  cairo_line_to(cairo_context, x, gripper_bottom);
254  cairo_stroke(cairo_context);
255
256  x -= 2;
257  cairo_set_source_rgb(cairo_context, 0.97, 0.97, 0.97);
258  cairo_move_to(cairo_context, x, gripper_top);
259  cairo_line_to(cairo_context, x, gripper_bottom);
260  cairo_stroke(cairo_context);
261  x += 3;
262  cairo_move_to(cairo_context, x, gripper_top);
263  cairo_line_to(cairo_context, x, gripper_bottom);
264  cairo_stroke(cairo_context);
265
266  cairo_destroy(cairo_context);
267
268  gdk_window_set_back_pixmap(widget->window, background, FALSE);
269  g_object_unref(background);
270  gdk_window_invalidate_rect(widget->window, NULL, TRUE);
271
272  return FALSE;
273}
274
275gboolean DisconnectWindowGtk::OnButtonPress(GtkWidget* widget,
276                                            GdkEventButton* event) {
277  DCHECK(CalledOnValidThread());
278
279  gtk_window_begin_move_drag(GTK_WINDOW(disconnect_window_),
280                             event->button,
281                             event->x_root,
282                             event->y_root,
283                             event->time);
284  return FALSE;
285}
286
287}  // namespace
288
289// static
290scoped_ptr<HostWindow> HostWindow::CreateDisconnectWindow() {
291  return scoped_ptr<HostWindow>(new DisconnectWindowGtk());
292}
293
294}  // namespace remoting
295