diff options
| -rw-r--r-- | chrome/browser/gtk/bookmark_manager_gtk.cc | 229 | ||||
| -rw-r--r-- | chrome/browser/gtk/bookmark_manager_gtk.h | 159 | ||||
| -rw-r--r-- | chrome/browser/gtk/bookmark_menu_controller_gtk.cc | 97 | ||||
| -rw-r--r-- | chrome/browser/gtk/bookmark_menu_controller_gtk.h | 39 | ||||
| -rw-r--r-- | chrome/browser/gtk/external_protocol_dialog_gtk.cc | 3 | ||||
| -rw-r--r-- | chrome/browser/gtk/external_protocol_dialog_gtk.h | 8 | ||||
| -rw-r--r-- | chrome/browser/tab_contents/tab_contents_view_gtk.cc | 44 | ||||
| -rw-r--r-- | chrome/browser/tab_contents/tab_contents_view_gtk.h | 21 |
8 files changed, 229 insertions, 371 deletions
diff --git a/chrome/browser/gtk/bookmark_manager_gtk.cc b/chrome/browser/gtk/bookmark_manager_gtk.cc index 848b306..bfa168b 100644 --- a/chrome/browser/gtk/bookmark_manager_gtk.cc +++ b/chrome/browser/gtk/bookmark_manager_gtk.cc @@ -375,13 +375,13 @@ void BookmarkManagerGtk::InitWidgets() { gtk_util::ConvertAcceleratorsFromWindowsStyle( l10n_util::GetStringUTF8(IDS_BOOKMARK_MANAGER_IMPORT_MENU)).c_str()); g_signal_connect(import_item, "activate", - G_CALLBACK(OnImportItemActivated), this); + G_CALLBACK(OnImportItemActivatedThunk), this); GtkWidget* export_item = gtk_menu_item_new_with_mnemonic( gtk_util::ConvertAcceleratorsFromWindowsStyle( l10n_util::GetStringUTF8(IDS_BOOKMARK_MANAGER_EXPORT_MENU)).c_str()); g_signal_connect(export_item, "activate", - G_CALLBACK(OnExportItemActivated), this); + G_CALLBACK(OnExportItemActivatedThunk), this); GtkWidget* tools_menu = gtk_menu_new(); gtk_menu_shell_append(GTK_MENU_SHELL(tools_menu), import_item); @@ -394,7 +394,7 @@ void BookmarkManagerGtk::InitWidgets() { // Build the sync status menu item. sync_status_menu_ = gtk_menu_item_new_with_label(""); g_signal_connect(sync_status_menu_, "activate", - G_CALLBACK(OnSyncStatusMenuActivated), this); + G_CALLBACK(OnSyncStatusMenuActivatedThunk), this); GtkWidget* menu_bar = gtk_menu_bar_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), organize_); @@ -457,15 +457,15 @@ GtkWidget* BookmarkManagerGtk::MakeLeftPane() { // When a row is collapsed that contained the selected node, we want to select // it. g_signal_connect(left_tree_view_, "row-collapsed", - G_CALLBACK(OnLeftTreeViewRowCollapsed), this); + G_CALLBACK(OnLeftTreeViewRowCollapsedThunk), this); g_signal_connect(left_tree_view_, "focus-in-event", - G_CALLBACK(OnLeftTreeViewFocusIn), this); + G_CALLBACK(OnLeftTreeViewFocusInThunk), this); g_signal_connect(left_tree_view_, "button-press-event", - G_CALLBACK(OnTreeViewButtonPress), this); + G_CALLBACK(OnTreeViewButtonPressThunk), this); g_signal_connect(left_tree_view_, "button-release-event", - G_CALLBACK(OnTreeViewButtonRelease), this); + G_CALLBACK(OnTreeViewButtonReleaseThunk), this); g_signal_connect(left_tree_view_, "key-press-event", - G_CALLBACK(OnTreeViewKeyPress), this); + G_CALLBACK(OnTreeViewKeyPressThunk), this); GtkCellRenderer* cell_renderer_text = bookmark_utils::GetCellRendererText( GTK_TREE_VIEW(left_tree_view_)); @@ -478,9 +478,9 @@ GtkWidget* BookmarkManagerGtk::MakeLeftPane() { gtk_dnd_util::SetDestTargetList(left_tree_view_, kDestTargetList); g_signal_connect(left_tree_view_, "drag-data-received", - G_CALLBACK(&OnLeftTreeViewDragReceived), this); + G_CALLBACK(OnLeftTreeViewDragReceivedThunk), this); g_signal_connect(left_tree_view_, "drag-motion", - G_CALLBACK(&OnLeftTreeViewDragMotion), this); + G_CALLBACK(OnLeftTreeViewDragMotionThunk), this); GtkWidget* scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), @@ -529,22 +529,22 @@ GtkWidget* BookmarkManagerGtk::MakeRightPane() { gtk_tree_selection_set_mode(right_selection(), GTK_SELECTION_MULTIPLE); g_signal_connect(right_tree_view_, "row-activated", - G_CALLBACK(OnRightTreeViewRowActivated), this); + G_CALLBACK(OnRightTreeViewRowActivatedThunk), this); g_signal_connect(right_selection(), "changed", G_CALLBACK(OnRightSelectionChanged), this); g_signal_connect(right_tree_view_, "focus-in-event", - G_CALLBACK(OnRightTreeViewFocusIn), this); + G_CALLBACK(OnRightTreeViewFocusInThunk), this); g_signal_connect(right_tree_view_, "button-press-event", - G_CALLBACK(OnRightTreeViewButtonPress), this); + G_CALLBACK(OnRightTreeViewButtonPressThunk), this); g_signal_connect(right_tree_view_, "motion-notify-event", - G_CALLBACK(OnRightTreeViewMotion), this); + G_CALLBACK(OnRightTreeViewMotionThunk), this); // This handler just controls showing the context menu. g_signal_connect(right_tree_view_, "button-press-event", - G_CALLBACK(OnTreeViewButtonPress), this); + G_CALLBACK(OnTreeViewButtonPressThunk), this); g_signal_connect(right_tree_view_, "button-release-event", - G_CALLBACK(OnTreeViewButtonRelease), this); + G_CALLBACK(OnTreeViewButtonReleaseThunk), this); g_signal_connect(right_tree_view_, "key-press-event", - G_CALLBACK(OnTreeViewKeyPress), this); + G_CALLBACK(OnTreeViewKeyPressThunk), this); // GDK_ACTION_MOVE is necessary to reorder bookmarks within the // right tree. COPY and LINK are necessary for drags to the @@ -559,13 +559,13 @@ GtkWidget* BookmarkManagerGtk::MakeRightPane() { // as a drag destination unless it corresponds to the contents of a folder. // See BuildRightStore(). g_signal_connect(right_tree_view_, "drag-data-get", - G_CALLBACK(&OnRightTreeViewDragGet), this); + G_CALLBACK(OnRightTreeViewDragGetThunk), this); g_signal_connect(right_tree_view_, "drag-data-received", - G_CALLBACK(&OnRightTreeViewDragReceived), this); + G_CALLBACK(OnRightTreeViewDragReceivedThunk), this); g_signal_connect(right_tree_view_, "drag-motion", - G_CALLBACK(&OnRightTreeViewDragMotion), this); + G_CALLBACK(OnRightTreeViewDragMotionThunk), this); g_signal_connect(right_tree_view_, "drag-begin", - G_CALLBACK(&OnRightTreeViewDragBegin), this); + G_CALLBACK(OnRightTreeViewDragBeginThunk), this); GtkWidget* scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), @@ -897,7 +897,7 @@ void BookmarkManagerGtk::PerformSearch() { } } -void BookmarkManagerGtk::OnSearchTextChanged() { +void BookmarkManagerGtk::OnSearchTextChanged(GtkWidget* widget) { search_factory_.RevokeAll(); MessageLoop::current()->PostDelayedTask(FROM_HERE, search_factory_.NewRunnableMethod(&BookmarkManagerGtk::PerformSearch), @@ -931,7 +931,6 @@ void BookmarkManagerGtk::OnRightSelectionChanged(GtkTreeSelection* selection, bm->ResetOrganizeMenu(false); } -// static void BookmarkManagerGtk::OnLeftTreeViewDragReceived( GtkWidget* tree_view, GdkDragContext* context, @@ -939,15 +938,14 @@ void BookmarkManagerGtk::OnLeftTreeViewDragReceived( gint y, GtkSelectionData* selection_data, guint target_type, - guint time, - BookmarkManagerGtk* bm) { + guint time) { gboolean get_nodes_success = FALSE; gboolean delete_selection_data = FALSE; std::vector<const BookmarkNode*> nodes = bookmark_utils::GetNodesFromSelection(context, selection_data, target_type, - bm->profile_, + profile_, &delete_selection_data, &get_nodes_success); @@ -966,9 +964,8 @@ void BookmarkManagerGtk::OnLeftTreeViewDragReceived( } GtkTreeIter iter; - gtk_tree_model_get_iter(GTK_TREE_MODEL(bm->left_store_), &iter, path); - const BookmarkNode* folder = - bm->GetNodeAt(GTK_TREE_MODEL(bm->left_store_), &iter); + gtk_tree_model_get_iter(GTK_TREE_MODEL(left_store_), &iter, path); + const BookmarkNode* folder = GetNodeAt(GTK_TREE_MODEL(left_store_), &iter); gboolean dnd_success = FALSE; if (folder) { @@ -976,7 +973,7 @@ void BookmarkManagerGtk::OnLeftTreeViewDragReceived( it != nodes.end(); ++it) { // Don't try to drop a node into one of its descendants. if (!folder->HasAncestor(*it)) { - bm->model_->Move(*it, folder, folder->GetChildCount()); + model_->Move(*it, folder, folder->GetChildCount()); dnd_success = TRUE; } } @@ -987,14 +984,12 @@ void BookmarkManagerGtk::OnLeftTreeViewDragReceived( time); } -// static gboolean BookmarkManagerGtk::OnLeftTreeViewDragMotion( GtkWidget* tree_view, GdkDragContext* context, gint x, gint y, - guint time, - BookmarkManagerGtk* bm) { + guint time) { GtkTreePath* path; GtkTreeViewDropPosition pos; gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y, @@ -1005,7 +1000,7 @@ gboolean BookmarkManagerGtk::OnLeftTreeViewDragMotion( GtkTreeIter iter; GtkTreeModel* model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view)); gtk_tree_model_get_iter(model, &iter, path); - if (bm->GetNodeAt(model, &iter) == NULL) + if (GetNodeAt(model, &iter) == NULL) return FALSE; // Only allow INTO. @@ -1023,41 +1018,36 @@ gboolean BookmarkManagerGtk::OnLeftTreeViewDragMotion( return TRUE; } -// static void BookmarkManagerGtk::OnLeftTreeViewRowCollapsed( - GtkTreeView *tree_view, + GtkWidget* tree_view, GtkTreeIter* iter, - GtkTreePath* path, - BookmarkManagerGtk* bm) { + GtkTreePath* path) { // If a selection still exists, do nothing. - if (gtk_tree_selection_get_selected(bm->left_selection(), NULL, NULL)) + if (gtk_tree_selection_get_selected(left_selection(), NULL, NULL)) return; - gtk_tree_selection_select_path(bm->left_selection(), path); + gtk_tree_selection_select_path(left_selection(), path); } -// static void BookmarkManagerGtk::OnRightTreeViewDragGet( GtkWidget* tree_view, GdkDragContext* context, GtkSelectionData* selection_data, guint target_type, - guint time, - BookmarkManagerGtk* bm) { + guint time) { // No selection, do nothing. This shouldn't get hit, but if it does an early // return avoids a crash. - if (gtk_tree_selection_count_selected_rows(bm->right_selection()) == 0) { + if (gtk_tree_selection_count_selected_rows(right_selection()) == 0) { NOTREACHED(); return; } - bookmark_utils::WriteBookmarksToSelection(bm->GetRightSelection(), + bookmark_utils::WriteBookmarksToSelection(GetRightSelection(), selection_data, target_type, - bm->profile_); + profile_); } -// static void BookmarkManagerGtk::OnRightTreeViewDragReceived( GtkWidget* tree_view, GdkDragContext* context, @@ -1065,15 +1055,14 @@ void BookmarkManagerGtk::OnRightTreeViewDragReceived( gint y, GtkSelectionData* selection_data, guint target_type, - guint time, - BookmarkManagerGtk* bm) { + guint time) { gboolean dnd_success = FALSE; gboolean delete_selection_data = FALSE; std::vector<const BookmarkNode*> nodes = bookmark_utils::GetNodesFromSelection(context, selection_data, target_type, - bm->profile_, + profile_, &delete_selection_data, &dnd_success); @@ -1097,9 +1086,9 @@ void BookmarkManagerGtk::OnRightTreeViewDragReceived( // |path| will be null when we are looking at an empty folder. if (!drop_before && !drop_after && path) { GtkTreeIter iter; - GtkTreeModel* model = GTK_TREE_MODEL(bm->right_store_); + GtkTreeModel* model = GTK_TREE_MODEL(right_store_); gtk_tree_model_get_iter(model, &iter, path); - const BookmarkNode* node = bm->GetNodeAt(model, &iter); + const BookmarkNode* node = GetNodeAt(model, &iter); if (node && node->is_folder()) { parent = node; idx = parent->GetChildCount(); @@ -1113,7 +1102,7 @@ void BookmarkManagerGtk::OnRightTreeViewDragReceived( if (path && drop_after) gtk_tree_path_next(path); // We will get a null path when the drop is below the lowest row. - parent = bm->GetFolder(); + parent = GetFolder(); idx = !path ? parent->GetChildCount() : gtk_tree_path_get_indices(path)[0]; } @@ -1121,7 +1110,7 @@ void BookmarkManagerGtk::OnRightTreeViewDragReceived( it != nodes.end(); ++it) { // Don't try to drop a node into one of its descendants. if (!parent->HasAncestor(*it)) { - bm->model_->Move(*it, parent, idx); + model_->Move(*it, parent, idx); idx = parent->IndexOfChild(*it) + 1; } } @@ -1130,28 +1119,24 @@ void BookmarkManagerGtk::OnRightTreeViewDragReceived( gtk_drag_finish(context, dnd_success, delete_selection_data, time); } -// static void BookmarkManagerGtk::OnRightTreeViewDragBegin( GtkWidget* tree_view, - GdkDragContext* drag_context, - BookmarkManagerGtk* bm) { + GdkDragContext* drag_context) { gtk_drag_set_icon_stock(drag_context, GTK_STOCK_DND, 0, 0); } -// static gboolean BookmarkManagerGtk::OnRightTreeViewDragMotion( GtkWidget* tree_view, GdkDragContext* context, gint x, gint y, - guint time, - BookmarkManagerGtk* bm) { + guint time) { GtkTreePath* path; GtkTreeViewDropPosition pos; gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y, &path, &pos); - const BookmarkNode* parent = bm->GetFolder(); + const BookmarkNode* parent = GetFolder(); if (path) { int idx = gtk_tree_path_get_indices(path)[gtk_tree_path_get_depth(path) - 1]; @@ -1172,40 +1157,32 @@ gboolean BookmarkManagerGtk::OnRightTreeViewDragMotion( return TRUE; } -// static void BookmarkManagerGtk::OnRightTreeViewRowActivated( - GtkTreeView* tree_view, + GtkWidget* tree_view, GtkTreePath* path, - GtkTreeViewColumn* column, - BookmarkManagerGtk* bm) { - std::vector<const BookmarkNode*> nodes = bm->GetRightSelection(); + GtkTreeViewColumn* column) { + std::vector<const BookmarkNode*> nodes = GetRightSelection(); if (nodes.empty()) return; if (nodes.size() == 1 && nodes[0]->is_folder()) { // Double click on a folder descends into the folder. - bm->SelectInTree(nodes[0], false); + SelectInTree(nodes[0], false); return; } - bookmark_utils::OpenAll(GTK_WINDOW(bm->window_), bm->profile_, NULL, nodes, + bookmark_utils::OpenAll(GTK_WINDOW(window_), profile_, NULL, nodes, CURRENT_TAB); } -// static -void BookmarkManagerGtk::OnLeftTreeViewFocusIn( - GtkTreeView* tree_view, - GdkEventFocus* event, - BookmarkManagerGtk* bm) { - if (!bm->organize_is_for_left_) - bm->ResetOrganizeMenu(true); +void BookmarkManagerGtk::OnLeftTreeViewFocusIn(GtkWidget* tree_view, + GdkEventFocus* event) { + if (!organize_is_for_left_) + ResetOrganizeMenu(true); } -// static -void BookmarkManagerGtk::OnRightTreeViewFocusIn( - GtkTreeView* tree_view, - GdkEventFocus* event, - BookmarkManagerGtk* bm) { - if (bm->organize_is_for_left_) - bm->ResetOrganizeMenu(false); +void BookmarkManagerGtk::OnRightTreeViewFocusIn(GtkWidget* tree_view, + GdkEventFocus* event) { + if (organize_is_for_left_) + ResetOrganizeMenu(false); } // We do a couple things in this handler. @@ -1224,12 +1201,10 @@ void BookmarkManagerGtk::OnRightTreeViewFocusIn( // We return TRUE for when we want to ignore events (i.e., stop the default // handler from handling them), and FALSE for when we want to continue // propagation. -// -// static gboolean BookmarkManagerGtk::OnRightTreeViewButtonPress( - GtkWidget* tree_view, GdkEventButton* event, BookmarkManagerGtk* bm) { + GtkWidget* tree_view, GdkEventButton* event) { // Always let cached mousedown events through. - if (bm->sending_delayed_mousedown_) + if (sending_delayed_mousedown_) return FALSE; if (event->button != 1) @@ -1238,8 +1213,8 @@ gboolean BookmarkManagerGtk::OnRightTreeViewButtonPress( // If a user double clicks, we will get two button presses in a row without // any intervening mouse up, hence we must flush delayed mousedowns here as // well as in the button release handler. - if (bm->delaying_mousedown_) { - bm->SendDelayedMousedown(); + if (delaying_mousedown_) { + SendDelayedMousedown(); return FALSE; } @@ -1261,13 +1236,13 @@ gboolean BookmarkManagerGtk::OnRightTreeViewButtonPress( if (path == NULL) { // Checking that the widget already has focus matches libegg behavior. if (GTK_WIDGET_HAS_FOCUS(tree_view)) - gtk_tree_selection_unselect_all(bm->right_selection()); + gtk_tree_selection_unselect_all(right_selection()); return FALSE; } - if (gtk_tree_selection_path_is_selected(bm->right_selection(), path)) { - bm->mousedown_event_ = *event; - bm->delaying_mousedown_ = true; + if (gtk_tree_selection_path_is_selected(right_selection(), path)) { + mousedown_event_ = *event; + delaying_mousedown_ = true; gtk_tree_path_free(path); return TRUE; } @@ -1276,24 +1251,23 @@ gboolean BookmarkManagerGtk::OnRightTreeViewButtonPress( return FALSE; } -// static gboolean BookmarkManagerGtk::OnRightTreeViewMotion( - GtkWidget* tree_view, GdkEventMotion* event, BookmarkManagerGtk* bm) { + GtkWidget* tree_view, GdkEventMotion* event) { // Swallow motion events when no row is selected. This prevents the initiation // of empty drags. - if (gtk_tree_selection_count_selected_rows(bm->right_selection()) == 0) + if (gtk_tree_selection_count_selected_rows(right_selection()) == 0) return TRUE; // Otherwise this handler is only used for the multi-drag workaround. - if (!bm->delaying_mousedown_) + if (!delaying_mousedown_) return FALSE; if (gtk_drag_check_threshold(tree_view, - static_cast<gint>(bm->mousedown_event_.x), - static_cast<gint>(bm->mousedown_event_.y), + static_cast<gint>(mousedown_event_.x), + static_cast<gint>(mousedown_event_.y), static_cast<gint>(event->x), static_cast<gint>(event->y))) { - bm->delaying_mousedown_ = false; + delaying_mousedown_ = false; GtkTargetList* targets = gtk_dnd_util::GetTargetListFromCodeMask( bookmark_utils::GetCodeMask(false)); gtk_drag_begin(tree_view, targets, GDK_ACTION_MOVE, @@ -1305,39 +1279,36 @@ gboolean BookmarkManagerGtk::OnRightTreeViewMotion( return FALSE; } -// static gboolean BookmarkManagerGtk::OnTreeViewButtonPress( - GtkWidget* tree_view, GdkEventButton* button, BookmarkManagerGtk* bm) { + GtkWidget* tree_view, GdkEventButton* button) { if (button->button != 3) return FALSE; - if (bm->ignore_rightclicks_) + if (ignore_rightclicks_) return FALSE; // If the cursor is not hovering over a selected row, let it propagate // to the default handler so that a selection change may occur. if (!CursorIsOverSelection(GTK_TREE_VIEW(tree_view))) { - bm->ignore_rightclicks_ = true; + ignore_rightclicks_ = true; gtk_propagate_event(tree_view, reinterpret_cast<GdkEvent*>(button)); - bm->ignore_rightclicks_ = false; + ignore_rightclicks_ = false; } - bm->context_menu_->PopupAsContext(button->time); + context_menu_->PopupAsContext(button->time); return TRUE; } -// static gboolean BookmarkManagerGtk::OnTreeViewButtonRelease( - GtkWidget* tree_view, GdkEventButton* button, BookmarkManagerGtk* bm) { - if (bm->delaying_mousedown_ && (tree_view == bm->right_tree_view_)) - bm->SendDelayedMousedown(); + GtkWidget* tree_view, GdkEventButton* button) { + if (delaying_mousedown_ && (tree_view == right_tree_view_)) + SendDelayedMousedown(); return FALSE; } -// static -gboolean BookmarkManagerGtk::OnTreeViewKeyPress( - GtkWidget* tree_view, GdkEventKey* key, BookmarkManagerGtk* bm) { +gboolean BookmarkManagerGtk::OnTreeViewKeyPress(GtkWidget* tree_view, + GdkEventKey* key) { int command = -1; if ((key->state & gtk_accelerator_get_default_mod_mask()) == @@ -1369,9 +1340,9 @@ gboolean BookmarkManagerGtk::OnTreeViewKeyPress( if (command == -1) return FALSE; - if (bm->organize_menu_controller_.get() && - bm->organize_menu_controller_->IsCommandIdEnabled(command)) { - bm->organize_menu_controller_->ExecuteCommand(command); + if (organize_menu_controller_.get() && + organize_menu_controller_->IsCommandIdEnabled(command)) { + organize_menu_controller_->ExecuteCommand(command); return TRUE; } @@ -1392,24 +1363,20 @@ void BookmarkManagerGtk::OnFolderNameEdited(GtkCellRendererText* render, UTF8ToWide(new_folder_name)); } -// static -void BookmarkManagerGtk::OnImportItemActivated( - GtkMenuItem* menuitem, BookmarkManagerGtk* bm) { +void BookmarkManagerGtk::OnImportItemActivated(GtkWidget* menuitem) { SelectFileDialog::FileTypeInfo file_type_info; file_type_info.extensions.resize(1); file_type_info.extensions[0].push_back(FILE_PATH_LITERAL("html")); file_type_info.extensions[0].push_back(FILE_PATH_LITERAL("htm")); file_type_info.include_all_files = true; - bm->select_file_dialog_->SelectFile( + select_file_dialog_->SelectFile( SelectFileDialog::SELECT_OPEN_FILE, string16(), FilePath(""), &file_type_info, 0, - std::string(), GTK_WINDOW(bm->window_), + std::string(), GTK_WINDOW(window_), reinterpret_cast<void*>(IDS_BOOKMARK_MANAGER_IMPORT_MENU)); } -// static -void BookmarkManagerGtk::OnExportItemActivated( - GtkMenuItem* menuitem, BookmarkManagerGtk* bm) { +void BookmarkManagerGtk::OnExportItemActivated(GtkWidget* menuitem) { SelectFileDialog::FileTypeInfo file_type_info; file_type_info.extensions.resize(1); file_type_info.extensions[0].push_back(FILE_PATH_LITERAL("html")); @@ -1420,22 +1387,20 @@ void BookmarkManagerGtk::OnExportItemActivated( // save locations differently for different user tasks. FilePath suggested_path; PathService::Get(chrome::DIR_USER_DATA, &suggested_path); - bm->select_file_dialog_->SelectFile( + select_file_dialog_->SelectFile( SelectFileDialog::SELECT_SAVEAS_FILE, string16(), suggested_path.Append("bookmarks.html"), &file_type_info, 0, - "html", GTK_WINDOW(bm->window_), + "html", GTK_WINDOW(window_), reinterpret_cast<void*>(IDS_BOOKMARK_MANAGER_EXPORT_MENU)); } -// static -void BookmarkManagerGtk::OnSyncStatusMenuActivated(GtkMenuItem* menu_item, - BookmarkManagerGtk* bm) { - if (bm->sync_relogin_required_) { - DCHECK(bm->sync_service_); - bm->sync_service_->ShowLoginDialog(); +void BookmarkManagerGtk::OnSyncStatusMenuActivated(GtkWidget* menu_item) { + if (sync_relogin_required_) { + DCHECK(sync_service_); + sync_service_->ShowLoginDialog(); } else { sync_ui_util::OpenSyncMyBookmarksDialog( - bm->profile_, ProfileSyncService::START_FROM_BOOKMARK_MANAGER); + profile_, ProfileSyncService::START_FROM_BOOKMARK_MANAGER); } } diff --git a/chrome/browser/gtk/bookmark_manager_gtk.h b/chrome/browser/gtk/bookmark_manager_gtk.h index 8ade7f5..0349ceb 100644 --- a/chrome/browser/gtk/bookmark_manager_gtk.h +++ b/chrome/browser/gtk/bookmark_manager_gtk.h @@ -8,6 +8,7 @@ #include <gtk/gtk.h> #include <vector> +#include "app/gtk_signal.h" #include "base/basictypes.h" #include "base/ref_counted.h" #include "base/task.h" @@ -166,12 +167,7 @@ class BookmarkManagerGtk : public BookmarkModelObserver, // Search helpers. void PerformSearch(); - void OnSearchTextChanged(); - - static void OnSearchTextChangedThunk(GtkWidget* search_entry, - BookmarkManagerGtk* bookmark_manager) { - bookmark_manager->OnSearchTextChanged(); - } + CHROMEGTK_CALLBACK_0(BookmarkManagerGtk, void, OnSearchTextChanged); // TreeView signal handlers. static void OnLeftSelectionChanged(GtkTreeSelection* selection, @@ -180,86 +176,42 @@ class BookmarkManagerGtk : public BookmarkModelObserver, static void OnRightSelectionChanged(GtkTreeSelection* selection, BookmarkManagerGtk* bm); - static void OnLeftTreeViewDragReceived(GtkWidget* tree_view, - GdkDragContext* context, - gint x, - gint y, - GtkSelectionData* selection_data, - guint target_type, - guint time, - BookmarkManagerGtk* bm); - - static gboolean OnLeftTreeViewDragMotion(GtkWidget* tree_view, - GdkDragContext* context, - gint x, - gint y, - guint time, - BookmarkManagerGtk* bm); - - static void OnLeftTreeViewRowCollapsed(GtkTreeView* tree_view, - GtkTreeIter* iter, - GtkTreePath* path, - BookmarkManagerGtk* bm); - - static void OnRightTreeViewDragGet(GtkWidget* tree_view, - GdkDragContext* context, - GtkSelectionData* selection_data, - guint target_type, - guint time, - BookmarkManagerGtk* bm); - - static void OnRightTreeViewDragReceived(GtkWidget* tree_view, - GdkDragContext* context, - gint x, - gint y, - GtkSelectionData* selection_data, - guint target_type, - guint time, - BookmarkManagerGtk* bm); - - static void OnRightTreeViewDragBegin(GtkWidget* tree_view, - GdkDragContext* drag_context, - BookmarkManagerGtk* bm); - - static gboolean OnRightTreeViewDragMotion(GtkWidget* tree_view, - GdkDragContext* context, - gint x, - gint y, - guint time, - BookmarkManagerGtk* bm); - - static void OnRightTreeViewRowActivated(GtkTreeView* tree_view, - GtkTreePath* path, - GtkTreeViewColumn* column, - BookmarkManagerGtk* bm); - - static void OnRightTreeViewFocusIn(GtkTreeView* tree_view, - GdkEventFocus* event, - BookmarkManagerGtk* bm); - - static void OnLeftTreeViewFocusIn(GtkTreeView* tree_view, - GdkEventFocus* event, - BookmarkManagerGtk* bm); - - static gboolean OnRightTreeViewButtonPress(GtkWidget* tree_view, - GdkEventButton* event, - BookmarkManagerGtk* bm); - - static gboolean OnRightTreeViewMotion(GtkWidget* tree_view, - GdkEventMotion* event, - BookmarkManagerGtk* bm); - - static gboolean OnTreeViewButtonPress(GtkWidget* tree_view, - GdkEventButton* button, - BookmarkManagerGtk* bm); - - static gboolean OnTreeViewButtonRelease(GtkWidget* tree_view, - GdkEventButton* button, - BookmarkManagerGtk* bm); - - static gboolean OnTreeViewKeyPress(GtkWidget* tree_view, - GdkEventKey* key, - BookmarkManagerGtk* bm); + CHROMEGTK_CALLBACK_6(BookmarkManagerGtk, void, OnLeftTreeViewDragReceived, + GdkDragContext*, gint, gint, GtkSelectionData*, + guint, guint); + CHROMEGTK_CALLBACK_4(BookmarkManagerGtk, gboolean, OnLeftTreeViewDragMotion, + GdkDragContext*, gint, gint, guint); + + CHROMEGTK_CALLBACK_2(BookmarkManagerGtk, void, OnLeftTreeViewRowCollapsed, + GtkTreeIter*, GtkTreePath*); + CHROMEGTK_CALLBACK_4(BookmarkManagerGtk, void, OnRightTreeViewDragGet, + GdkDragContext*, GtkSelectionData*, guint, guint); + + CHROMEGTK_CALLBACK_6(BookmarkManagerGtk, void, OnRightTreeViewDragReceived, + GdkDragContext*, gint, gint, GtkSelectionData*, + guint, guint); + CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, void, OnRightTreeViewDragBegin, + GdkDragContext*); + CHROMEGTK_CALLBACK_4(BookmarkManagerGtk, gboolean, OnRightTreeViewDragMotion, + GdkDragContext*, gint, gint, guint); + + CHROMEGTK_CALLBACK_2(BookmarkManagerGtk, void, OnRightTreeViewRowActivated, + GtkTreePath*, GtkTreeViewColumn*); + CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, void, OnRightTreeViewFocusIn, + GdkEventFocus*); + CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, void, OnLeftTreeViewFocusIn, + GdkEventFocus*); + CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, gboolean, OnRightTreeViewButtonPress, + GdkEventButton*); + + CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, gboolean, OnRightTreeViewMotion, + GdkEventMotion*); + CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, gboolean, OnTreeViewButtonPress, + GdkEventButton*); + CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, gboolean, OnTreeViewButtonRelease, + GdkEventButton*); + CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, gboolean, OnTreeViewKeyPress, + GdkEventKey*); // Callback from inline edits to folder names. This changes the name in the // model. @@ -269,37 +221,18 @@ class BookmarkManagerGtk : public BookmarkModelObserver, BookmarkManagerGtk* bm); // Tools menu item callbacks. - static void OnImportItemActivated(GtkMenuItem* menuitem, - BookmarkManagerGtk* bm); - static void OnExportItemActivated(GtkMenuItem* menuitem, - BookmarkManagerGtk* bm); + CHROMEGTK_CALLBACK_0(BookmarkManagerGtk, void, OnImportItemActivated); + CHROMEGTK_CALLBACK_0(BookmarkManagerGtk, void, OnExportItemActivated); // Sync status menu item callback. - static void OnSyncStatusMenuActivated(GtkMenuItem* menu_item, - BookmarkManagerGtk* bm); + CHROMEGTK_CALLBACK_0(BookmarkManagerGtk, void, OnSyncStatusMenuActivated); // Window callbacks. - static gboolean OnWindowDestroyedThunk(GtkWidget* window, gpointer self) { - return reinterpret_cast<BookmarkManagerGtk*>(self)-> - OnWindowDestroyed(window); - } - gboolean OnWindowDestroyed(GtkWidget* window); - - static gboolean OnWindowStateChangedThunk(GtkWidget* window, - GdkEventWindowState* event, - gpointer self) { - return reinterpret_cast<BookmarkManagerGtk*>(self)-> - OnWindowStateChanged(window, event); - } - gboolean OnWindowStateChanged(GtkWidget* window, GdkEventWindowState* event); - - static gboolean OnWindowConfiguredThunk(GtkWidget* window, - GdkEventConfigure* event, - gpointer self) { - return reinterpret_cast<BookmarkManagerGtk*>(self)-> - OnWindowConfigured(window, event); - } - gboolean OnWindowConfigured(GtkWidget* window, GdkEventConfigure* event); + CHROMEGTK_CALLBACK_0(BookmarkManagerGtk, gboolean, OnWindowDestroyed); + CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, gboolean, OnWindowStateChanged, + GdkEventWindowState*); + CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, gboolean, OnWindowConfigured, + GdkEventConfigure*); // Handles an accelerator being pressed. static gboolean OnGtkAccelerator(GtkAccelGroup* accel_group, diff --git a/chrome/browser/gtk/bookmark_menu_controller_gtk.cc b/chrome/browser/gtk/bookmark_menu_controller_gtk.cc index 52eba7f..4f5c76f 100644 --- a/chrome/browser/gtk/bookmark_menu_controller_gtk.cc +++ b/chrome/browser/gtk/bookmark_menu_controller_gtk.cc @@ -100,7 +100,7 @@ BookmarkMenuController::BookmarkMenuController(Browser* browser, menu_ = gtk_menu_new(); BuildMenu(node, start_child_index, menu_); g_signal_connect(menu_, "hide", - G_CALLBACK(OnMenuHidden), this); + G_CALLBACK(OnMenuHiddenThunk), this); gtk_widget_show_all(menu_); } @@ -158,7 +158,7 @@ void BookmarkMenuController::BuildMenu(const BookmarkNode* parent, start_child_index < parent->GetChildCount()); g_signal_connect(menu, "button-press-event", - G_CALLBACK(OnButtonPressed), this); + G_CALLBACK(OnButtonPressedThunk), this); for (int i = start_child_index; i < parent->GetChildCount(); ++i) { const BookmarkNode* node = parent->GetChild(i); @@ -174,10 +174,10 @@ void BookmarkMenuController::BuildMenu(const BookmarkNode* parent, gtk_util::SetAlwaysShowImage(menu_item); g_signal_connect(menu_item, "button-release-event", - G_CALLBACK(OnButtonReleased), this); + G_CALLBACK(OnButtonReleasedThunk), this); if (node->is_url()) { g_signal_connect(menu_item, "activate", - G_CALLBACK(OnMenuItemActivated), this); + G_CALLBACK(OnMenuItemActivatedThunk), this); } else if (node->is_folder()) { GtkWidget* submenu = gtk_menu_new(); BuildMenu(node, 0, submenu); @@ -193,18 +193,18 @@ void BookmarkMenuController::BuildMenu(const BookmarkNode* parent, target_mask |= gtk_dnd_util::TEXT_URI_LIST | gtk_dnd_util::NETSCAPE_URL; gtk_dnd_util::SetSourceTargetListFromCodeMask(menu_item, target_mask); g_signal_connect(menu_item, "drag-begin", - G_CALLBACK(&OnMenuItemDragBegin), this); + G_CALLBACK(OnMenuItemDragBeginThunk), this); g_signal_connect(menu_item, "drag-end", - G_CALLBACK(&OnMenuItemDragEnd), this); + G_CALLBACK(OnMenuItemDragEndThunk), this); g_signal_connect(menu_item, "drag-data-get", - G_CALLBACK(&OnMenuItemDragGet), this); + G_CALLBACK(OnMenuItemDragGetThunk), this); // It is important to connect to this signal after setting up the drag // source because we only want to stifle the menu's default handler and // not the handler that the drag source uses. if (node->is_folder()) { g_signal_connect(menu_item, "button-press-event", - G_CALLBACK(OnFolderButtonPressed), this); + G_CALLBACK(OnFolderButtonPressedThunk), this); } gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item); @@ -220,20 +220,17 @@ void BookmarkMenuController::BuildMenu(const BookmarkNode* parent, } } -// static gboolean BookmarkMenuController::OnButtonPressed( GtkWidget* sender, - GdkEventButton* event, - BookmarkMenuController* controller) { - controller->ignore_button_release_ = false; + GdkEventButton* event) { + ignore_button_release_ = false; GtkMenuShell* menu_shell = GTK_MENU_SHELL(sender); if (event->button == 3) { // If the cursor is outside our bounds, pass this event up to the parent. if (!gtk_util::WidgetContainsCursor(sender)) { if (menu_shell->parent_menu_shell) { - return OnButtonPressed(menu_shell->parent_menu_shell, event, - controller); + return OnButtonPressed(menu_shell->parent_menu_shell, event); } else { // We are the top level menu; we can propagate no further. return FALSE; @@ -259,36 +256,34 @@ gboolean BookmarkMenuController::OnButtonPressed( std::vector<const BookmarkNode*> nodes; if (node) nodes.push_back(node); - controller->context_menu_controller_.reset( + context_menu_controller_.reset( new BookmarkContextMenuController( - controller->parent_window_, controller, controller->profile_, - controller->page_navigator_, parent, nodes, + parent_window_, this, profile_, + page_navigator_, parent, nodes, BookmarkContextMenuController::BOOKMARK_BAR)); - controller->context_menu_.reset( - new MenuGtk(NULL, controller->context_menu_controller_->menu_model())); + context_menu_.reset( + new MenuGtk(NULL, context_menu_controller_->menu_model())); // Our bookmark folder menu loses the grab to the context menu. When the // context menu is hidden, re-assert our grab. GtkWidget* grabbing_menu = gtk_grab_get_current(); g_object_ref(grabbing_menu); - g_signal_connect(controller->context_menu_->widget(), "hide", + g_signal_connect(context_menu_->widget(), "hide", G_CALLBACK(OnContextMenuHide), grabbing_menu); - controller->context_menu_->PopupAsContext(event->time); + context_menu_->PopupAsContext(event->time); return TRUE; } return FALSE; } -// static gboolean BookmarkMenuController::OnButtonReleased( GtkWidget* sender, - GdkEventButton* event, - BookmarkMenuController* controller) { - if (controller->ignore_button_release_) { + GdkEventButton* event) { + if (ignore_button_release_) { // Don't handle this message; it was a drag. - controller->ignore_button_release_ = false; + ignore_button_release_ = false; return FALSE; } @@ -298,11 +293,11 @@ gboolean BookmarkMenuController::OnButtonReleased( if (event->button == 1 || event->button == 2) { WindowOpenDisposition disposition = event_utils::DispositionFromEventFlags(event->state); - controller->NavigateToMenuItem(sender, disposition); + NavigateToMenuItem(sender, disposition); // We need to manually dismiss the popup menu because we're overriding // button-release-event. - gtk_menu_popdown(GTK_MENU(controller->menu_)); + gtk_menu_popdown(GTK_MENU(menu_)); return TRUE; } } else { @@ -317,49 +312,36 @@ gboolean BookmarkMenuController::OnButtonReleased( return FALSE; } -// static gboolean BookmarkMenuController::OnFolderButtonPressed( - GtkWidget* sender, - GdkEventButton* event, - BookmarkMenuController* controller) { + GtkWidget* sender, GdkEventButton* event) { // The button press may start a drag; don't let the default handler run. if (event->button == 1) return TRUE; return FALSE; } -// static -void BookmarkMenuController::OnMenuHidden(GtkWidget* menu, - BookmarkMenuController* controller) { - if (controller->triggering_widget_) { - gtk_chrome_button_unset_paint_state( - GTK_CHROME_BUTTON(controller->triggering_widget_)); - } +void BookmarkMenuController::OnMenuHidden(GtkWidget* menu) { + if (triggering_widget_) + gtk_chrome_button_unset_paint_state(GTK_CHROME_BUTTON(triggering_widget_)); } -// static -void BookmarkMenuController::OnMenuItemActivated( - GtkMenuItem* menu_item, BookmarkMenuController* controller) { - controller->NavigateToMenuItem(GTK_WIDGET(menu_item), CURRENT_TAB); +void BookmarkMenuController::OnMenuItemActivated(GtkWidget* menu_item) { + NavigateToMenuItem(menu_item, CURRENT_TAB); } -// static -void BookmarkMenuController::OnMenuItemDragBegin( - GtkWidget* menu_item, - GdkDragContext* drag_context, - BookmarkMenuController* controller) { +void BookmarkMenuController::OnMenuItemDragBegin(GtkWidget* menu_item, + GdkDragContext* drag_context) { // The parent menu item might be removed during the drag. Ref it so |button| // won't get destroyed. g_object_ref(menu_item->parent); // Signal to any future OnButtonReleased calls that we're dragging instead of // pressing. - controller->ignore_button_release_ = true; + ignore_button_release_ = true; const BookmarkNode* node = bookmark_utils::BookmarkNodeForWidget(menu_item); GtkWidget* window = bookmark_utils::GetDragRepresentation( - node, controller->model_, - GtkThemeProvider::GetFrom(controller->profile_)); + node, model_, GtkThemeProvider::GetFrom(profile_)); gint x, y; gtk_widget_get_pointer(menu_item, &x, &y); gtk_drag_set_icon_widget(drag_context, window, x, y); @@ -368,22 +350,17 @@ void BookmarkMenuController::OnMenuItemDragBegin( gtk_widget_hide(menu_item); } -// static -void BookmarkMenuController::OnMenuItemDragEnd( - GtkWidget* menu_item, - GdkDragContext* drag_context, - BookmarkMenuController* controller) { +void BookmarkMenuController::OnMenuItemDragEnd(GtkWidget* menu_item, + GdkDragContext* drag_context) { gtk_widget_show(menu_item); g_object_unref(menu_item->parent); } -// static void BookmarkMenuController::OnMenuItemDragGet( GtkWidget* widget, GdkDragContext* context, GtkSelectionData* selection_data, - guint target_type, guint time, - BookmarkMenuController* controller) { + guint target_type, guint time) { const BookmarkNode* node = bookmark_utils::BookmarkNodeForWidget(widget); bookmark_utils::WriteBookmarkToSelection(node, selection_data, target_type, - controller->profile_); + profile_); } diff --git a/chrome/browser/gtk/bookmark_menu_controller_gtk.h b/chrome/browser/gtk/bookmark_menu_controller_gtk.h index ea68a78..843f556 100644 --- a/chrome/browser/gtk/bookmark_menu_controller_gtk.h +++ b/chrome/browser/gtk/bookmark_menu_controller_gtk.h @@ -9,6 +9,7 @@ #include <map> +#include "app/gtk_signal.h" #include "base/scoped_ptr.h" #include "chrome/browser/bookmarks/base_bookmark_model_observer.h" #include "chrome/browser/bookmarks/bookmark_context_menu_controller.h" @@ -67,41 +68,33 @@ class BookmarkMenuController : public BaseBookmarkModelObserver, // respectively. We have to override these separate from OnMenuItemActivated // because we need to handle right clicks and opening bookmarks with // different dispositions. - static gboolean OnButtonPressed(GtkWidget* sender, - GdkEventButton* event, - BookmarkMenuController* controller); - static gboolean OnButtonReleased(GtkWidget* sender, - GdkEventButton* event, - BookmarkMenuController* controller); + CHROMEGTK_CALLBACK_1(BookmarkMenuController, gboolean, OnButtonPressed, + GdkEventButton*); + CHROMEGTK_CALLBACK_1(BookmarkMenuController, gboolean, OnButtonReleased, + GdkEventButton*); + // We connect this handler to the button-press-event signal for folder nodes. // It suppresses the normal behavior (popping up the submenu) to allow these // nodes to be draggable. The submenu is instead popped up on a // button-release-event. - static gboolean OnFolderButtonPressed(GtkWidget* sender, - GdkEventButton* event, - BookmarkMenuController* controller); + CHROMEGTK_CALLBACK_1(BookmarkMenuController, gboolean, OnFolderButtonPressed, + GdkEventButton*); // We have to stop drawing |triggering_widget_| as active when the menu // closes. - static void OnMenuHidden(GtkWidget* menu, BookmarkMenuController* controller); + CHROMEGTK_CALLBACK_0(BookmarkMenuController, void, OnMenuHidden) // We respond to the activate signal because things other than mouse button // events can trigger it. - static void OnMenuItemActivated(GtkMenuItem* menuitem, - BookmarkMenuController* controller); + CHROMEGTK_CALLBACK_0(BookmarkMenuController, void, OnMenuItemActivated); // The individual GtkMenuItems in the BookmarkMenu are all drag sources. - static void OnMenuItemDragBegin(GtkWidget* menu_item, - GdkDragContext* drag_context, - BookmarkMenuController* bar); - static void OnMenuItemDragEnd(GtkWidget* menu_item, - GdkDragContext* drag_context, - BookmarkMenuController* controller); - static void OnMenuItemDragGet( - GtkWidget* widget, GdkDragContext* context, - GtkSelectionData* selection_data, - guint target_type, guint time, - BookmarkMenuController* controller); + CHROMEGTK_CALLBACK_1(BookmarkMenuController, void, OnMenuItemDragBegin, + GdkDragContext*); + CHROMEGTK_CALLBACK_1(BookmarkMenuController, void, OnMenuItemDragEnd, + GdkDragContext*); + CHROMEGTK_CALLBACK_4(BookmarkMenuController, void, OnMenuItemDragGet, + GdkDragContext*, GtkSelectionData*, guint, guint); Browser* browser_; Profile* profile_; diff --git a/chrome/browser/gtk/external_protocol_dialog_gtk.cc b/chrome/browser/gtk/external_protocol_dialog_gtk.cc index 6be7e1a..cee608f 100644 --- a/chrome/browser/gtk/external_protocol_dialog_gtk.cc +++ b/chrome/browser/gtk/external_protocol_dialog_gtk.cc @@ -98,7 +98,8 @@ ExternalProtocolDialogGtk::ExternalProtocolDialogGtk(const GURL& url) gtk_widget_show_all(dialog_); } -void ExternalProtocolDialogGtk::OnDialogResponse(int response) { +void ExternalProtocolDialogGtk::OnDialogResponse(GtkWidget* widget, + int response) { if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbox_))) { if (response == GTK_RESPONSE_ACCEPT) { ExternalProtocolHandler::SetBlockState( diff --git a/chrome/browser/gtk/external_protocol_dialog_gtk.h b/chrome/browser/gtk/external_protocol_dialog_gtk.h index 748739a..c77b284 100644 --- a/chrome/browser/gtk/external_protocol_dialog_gtk.h +++ b/chrome/browser/gtk/external_protocol_dialog_gtk.h @@ -5,6 +5,7 @@ #ifndef CHROME_BROWSER_GTK_EXTERNAL_PROTOCOL_DIALOG_GTK_H_ #define CHROME_BROWSER_GTK_EXTERNAL_PROTOCOL_DIALOG_GTK_H_ +#include "app/gtk_signal.h" #include "base/time.h" #include "googleurl/src/gurl.h" @@ -17,12 +18,7 @@ class ExternalProtocolDialogGtk { explicit ExternalProtocolDialogGtk(const GURL& url); private: - static void OnDialogResponseThunk(GtkWidget* widget, - int response, - ExternalProtocolDialogGtk* dialog) { - dialog->OnDialogResponse(response); - } - void OnDialogResponse(int response); + CHROMEGTK_CALLBACK_1(ExternalProtocolDialogGtk, void, OnDialogResponse, int); GtkWidget* dialog_; GtkWidget* checkbox_; diff --git a/chrome/browser/tab_contents/tab_contents_view_gtk.cc b/chrome/browser/tab_contents/tab_contents_view_gtk.cc index b636757..b549ada 100644 --- a/chrome/browser/tab_contents/tab_contents_view_gtk.cc +++ b/chrome/browser/tab_contents/tab_contents_view_gtk.cc @@ -114,11 +114,11 @@ TabContentsViewGtk::TabContentsViewGtk(TabContents* tab_contents) constrained_window_(NULL) { gtk_widget_set_name(expanded_, "chrome-tab-contents-view"); g_signal_connect(expanded_, "size-allocate", - G_CALLBACK(OnSizeAllocate), this); + G_CALLBACK(OnSizeAllocateThunk), this); g_signal_connect(expanded_, "child-size-request", - G_CALLBACK(OnChildSizeRequest), this); + G_CALLBACK(OnChildSizeRequestThunk), this); g_signal_connect(floating_.get(), "set-floating-position", - G_CALLBACK(OnSetFloatingPosition), this); + G_CALLBACK(OnSetFloatingPositionThunk), this); gtk_container_add(GTK_CONTAINER(floating_.get()), expanded_); gtk_widget_show(expanded_); @@ -181,7 +181,7 @@ RenderWidgetHostView* TabContentsViewGtk::CreateViewForWidget( gtk_widget_add_events(content_view, GDK_LEAVE_NOTIFY_MASK | GDK_POINTER_MOTION_MASK); g_signal_connect(content_view, "button-press-event", - G_CALLBACK(OnMouseDown), this); + G_CALLBACK(OnMouseDownThunk), this); InsertIntoContentArea(content_view); // Renderer target DnD. @@ -340,51 +340,47 @@ void TabContentsViewGtk::InsertIntoContentArea(GtkWidget* widget) { } gboolean TabContentsViewGtk::OnMouseDown(GtkWidget* widget, - GdkEventButton* event, TabContentsViewGtk* view) { - view->last_mouse_down_ = *event; + GdkEventButton* event) { + last_mouse_down_ = *event; return FALSE; } void TabContentsViewGtk::OnChildSizeRequest(GtkWidget* widget, GtkWidget* child, - GtkRequisition* requisition, - TabContentsViewGtk* view) { - if (view->tab_contents()->delegate()) { + GtkRequisition* requisition) { + if (tab_contents()->delegate()) { requisition->height += - view->tab_contents()->delegate()->GetExtraRenderViewHeight(); + tab_contents()->delegate()->GetExtraRenderViewHeight(); } } void TabContentsViewGtk::OnSizeAllocate(GtkWidget* widget, - GtkAllocation* allocation, - TabContentsViewGtk* view) { + GtkAllocation* allocation) { int width = allocation->width; int height = allocation->height; // |delegate()| can be NULL here during browser teardown. - if (view->tab_contents()->delegate()) - height += view->tab_contents()->delegate()->GetExtraRenderViewHeight(); + if (tab_contents()->delegate()) + height += tab_contents()->delegate()->GetExtraRenderViewHeight(); gfx::Size size(width, height); - view->requested_size_ = size; + requested_size_ = size; // We manually tell our RWHV to resize the renderer content. This avoids // spurious resizes from GTK+. - RenderWidgetHostView* rwhv = view->tab_contents()->GetRenderWidgetHostView(); + RenderWidgetHostView* rwhv = tab_contents()->GetRenderWidgetHostView(); if (rwhv) rwhv->SetSize(size); - if (view->tab_contents()->interstitial_page()) - view->tab_contents()->interstitial_page()->SetSize(size); + if (tab_contents()->interstitial_page()) + tab_contents()->interstitial_page()->SetSize(size); } -// static void TabContentsViewGtk::OnSetFloatingPosition( - GtkFloatingContainer* floating_container, GtkAllocation* allocation, - TabContentsViewGtk* tab_contents_view) { + GtkWidget* floating_container, GtkAllocation* allocation) { // Place each ConstrainedWindow in the center of the view. int half_view_width = std::max((allocation->x + allocation->width) / 2, 0); int half_view_height = std::max((allocation->y + allocation->height) / 2, 0); - if (tab_contents_view->constrained_window_) { - GtkWidget* widget = tab_contents_view->constrained_window_->widget(); - DCHECK(widget->parent == tab_contents_view->floating_.get()); + if (constrained_window_) { + GtkWidget* widget = constrained_window_->widget(); + DCHECK(widget->parent == floating_.get()); GtkRequisition requisition; gtk_widget_size_request(widget, &requisition); diff --git a/chrome/browser/tab_contents/tab_contents_view_gtk.h b/chrome/browser/tab_contents/tab_contents_view_gtk.h index 1bded49b..4329165 100644 --- a/chrome/browser/tab_contents/tab_contents_view_gtk.h +++ b/chrome/browser/tab_contents/tab_contents_view_gtk.h @@ -7,6 +7,7 @@ #include <gtk/gtk.h> +#include "app/gtk_signal.h" #include "base/scoped_ptr.h" #include "chrome/browser/gtk/focus_store_gtk.h" #include "chrome/browser/tab_contents/tab_contents_view.h" @@ -80,25 +81,21 @@ class TabContentsViewGtk : public TabContentsView, void CancelDragIfAny(); // We keep track of the timestamp of the latest mousedown event. - static gboolean OnMouseDown(GtkWidget* widget, - GdkEventButton* event, TabContentsViewGtk* view); + CHROMEGTK_CALLBACK_1(TabContentsViewGtk, gboolean, OnMouseDown, + GdkEventButton*); // Used to adjust the size of its children when the size of |expanded_| is // changed. - static void OnChildSizeRequest(GtkWidget* widget, - GtkWidget* child, - GtkRequisition* requisition, - TabContentsViewGtk* view); + CHROMEGTK_CALLBACK_2(TabContentsViewGtk, void, OnChildSizeRequest, + GtkWidget*, GtkRequisition*); // Used to propagate the size change of |expanded_| to our RWHV to resize the // renderer content. - static void OnSizeAllocate(GtkWidget* widget, - GtkAllocation* allocation, - TabContentsViewGtk* view); + CHROMEGTK_CALLBACK_1(TabContentsViewGtk, void, OnSizeAllocate, + GtkAllocation*); - static void OnSetFloatingPosition( - GtkFloatingContainer* floating_container, GtkAllocation* allocation, - TabContentsViewGtk* tab_contents_view); + CHROMEGTK_CALLBACK_1(TabContentsViewGtk, void, OnSetFloatingPosition, + GtkAllocation*); // Contains |expanded_| as its GtkBin member. OwnedWidgetGtk floating_; |