| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 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 "content/shell/browser/shell.h" | |
| 6 | |
| 7 #include <gdk/gdkkeysyms.h> | |
| 8 #include <gtk/gtk.h> | |
| 9 | |
| 10 #include "base/logging.h" | |
| 11 #include "base/strings/string_piece.h" | |
| 12 #include "base/strings/utf_string_conversions.h" | |
| 13 #include "content/public/browser/browser_context.h" | |
| 14 #include "content/public/browser/native_web_keyboard_event.h" | |
| 15 #include "content/public/browser/render_widget_host_view.h" | |
| 16 #include "content/public/browser/web_contents.h" | |
| 17 #include "content/public/browser/web_contents_view.h" | |
| 18 #include "content/public/common/renderer_preferences.h" | |
| 19 #include "content/shell/browser/shell_browser_context.h" | |
| 20 #include "content/shell/browser/shell_content_browser_client.h" | |
| 21 | |
| 22 namespace content { | |
| 23 | |
| 24 namespace { | |
| 25 | |
| 26 // Callback for Debug > Show web inspector... menu item. | |
| 27 gboolean ShowWebInspectorActivated(GtkWidget* widget, Shell* shell) { | |
| 28 shell->ShowDevTools(); | |
| 29 return FALSE; // Don't stop this message. | |
| 30 } | |
| 31 | |
| 32 GtkWidget* AddMenuEntry(GtkWidget* menu_widget, const char* text, | |
| 33 GCallback callback, Shell* shell) { | |
| 34 GtkWidget* entry = gtk_menu_item_new_with_label(text); | |
| 35 g_signal_connect(entry, "activate", callback, shell); | |
| 36 gtk_menu_shell_append(GTK_MENU_SHELL(menu_widget), entry); | |
| 37 return entry; | |
| 38 } | |
| 39 | |
| 40 GtkWidget* CreateMenu(GtkWidget* menu_bar, const char* text) { | |
| 41 GtkWidget* menu_widget = gtk_menu_new(); | |
| 42 GtkWidget* menu_header = gtk_menu_item_new_with_label(text); | |
| 43 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_header), menu_widget); | |
| 44 gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), menu_header); | |
| 45 return menu_widget; | |
| 46 } | |
| 47 | |
| 48 GtkWidget* CreateMenuBar(Shell* shell) { | |
| 49 GtkWidget* menu_bar = gtk_menu_bar_new(); | |
| 50 GtkWidget* debug_menu = CreateMenu(menu_bar, "Debug"); | |
| 51 AddMenuEntry(debug_menu, "Show web inspector...", | |
| 52 G_CALLBACK(ShowWebInspectorActivated), shell); | |
| 53 return menu_bar; | |
| 54 } | |
| 55 | |
| 56 } // namespace | |
| 57 | |
| 58 void Shell::PlatformInitialize(const gfx::Size& default_window_size) { | |
| 59 } | |
| 60 | |
| 61 void Shell::PlatformExit() { | |
| 62 } | |
| 63 | |
| 64 void Shell::PlatformCleanUp() { | |
| 65 // Nothing to clean up; GTK will clean up the widgets shortly after. | |
| 66 } | |
| 67 | |
| 68 void Shell::PlatformEnableUIControl(UIControl control, bool is_enabled) { | |
| 69 if (headless_) | |
| 70 return; | |
| 71 | |
| 72 GtkToolItem* item = NULL; | |
| 73 switch (control) { | |
| 74 case BACK_BUTTON: | |
| 75 item = back_button_; | |
| 76 break; | |
| 77 case FORWARD_BUTTON: | |
| 78 item = forward_button_; | |
| 79 break; | |
| 80 case STOP_BUTTON: | |
| 81 item = stop_button_; | |
| 82 break; | |
| 83 default: | |
| 84 NOTREACHED() << "Unknown UI control"; | |
| 85 return; | |
| 86 } | |
| 87 gtk_widget_set_sensitive(GTK_WIDGET(item), is_enabled); | |
| 88 } | |
| 89 | |
| 90 void Shell::PlatformSetAddressBarURL(const GURL& url) { | |
| 91 if (headless_) | |
| 92 return; | |
| 93 | |
| 94 gtk_entry_set_text(GTK_ENTRY(url_edit_view_), url.spec().c_str()); | |
| 95 } | |
| 96 | |
| 97 void Shell::PlatformSetIsLoading(bool loading) { | |
| 98 if (headless_) | |
| 99 return; | |
| 100 | |
| 101 if (loading) | |
| 102 gtk_spinner_start(GTK_SPINNER(spinner_)); | |
| 103 else | |
| 104 gtk_spinner_stop(GTK_SPINNER(spinner_)); | |
| 105 } | |
| 106 | |
| 107 void Shell::PlatformCreateWindow(int width, int height) { | |
| 108 ui_elements_height_ = 0; | |
| 109 if (headless_) { | |
| 110 content_size_ = gfx::Size(width, height); | |
| 111 return; | |
| 112 } | |
| 113 | |
| 114 window_ = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL)); | |
| 115 gtk_window_set_title(window_, "Content Shell"); | |
| 116 g_signal_connect(G_OBJECT(window_), "destroy", | |
| 117 G_CALLBACK(OnWindowDestroyedThunk), this); | |
| 118 | |
| 119 vbox_ = gtk_vbox_new(FALSE, 0); | |
| 120 | |
| 121 // Create the menu bar. | |
| 122 GtkWidget* menu_bar = CreateMenuBar(this); | |
| 123 gtk_box_pack_start(GTK_BOX(vbox_), menu_bar, FALSE, FALSE, 0); | |
| 124 | |
| 125 // Create the object that mediates accelerators. | |
| 126 GtkAccelGroup* accel_group = gtk_accel_group_new(); | |
| 127 gtk_window_add_accel_group(GTK_WINDOW(window_), accel_group); | |
| 128 | |
| 129 // Set global window handling accelerators: | |
| 130 gtk_accel_group_connect( | |
| 131 accel_group, GDK_w, GDK_CONTROL_MASK, | |
| 132 GTK_ACCEL_VISIBLE, | |
| 133 g_cclosure_new(G_CALLBACK(OnCloseWindowKeyPressedThunk), | |
| 134 this, NULL)); | |
| 135 | |
| 136 gtk_accel_group_connect( | |
| 137 accel_group, GDK_n, GDK_CONTROL_MASK, | |
| 138 GTK_ACCEL_VISIBLE, | |
| 139 g_cclosure_new(G_CALLBACK(OnNewWindowKeyPressedThunk), | |
| 140 this, NULL)); | |
| 141 | |
| 142 gtk_accel_group_connect( | |
| 143 accel_group, GDK_F5, (GdkModifierType)0, | |
| 144 GTK_ACCEL_VISIBLE, | |
| 145 g_cclosure_new(G_CALLBACK(OnReloadKeyPressedThunk), | |
| 146 this, NULL)); | |
| 147 | |
| 148 GtkWidget* toolbar = gtk_toolbar_new(); | |
| 149 // Turn off the labels on the toolbar buttons. | |
| 150 gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); | |
| 151 | |
| 152 back_button_ = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK); | |
| 153 g_signal_connect(back_button_, "clicked", | |
| 154 G_CALLBACK(&OnBackButtonClickedThunk), this); | |
| 155 gtk_toolbar_insert(GTK_TOOLBAR(toolbar), back_button_, -1 /* append */); | |
| 156 gtk_widget_add_accelerator(GTK_WIDGET(back_button_), "clicked", accel_group, | |
| 157 GDK_Left, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); | |
| 158 | |
| 159 forward_button_ = gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD); | |
| 160 g_signal_connect(forward_button_, "clicked", | |
| 161 G_CALLBACK(&OnForwardButtonClickedThunk), this); | |
| 162 gtk_toolbar_insert(GTK_TOOLBAR(toolbar), forward_button_, -1 /* append */); | |
| 163 gtk_widget_add_accelerator(GTK_WIDGET(forward_button_), "clicked", | |
| 164 accel_group, | |
| 165 GDK_Right, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); | |
| 166 | |
| 167 reload_button_ = gtk_tool_button_new_from_stock(GTK_STOCK_REFRESH); | |
| 168 g_signal_connect(reload_button_, "clicked", | |
| 169 G_CALLBACK(&OnReloadButtonClickedThunk), this); | |
| 170 gtk_toolbar_insert(GTK_TOOLBAR(toolbar), reload_button_, -1 /* append */); | |
| 171 gtk_widget_add_accelerator(GTK_WIDGET(reload_button_), "clicked", | |
| 172 accel_group, | |
| 173 GDK_r, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); | |
| 174 | |
| 175 stop_button_ = gtk_tool_button_new_from_stock(GTK_STOCK_STOP); | |
| 176 g_signal_connect(stop_button_, "clicked", | |
| 177 G_CALLBACK(&OnStopButtonClickedThunk), this); | |
| 178 gtk_toolbar_insert(GTK_TOOLBAR(toolbar), stop_button_, -1 /* append */); | |
| 179 | |
| 180 url_edit_view_ = gtk_entry_new(); | |
| 181 g_signal_connect(G_OBJECT(url_edit_view_), "activate", | |
| 182 G_CALLBACK(&OnURLEntryActivateThunk), this); | |
| 183 | |
| 184 gtk_accel_group_connect( | |
| 185 accel_group, GDK_l, GDK_CONTROL_MASK, | |
| 186 GTK_ACCEL_VISIBLE, | |
| 187 g_cclosure_new(G_CALLBACK(OnHighlightURLViewThunk), | |
| 188 this, NULL)); | |
| 189 | |
| 190 GtkToolItem* tool_item = gtk_tool_item_new(); | |
| 191 gtk_container_add(GTK_CONTAINER(tool_item), url_edit_view_); | |
| 192 gtk_tool_item_set_expand(tool_item, TRUE); | |
| 193 gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_item, -1 /* append */); | |
| 194 | |
| 195 // Center a 20x20 spinner in a 26x24 area. | |
| 196 GtkWidget* spinner_alignment = gtk_alignment_new(0.5, 0.5, 0, 0); | |
| 197 gtk_alignment_set_padding(GTK_ALIGNMENT(spinner_alignment), 2, 2, 4, 4); | |
| 198 spinner_ = gtk_spinner_new(); | |
| 199 gtk_widget_set_size_request(spinner_, 20, 20); | |
| 200 gtk_container_add(GTK_CONTAINER(spinner_alignment), spinner_); | |
| 201 | |
| 202 spinner_item_ = gtk_tool_item_new(); | |
| 203 gtk_container_add(GTK_CONTAINER(spinner_item_), spinner_alignment); | |
| 204 gtk_toolbar_insert(GTK_TOOLBAR(toolbar), spinner_item_, -1 /* append */); | |
| 205 | |
| 206 gtk_box_pack_start(GTK_BOX(vbox_), toolbar, FALSE, FALSE, 0); | |
| 207 | |
| 208 gtk_container_add(GTK_CONTAINER(window_), vbox_); | |
| 209 | |
| 210 // Trigger layout of the UI elements, so that we can measure their | |
| 211 // heights. The width and height passed to this method are meant for the web | |
| 212 // contents view, not the top-level window. Since Gtk only seems to provide a | |
| 213 // suitable resizing function for top-level windows, we need to know how to | |
| 214 // convert from web contents view size to top-level window size. | |
| 215 gtk_widget_show_all(GTK_WIDGET(vbox_)); | |
| 216 | |
| 217 // Measure the heights of the UI elements, now that they have been laid out. | |
| 218 GtkRequisition elm_size; | |
| 219 gtk_widget_size_request(menu_bar, &elm_size); | |
| 220 ui_elements_height_ += elm_size.height; | |
| 221 gtk_widget_size_request(toolbar, &elm_size); | |
| 222 ui_elements_height_ += elm_size.height; | |
| 223 | |
| 224 // We're ready to set an initial window size. | |
| 225 SizeTo(gfx::Size(width, height)); | |
| 226 | |
| 227 // Finally, show the window. | |
| 228 gtk_widget_show_all(GTK_WIDGET(window_)); | |
| 229 } | |
| 230 | |
| 231 void Shell::PlatformSetContents() { | |
| 232 if (headless_) { | |
| 233 SizeTo(content_size_); | |
| 234 return; | |
| 235 } | |
| 236 | |
| 237 WebContentsView* content_view = web_contents_->GetView(); | |
| 238 gtk_container_add(GTK_CONTAINER(vbox_), content_view->GetNativeView()); | |
| 239 } | |
| 240 | |
| 241 void Shell::SizeTo(const gfx::Size& content_size) { | |
| 242 content_size_ = content_size; | |
| 243 | |
| 244 if (window_) { | |
| 245 gtk_window_resize(window_, | |
| 246 content_size.width(), | |
| 247 content_size.height() + ui_elements_height_); | |
| 248 } else if (web_contents_) { | |
| 249 RenderWidgetHostView* render_widget_host_view = | |
| 250 web_contents_->GetRenderWidgetHostView(); | |
| 251 if (render_widget_host_view) | |
| 252 render_widget_host_view->SetSize(content_size); | |
| 253 } | |
| 254 } | |
| 255 | |
| 256 void Shell::PlatformResizeSubViews() { | |
| 257 // Not needed; the subviews are bound. | |
| 258 } | |
| 259 | |
| 260 bool Shell::PlatformHandleContextMenu( | |
| 261 const content::ContextMenuParams& params) { | |
| 262 return false; | |
| 263 } | |
| 264 | |
| 265 void Shell::Close() { | |
| 266 if (headless_) { | |
| 267 delete this; | |
| 268 return; | |
| 269 } | |
| 270 | |
| 271 gtk_widget_destroy(GTK_WIDGET(window_)); | |
| 272 } | |
| 273 | |
| 274 void Shell::OnBackButtonClicked(GtkWidget* widget) { | |
| 275 GoBackOrForward(-1); | |
| 276 } | |
| 277 | |
| 278 void Shell::OnForwardButtonClicked(GtkWidget* widget) { | |
| 279 GoBackOrForward(1); | |
| 280 } | |
| 281 | |
| 282 void Shell::OnReloadButtonClicked(GtkWidget* widget) { | |
| 283 Reload(); | |
| 284 } | |
| 285 | |
| 286 void Shell::OnStopButtonClicked(GtkWidget* widget) { | |
| 287 Stop(); | |
| 288 } | |
| 289 | |
| 290 void Shell::OnURLEntryActivate(GtkWidget* entry) { | |
| 291 const gchar* str = gtk_entry_get_text(GTK_ENTRY(entry)); | |
| 292 GURL url(str); | |
| 293 if (!url.has_scheme()) | |
| 294 url = GURL(std::string("http://") + std::string(str)); | |
| 295 if (url.is_valid()) | |
| 296 LoadURL(url); | |
| 297 } | |
| 298 | |
| 299 // Callback for when the main window is destroyed. | |
| 300 gboolean Shell::OnWindowDestroyed(GtkWidget* window) { | |
| 301 delete this; | |
| 302 return FALSE; // Don't stop this message. | |
| 303 } | |
| 304 | |
| 305 gboolean Shell::OnCloseWindowKeyPressed(GtkAccelGroup* accel_group, | |
| 306 GObject* acceleratable, | |
| 307 guint keyval, | |
| 308 GdkModifierType modifier) { | |
| 309 gtk_widget_destroy(GTK_WIDGET(window_)); | |
| 310 return TRUE; | |
| 311 } | |
| 312 | |
| 313 gboolean Shell::OnNewWindowKeyPressed(GtkAccelGroup* accel_group, | |
| 314 GObject* acceleratable, | |
| 315 guint keyval, | |
| 316 GdkModifierType modifier) { | |
| 317 ShellBrowserContext* browser_context = | |
| 318 ShellContentBrowserClient::Get()->browser_context(); | |
| 319 Shell::CreateNewWindow(browser_context, | |
| 320 GURL(), | |
| 321 NULL, | |
| 322 MSG_ROUTING_NONE, | |
| 323 gfx::Size()); | |
| 324 return TRUE; | |
| 325 } | |
| 326 | |
| 327 gboolean Shell::OnHighlightURLView(GtkAccelGroup* accel_group, | |
| 328 GObject* acceleratable, | |
| 329 guint keyval, | |
| 330 GdkModifierType modifier) { | |
| 331 gtk_widget_grab_focus(GTK_WIDGET(url_edit_view_)); | |
| 332 return TRUE; | |
| 333 } | |
| 334 | |
| 335 gboolean Shell::OnReloadKeyPressed(GtkAccelGroup* accel_group, | |
| 336 GObject* acceleratable, | |
| 337 guint keyval, | |
| 338 GdkModifierType modifier) { | |
| 339 Reload(); | |
| 340 return TRUE; | |
| 341 } | |
| 342 | |
| 343 void Shell::PlatformSetTitle(const base::string16& title) { | |
| 344 if (headless_) | |
| 345 return; | |
| 346 | |
| 347 std::string title_utf8 = base::UTF16ToUTF8(title); | |
| 348 gtk_window_set_title(GTK_WINDOW(window_), title_utf8.c_str()); | |
| 349 } | |
| 350 | |
| 351 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 231733005:
Delete the GTK+ port of Chrome. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src