| 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 "chrome/browser/ui/libgtk2ui/menu_util.h" | |
| 6 | |
| 7 #include "base/strings/utf_string_conversions.h" | |
| 8 #include "chrome/app/chrome_command_ids.h" | |
| 9 #include "chrome/browser/ui/libgtk2ui/gtk2_util.h" | |
| 10 #include "chrome/browser/ui/libgtk2ui/skia_utils_gtk2.h" | |
| 11 #include "ui/base/accelerators/accelerator.h" | |
| 12 #include "ui/base/accelerators/menu_label_accelerator_util_linux.h" | |
| 13 #include "ui/base/models/menu_model.h" | |
| 14 | |
| 15 G_GNUC_BEGIN_IGNORE_DEPRECATIONS | |
| 16 | |
| 17 namespace libgtk2ui { | |
| 18 | |
| 19 GtkWidget* BuildMenuItemWithImage(const std::string& label, GtkWidget* image) { | |
| 20 GtkWidget* menu_item = gtk_image_menu_item_new_with_mnemonic(label.c_str()); | |
| 21 gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item), image); | |
| 22 return menu_item; | |
| 23 } | |
| 24 | |
| 25 GtkWidget* BuildMenuItemWithImage(const std::string& label, | |
| 26 const gfx::Image& icon) { | |
| 27 GdkPixbuf* pixbuf = GdkPixbufFromSkBitmap(*icon.ToSkBitmap()); | |
| 28 | |
| 29 GtkWidget* menu_item = | |
| 30 BuildMenuItemWithImage(label, gtk_image_new_from_pixbuf(pixbuf)); | |
| 31 g_object_unref(pixbuf); | |
| 32 return menu_item; | |
| 33 } | |
| 34 | |
| 35 GtkWidget* BuildMenuItemWithLabel(const std::string& label) { | |
| 36 return gtk_menu_item_new_with_mnemonic(label.c_str()); | |
| 37 } | |
| 38 | |
| 39 ui::MenuModel* ModelForMenuItem(GtkMenuItem* menu_item) { | |
| 40 return reinterpret_cast<ui::MenuModel*>( | |
| 41 g_object_get_data(G_OBJECT(menu_item), "model")); | |
| 42 } | |
| 43 | |
| 44 GtkWidget* AppendMenuItemToMenu(int index, | |
| 45 ui::MenuModel* model, | |
| 46 GtkWidget* menu_item, | |
| 47 GtkWidget* menu, | |
| 48 bool connect_to_activate, | |
| 49 GCallback item_activated_cb, | |
| 50 void* this_ptr) { | |
| 51 // Set the ID of a menu item. | |
| 52 // Add 1 to the menu_id to avoid setting zero (null) to "menu-id". | |
| 53 g_object_set_data(G_OBJECT(menu_item), "menu-id", GINT_TO_POINTER(index + 1)); | |
| 54 | |
| 55 // Native menu items do their own thing, so only selectively listen for the | |
| 56 // activate signal. | |
| 57 if (connect_to_activate) { | |
| 58 g_signal_connect(menu_item, "activate", item_activated_cb, this_ptr); | |
| 59 } | |
| 60 | |
| 61 // AppendMenuItemToMenu is used both internally when we control menu creation | |
| 62 // from a model (where the model can choose to hide certain menu items), and | |
| 63 // with immediate commands which don't provide the option. | |
| 64 if (model) { | |
| 65 if (model->IsVisibleAt(index)) | |
| 66 gtk_widget_show(menu_item); | |
| 67 } else { | |
| 68 gtk_widget_show(menu_item); | |
| 69 } | |
| 70 gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item); | |
| 71 return menu_item; | |
| 72 } | |
| 73 | |
| 74 bool GetMenuItemID(GtkWidget* menu_item, int* menu_id) { | |
| 75 gpointer id_ptr = g_object_get_data(G_OBJECT(menu_item), "menu-id"); | |
| 76 if (id_ptr != NULL) { | |
| 77 *menu_id = GPOINTER_TO_INT(id_ptr) - 1; | |
| 78 return true; | |
| 79 } | |
| 80 | |
| 81 return false; | |
| 82 } | |
| 83 | |
| 84 void ExecuteCommand(ui::MenuModel* model, int id) { | |
| 85 GdkEvent* event = gtk_get_current_event(); | |
| 86 int event_flags = 0; | |
| 87 | |
| 88 if (event && event->type == GDK_BUTTON_RELEASE) | |
| 89 event_flags = EventFlagsFromGdkState(event->button.state); | |
| 90 model->ActivatedAt(id, event_flags); | |
| 91 | |
| 92 if (event) | |
| 93 gdk_event_free(event); | |
| 94 } | |
| 95 | |
| 96 void BuildSubmenuFromModel(ui::MenuModel* model, | |
| 97 GtkWidget* menu, | |
| 98 GCallback item_activated_cb, | |
| 99 bool* block_activation, | |
| 100 void* this_ptr) { | |
| 101 std::map<int, GtkWidget*> radio_groups; | |
| 102 GtkWidget* menu_item = NULL; | |
| 103 for (int i = 0; i < model->GetItemCount(); ++i) { | |
| 104 gfx::Image icon; | |
| 105 std::string label = ui::ConvertAcceleratorsFromWindowsStyle( | |
| 106 base::UTF16ToUTF8(model->GetLabelAt(i))); | |
| 107 | |
| 108 bool connect_to_activate = true; | |
| 109 | |
| 110 switch (model->GetTypeAt(i)) { | |
| 111 case ui::MenuModel::TYPE_SEPARATOR: | |
| 112 menu_item = gtk_separator_menu_item_new(); | |
| 113 break; | |
| 114 | |
| 115 case ui::MenuModel::TYPE_CHECK: | |
| 116 menu_item = gtk_check_menu_item_new_with_mnemonic(label.c_str()); | |
| 117 break; | |
| 118 | |
| 119 case ui::MenuModel::TYPE_RADIO: { | |
| 120 std::map<int, GtkWidget*>::iterator iter = | |
| 121 radio_groups.find(model->GetGroupIdAt(i)); | |
| 122 | |
| 123 if (iter == radio_groups.end()) { | |
| 124 menu_item = | |
| 125 gtk_radio_menu_item_new_with_mnemonic(NULL, label.c_str()); | |
| 126 radio_groups[model->GetGroupIdAt(i)] = menu_item; | |
| 127 } else { | |
| 128 menu_item = gtk_radio_menu_item_new_with_mnemonic_from_widget( | |
| 129 GTK_RADIO_MENU_ITEM(iter->second), label.c_str()); | |
| 130 } | |
| 131 break; | |
| 132 } | |
| 133 case ui::MenuModel::TYPE_BUTTON_ITEM: { | |
| 134 NOTIMPLEMENTED(); | |
| 135 break; | |
| 136 } | |
| 137 case ui::MenuModel::TYPE_SUBMENU: | |
| 138 case ui::MenuModel::TYPE_COMMAND: { | |
| 139 if (model->GetIconAt(i, &icon)) | |
| 140 menu_item = BuildMenuItemWithImage(label, icon); | |
| 141 else | |
| 142 menu_item = BuildMenuItemWithLabel(label); | |
| 143 if (GTK_IS_IMAGE_MENU_ITEM(menu_item)) { | |
| 144 gtk_image_menu_item_set_always_show_image( | |
| 145 GTK_IMAGE_MENU_ITEM(menu_item), TRUE); | |
| 146 } | |
| 147 break; | |
| 148 } | |
| 149 | |
| 150 default: | |
| 151 NOTREACHED(); | |
| 152 } | |
| 153 | |
| 154 if (model->GetTypeAt(i) == ui::MenuModel::TYPE_SUBMENU) { | |
| 155 GtkWidget* submenu = gtk_menu_new(); | |
| 156 ui::MenuModel* submenu_model = model->GetSubmenuModelAt(i); | |
| 157 BuildSubmenuFromModel(submenu_model, | |
| 158 submenu, | |
| 159 item_activated_cb, | |
| 160 block_activation, | |
| 161 this_ptr); | |
| 162 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), submenu); | |
| 163 | |
| 164 // Update all the menu item info in the newly-generated menu. | |
| 165 gtk_container_foreach( | |
| 166 GTK_CONTAINER(submenu), SetMenuItemInfo, block_activation); | |
| 167 submenu_model->MenuWillShow(); | |
| 168 connect_to_activate = false; | |
| 169 } | |
| 170 | |
| 171 ui::Accelerator accelerator; | |
| 172 if (model->GetAcceleratorAt(i, &accelerator)) { | |
| 173 gtk_widget_add_accelerator(menu_item, | |
| 174 "activate", | |
| 175 NULL, | |
| 176 GetGdkKeyCodeForAccelerator(accelerator), | |
| 177 GetGdkModifierForAccelerator(accelerator), | |
| 178 GTK_ACCEL_VISIBLE); | |
| 179 } | |
| 180 | |
| 181 g_object_set_data(G_OBJECT(menu_item), "model", model); | |
| 182 AppendMenuItemToMenu(i, | |
| 183 model, | |
| 184 menu_item, | |
| 185 menu, | |
| 186 connect_to_activate, | |
| 187 item_activated_cb, | |
| 188 this_ptr); | |
| 189 | |
| 190 menu_item = NULL; | |
| 191 } | |
| 192 } | |
| 193 | |
| 194 void SetMenuItemInfo(GtkWidget* widget, void* block_activation_ptr) { | |
| 195 if (GTK_IS_SEPARATOR_MENU_ITEM(widget)) { | |
| 196 // We need to explicitly handle this case because otherwise we'll ask the | |
| 197 // menu delegate about something with an invalid id. | |
| 198 return; | |
| 199 } | |
| 200 | |
| 201 int id; | |
| 202 if (!GetMenuItemID(widget, &id)) | |
| 203 return; | |
| 204 | |
| 205 ui::MenuModel* model = ModelForMenuItem(GTK_MENU_ITEM(widget)); | |
| 206 if (!model) { | |
| 207 // If we're not providing the sub menu, then there's no model. For | |
| 208 // example, the IME submenu doesn't have a model. | |
| 209 return; | |
| 210 } | |
| 211 bool* block_activation = static_cast<bool*>(block_activation_ptr); | |
| 212 | |
| 213 if (GTK_IS_CHECK_MENU_ITEM(widget)) { | |
| 214 GtkCheckMenuItem* item = GTK_CHECK_MENU_ITEM(widget); | |
| 215 | |
| 216 // gtk_check_menu_item_set_active() will send the activate signal. Touching | |
| 217 // the underlying "active" property will also call the "activate" handler | |
| 218 // for this menu item. So we prevent the "activate" handler from | |
| 219 // being called while we set the checkbox. | |
| 220 // Why not use one of the glib signal-blocking functions? Because when we | |
| 221 // toggle a radio button, it will deactivate one of the other radio buttons, | |
| 222 // which we don't have a pointer to. | |
| 223 *block_activation = true; | |
| 224 gtk_check_menu_item_set_active(item, model->IsItemCheckedAt(id)); | |
| 225 *block_activation = false; | |
| 226 } | |
| 227 | |
| 228 if (GTK_IS_MENU_ITEM(widget)) { | |
| 229 gtk_widget_set_sensitive(widget, model->IsEnabledAt(id)); | |
| 230 | |
| 231 if (model->IsVisibleAt(id)) { | |
| 232 // Update the menu item label if it is dynamic. | |
| 233 if (model->IsItemDynamicAt(id)) { | |
| 234 std::string label = ui::ConvertAcceleratorsFromWindowsStyle( | |
| 235 base::UTF16ToUTF8(model->GetLabelAt(id))); | |
| 236 | |
| 237 gtk_menu_item_set_label(GTK_MENU_ITEM(widget), label.c_str()); | |
| 238 if (GTK_IS_IMAGE_MENU_ITEM(widget)) { | |
| 239 gfx::Image icon; | |
| 240 if (model->GetIconAt(id, &icon)) { | |
| 241 GdkPixbuf* pixbuf = GdkPixbufFromSkBitmap(*icon.ToSkBitmap()); | |
| 242 gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(widget), | |
| 243 gtk_image_new_from_pixbuf(pixbuf)); | |
| 244 g_object_unref(pixbuf); | |
| 245 } else { | |
| 246 gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(widget), NULL); | |
| 247 } | |
| 248 } | |
| 249 } | |
| 250 | |
| 251 gtk_widget_show(widget); | |
| 252 } else { | |
| 253 gtk_widget_hide(widget); | |
| 254 } | |
| 255 | |
| 256 GtkWidget* submenu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(widget)); | |
| 257 if (submenu) { | |
| 258 gtk_container_foreach( | |
| 259 GTK_CONTAINER(submenu), &SetMenuItemInfo, block_activation_ptr); | |
| 260 } | |
| 261 } | |
| 262 } | |
| 263 | |
| 264 } // namespace libgtk2ui | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2449243002:
Gtk3 ui: Add libgtk3ui as a separate build component (Closed)
