| | 1 | ///////////////////////////////////////////////////////////////////////////// |
| | 2 | // Name: menu.cpp |
| | 3 | // Purpose: |
| | 4 | // Author: Robert Roebling |
| | 5 | // Id: $Id$ |
| | 6 | // Copyright: (c) 1998 Robert Roebling |
| | 7 | // Licence: wxWindows licence |
| | 8 | ///////////////////////////////////////////////////////////////////////////// |
| | 9 | |
| | 10 | #ifdef __GNUG__ |
| | 11 | #pragma implementation "menu.h" |
| | 12 | #pragma implementation "menuitem.h" |
| | 13 | #endif |
| | 14 | |
| | 15 | #include "wx/menu.h" |
| | 16 | #include "wx/log.h" |
| | 17 | #include "wx/intl.h" |
| | 18 | #include "wx/app.h" |
| | 19 | |
| | 20 | #include "gdk/gdk.h" |
| | 21 | #include "gtk/gtk.h" |
| | 22 | |
| | 23 | //----------------------------------------------------------------------------- |
| | 24 | // idle system |
| | 25 | //----------------------------------------------------------------------------- |
| | 26 | |
| | 27 | extern void wxapp_install_idle_handler(); |
| | 28 | extern bool g_isIdle; |
| | 29 | |
| | 30 | //----------------------------------------------------------------------------- |
| | 31 | // wxMenuBar |
| | 32 | //----------------------------------------------------------------------------- |
| | 33 | |
| | 34 | IMPLEMENT_DYNAMIC_CLASS(wxMenuBar,wxWindow) |
| | 35 | |
| | 36 | wxMenuBar::wxMenuBar( long style ) |
| | 37 | { |
| | 38 | /* the parent window is known after wxFrame::SetMenu() */ |
| | 39 | m_needParent = FALSE; |
| | 40 | |
| | 41 | PreCreation( (wxWindow *) NULL, -1, wxDefaultPosition, wxDefaultSize, style, "menu" ); |
| | 42 | |
| | 43 | m_menus.DeleteContents( TRUE ); |
| | 44 | |
| | 45 | /* GTK 1.2.0 doesn't have gtk_item_factory_get_item(), but GTK 1.2.1 has. */ |
| | 46 | #if (GTK_MINOR_VERSION > 0) && (GTK_MICRO_VERSION > 0) |
| | 47 | m_accel = gtk_accel_group_new(); |
| | 48 | m_factory = gtk_item_factory_new( GTK_TYPE_MENU_BAR, "<main>", m_accel ); |
| | 49 | m_menubar = gtk_item_factory_get_widget( m_factory, "<main>" ); |
| | 50 | #else |
| | 51 | m_menubar = gtk_menu_bar_new(); |
| | 52 | #endif |
| | 53 | |
| | 54 | if (style & wxMB_DOCKABLE) |
| | 55 | { |
| | 56 | m_widget = gtk_handle_box_new(); |
| | 57 | gtk_container_add( GTK_CONTAINER(m_widget), GTK_WIDGET(m_menubar) ); |
| | 58 | gtk_widget_show( GTK_WIDGET(m_menubar) ); |
| | 59 | } |
| | 60 | else |
| | 61 | { |
| | 62 | m_widget = GTK_WIDGET(m_menubar); |
| | 63 | } |
| | 64 | |
| | 65 | PostCreation(); |
| | 66 | |
| | 67 | Show( TRUE ); |
| | 68 | } |
| | 69 | |
| | 70 | wxMenuBar::wxMenuBar() |
| | 71 | { |
| | 72 | /* the parent window is known after wxFrame::SetMenu() */ |
| | 73 | m_needParent = FALSE; |
| | 74 | |
| | 75 | PreCreation( (wxWindow *) NULL, -1, wxDefaultPosition, wxDefaultSize, 0, "menu" ); |
| | 76 | |
| | 77 | m_menus.DeleteContents( TRUE ); |
| | 78 | |
| | 79 | /* GTK 1.2.0 doesn't have gtk_item_factory_get_item(), but GTK 1.2.1 has. */ |
| | 80 | #if (GTK_MINOR_VERSION > 0) && (GTK_MICRO_VERSION > 0) |
| | 81 | m_accel = gtk_accel_group_new(); |
| | 82 | m_factory = gtk_item_factory_new( GTK_TYPE_MENU_BAR, "<main>", m_accel ); |
| | 83 | m_menubar = gtk_item_factory_get_widget( m_factory, "<main>" ); |
| | 84 | #else |
| | 85 | m_menubar = gtk_menu_bar_new(); |
| | 86 | #endif |
| | 87 | |
| | 88 | m_widget = GTK_WIDGET(m_menubar); |
| | 89 | |
| | 90 | PostCreation(); |
| | 91 | |
| | 92 | Show( TRUE ); |
| | 93 | } |
| | 94 | |
| | 95 | wxMenuBar::~wxMenuBar() |
| | 96 | { |
| | 97 | // how to destroy a GtkItemFactory ? |
| | 98 | } |
| | 99 | |
| | 100 | void wxMenuBar::Append( wxMenu *menu, const wxString &title ) |
| | 101 | { |
| | 102 | m_menus.Append( menu ); |
| | 103 | |
| | 104 | /* GTK 1.2 wants to have "_" instead of "&" for accelerators */ |
| | 105 | wxString str; |
| | 106 | for ( const wxChar *pc = title; *pc != _T('\0'); pc++ ) |
| | 107 | { |
| | 108 | if (*pc == _T('&')) |
| | 109 | { |
| | 110 | #if (GTK_MINOR_VERSION > 0) && (GTK_MICRO_VERSION > 0) |
| | 111 | str << _T('_'); |
| | 112 | } else |
| | 113 | if (*pc == _T('/')) |
| | 114 | { |
| | 115 | str << _T('\\'); |
| | 116 | #endif |
| | 117 | } |
| | 118 | else |
| | 119 | str << *pc; |
| | 120 | } |
| | 121 | |
| | 122 | /* this doesn't have much effect right now */ |
| | 123 | menu->SetTitle( str ); |
| | 124 | |
| | 125 | /* GTK 1.2.0 doesn't have gtk_item_factory_get_item(), but GTK 1.2.1 has. */ |
| | 126 | #if (GTK_MINOR_VERSION > 0) && (GTK_MICRO_VERSION > 0) |
| | 127 | |
| | 128 | /* local buffer in multibyte form */ |
| | 129 | char buf[200]; |
| | 130 | strcpy( buf, "/" ); |
| | 131 | strcat( buf, str.mb_str() ); |
| | 132 | |
| | 133 | GtkItemFactoryEntry entry; |
| | 134 | entry.path = buf; |
| | 135 | entry.accelerator = (gchar*) NULL; |
| | 136 | entry.callback = (GtkItemFactoryCallback) NULL; |
| | 137 | entry.callback_action = 0; |
| | 138 | entry.item_type = "<Branch>"; |
| | 139 | |
| | 140 | gtk_item_factory_create_item( m_factory, &entry, (gpointer) this, 2 ); /* what is 2 ? */ |
| | 141 | |
| | 142 | /* in order to get the pointer to the item we need the item text _without_ underscores */ |
| | 143 | wxString tmp = _T("<main>/"); |
| | 144 | for ( const wxChar *pc = str; *pc != _T('\0'); pc++ ) |
| | 145 | { |
| | 146 | if (*pc == _T('_')) pc++; /* skip it */ |
| | 147 | tmp << *pc; |
| | 148 | } |
| | 149 | |
| | 150 | menu->m_owner = gtk_item_factory_get_item( m_factory, tmp.mb_str() ); |
| | 151 | |
| | 152 | gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu->m_owner), menu->m_menu ); |
| | 153 | |
| | 154 | #else |
| | 155 | |
| | 156 | menu->m_owner = gtk_menu_item_new_with_label( str.mb_str() ); |
| | 157 | gtk_widget_show( menu->m_owner ); |
| | 158 | gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu->m_owner), menu->m_menu ); |
| | 159 | |
| | 160 | gtk_menu_bar_append( GTK_MENU_BAR(m_menubar), menu->m_owner ); |
| | 161 | |
| | 162 | #endif |
| | 163 | } |
| | 164 | |
| | 165 | static int FindMenuItemRecursive( const wxMenu *menu, const wxString &menuString, const wxString &itemString ) |
| | 166 | { |
| | 167 | if (menu->GetTitle() == menuString) |
| | 168 | { |
| | 169 | int res = menu->FindItem( itemString ); |
| | 170 | if (res != wxNOT_FOUND) |
| | 171 | return res; |
| | 172 | } |
| | 173 | |
| | 174 | wxNode *node = ((wxMenu *)menu)->GetItems().First(); // const_cast |
| | 175 | while (node) |
| | 176 | { |
| | 177 | wxMenuItem *item = (wxMenuItem*)node->Data(); |
| | 178 | if (item->IsSubMenu()) |
| | 179 | return FindMenuItemRecursive(item->GetSubMenu(), menuString, itemString); |
| | 180 | |
| | 181 | node = node->Next(); |
| | 182 | } |
| | 183 | |
| | 184 | return wxNOT_FOUND; |
| | 185 | } |
| | 186 | |
| | 187 | wxMenuItem *wxMenuBar::FindItemForId(int itemId, wxMenu **menuForItem ) const |
| | 188 | { |
| | 189 | if ( menuForItem ) |
| | 190 | { |
| | 191 | // TODO return the pointer to the menu |
| | 192 | |
| | 193 | *menuForItem = NULL; |
| | 194 | } |
| | 195 | |
| | 196 | return FindItem(itemId); |
| | 197 | } |
| | 198 | |
| | 199 | int wxMenuBar::FindMenuItem( const wxString &menuString, const wxString &itemString ) const |
| | 200 | { |
| | 201 | wxNode *node = m_menus.First(); |
| | 202 | while (node) |
| | 203 | { |
| | 204 | wxMenu *menu = (wxMenu*)node->Data(); |
| | 205 | int res = FindMenuItemRecursive( menu, menuString, itemString); |
| | 206 | if (res != -1) return res; |
| | 207 | node = node->Next(); |
| | 208 | } |
| | 209 | return -1; |
| | 210 | } |
| | 211 | |
| | 212 | // Find a wxMenuItem using its id. Recurses down into sub-menus |
| | 213 | static wxMenuItem* FindMenuItemByIdRecursive(const wxMenu* menu, int id) |
| | 214 | { |
| | 215 | wxMenuItem* result = menu->FindItem(id); |
| | 216 | |
| | 217 | wxNode *node = ((wxMenu *)menu)->GetItems().First(); // const_cast |
| | 218 | while ( node && result == NULL ) |
| | 219 | { |
| | 220 | wxMenuItem *item = (wxMenuItem*)node->Data(); |
| | 221 | if (item->IsSubMenu()) |
| | 222 | { |
| | 223 | result = FindMenuItemByIdRecursive( item->GetSubMenu(), id ); |
| | 224 | } |
| | 225 | node = node->Next(); |
| | 226 | } |
| | 227 | |
| | 228 | return result; |
| | 229 | } |
| | 230 | |
| | 231 | wxMenuItem* wxMenuBar::FindItem( int id ) const |
| | 232 | { |
| | 233 | wxMenuItem* result = 0; |
| | 234 | wxNode *node = m_menus.First(); |
| | 235 | while (node && result == 0) |
| | 236 | { |
| | 237 | wxMenu *menu = (wxMenu*)node->Data(); |
| | 238 | result = FindMenuItemByIdRecursive( menu, id ); |
| | 239 | node = node->Next(); |
| | 240 | } |
| | 241 | |
| | 242 | return result; |
| | 243 | } |
| | 244 | |
| | 245 | void wxMenuBar::Check( int id, bool check ) |
| | 246 | { |
| | 247 | wxMenuItem* item = FindMenuItemById( id ); |
| | 248 | |
| | 249 | wxCHECK_RET( item, _T("wxMenuBar::Check: no such item") ); |
| | 250 | |
| | 251 | item->Check(check); |
| | 252 | } |
| | 253 | |
| | 254 | bool wxMenuBar::IsChecked( int id ) const |
| | 255 | { |
| | 256 | wxMenuItem* item = FindMenuItemById( id ); |
| | 257 | |
| | 258 | wxCHECK_MSG( item, FALSE, _T("wxMenuBar::IsChecked: no such item") ); |
| | 259 | |
| | 260 | return item->IsChecked(); |
| | 261 | } |
| | 262 | |
| | 263 | void wxMenuBar::Enable( int id, bool enable ) |
| | 264 | { |
| | 265 | wxMenuItem* item = FindMenuItemById( id ); |
| | 266 | |
| | 267 | wxCHECK_RET( item, _T("wxMenuBar::Enable: no such item") ); |
| | 268 | |
| | 269 | item->Enable(enable); |
| | 270 | } |
| | 271 | |
| | 272 | bool wxMenuBar::IsEnabled( int id ) const |
| | 273 | { |
| | 274 | wxMenuItem* item = FindMenuItemById( id ); |
| | 275 | |
| | 276 | wxCHECK_MSG( item, FALSE, _T("wxMenuBar::IsEnabled: no such item") ); |
| | 277 | |
| | 278 | return item->IsEnabled(); |
| | 279 | } |
| | 280 | |
| | 281 | wxString wxMenuBar::GetLabel( int id ) const |
| | 282 | { |
| | 283 | wxMenuItem* item = FindMenuItemById( id ); |
| | 284 | |
| | 285 | wxCHECK_MSG( item, _T(""), _T("wxMenuBar::GetLabel: no such item") ); |
| | 286 | |
| | 287 | return item->GetText(); |
| | 288 | } |
| | 289 | |
| | 290 | void wxMenuBar::SetLabel( int id, const wxString &label ) |
| | 291 | { |
| | 292 | wxMenuItem* item = FindMenuItemById( id ); |
| | 293 | |
| | 294 | wxCHECK_RET( item, _T("wxMenuBar::SetLabel: no such item") ); |
| | 295 | |
| | 296 | item->SetText( label ); |
| | 297 | } |
| | 298 | |
| | 299 | void wxMenuBar::EnableTop( int pos, bool flag ) |
| | 300 | { |
| | 301 | wxNode *node = m_menus.Nth( pos ); |
| | 302 | |
| | 303 | wxCHECK_RET( node, _T("menu not found") ); |
| | 304 | |
| | 305 | wxMenu* menu = (wxMenu*)node->Data(); |
| | 306 | |
| | 307 | if (menu->m_owner) |
| | 308 | gtk_widget_set_sensitive( menu->m_owner, flag ); |
| | 309 | } |
| | 310 | |
| | 311 | wxString wxMenuBar::GetLabelTop( int pos ) const |
| | 312 | { |
| | 313 | wxNode *node = m_menus.Nth( pos ); |
| | 314 | |
| | 315 | wxCHECK_MSG( node, _T("invalid"), _T("menu not found") ); |
| | 316 | |
| | 317 | wxMenu* menu = (wxMenu*)node->Data(); |
| | 318 | |
| | 319 | return menu->GetTitle(); |
| | 320 | } |
| | 321 | |
| | 322 | void wxMenuBar::SetLabelTop( int pos, const wxString& label ) |
| | 323 | { |
| | 324 | wxNode *node = m_menus.Nth( pos ); |
| | 325 | |
| | 326 | wxCHECK_RET( node, _T("menu not found") ); |
| | 327 | |
| | 328 | wxMenu* menu = (wxMenu*)node->Data(); |
| | 329 | |
| | 330 | menu->SetTitle( label ); |
| | 331 | } |
| | 332 | |
| | 333 | void wxMenuBar::SetHelpString( int id, const wxString& helpString ) |
| | 334 | { |
| | 335 | wxMenuItem* item = FindMenuItemById( id ); |
| | 336 | |
| | 337 | wxCHECK_RET( item, _T("wxMenuBar::SetHelpString: no such item") ); |
| | 338 | |
| | 339 | item->SetHelp( helpString ); |
| | 340 | } |
| | 341 | |
| | 342 | wxString wxMenuBar::GetHelpString( int id ) const |
| | 343 | { |
| | 344 | wxMenuItem* item = FindMenuItemById( id ); |
| | 345 | |
| | 346 | wxCHECK_MSG( item, _T(""), _T("wxMenuBar::GetHelpString: no such item") ); |
| | 347 | |
| | 348 | return item->GetHelp(); |
| | 349 | } |
| | 350 | |
| | 351 | //----------------------------------------------------------------------------- |
| | 352 | // "activate" |
| | 353 | //----------------------------------------------------------------------------- |
| | 354 | |
| | 355 | static void gtk_menu_clicked_callback( GtkWidget *widget, wxMenu *menu ) |
| | 356 | { |
| | 357 | if (g_isIdle) wxapp_install_idle_handler(); |
| | 358 | |
| | 359 | int id = menu->FindMenuIdByMenuItem(widget); |
| | 360 | |
| | 361 | /* should find it for normal (not popup) menu */ |
| | 362 | wxASSERT( (id != -1) || (menu->GetInvokingWindow() != NULL) ); |
| | 363 | |
| | 364 | if (!menu->IsEnabled(id)) |
| | 365 | return; |
| | 366 | |
| | 367 | wxMenuItem* item = menu->FindItem( id ); |
| | 368 | wxCHECK_RET( item, _T("error in menu item callback") ); |
| | 369 | |
| | 370 | if (item->IsCheckable()) |
| | 371 | { |
| | 372 | if (item->GetCheckedFlag() == item->IsChecked()) |
| | 373 | { |
| | 374 | /* the menu item has been checked by calling wxMenuItem->Check() */ |
| | 375 | return; |
| | 376 | } |
| | 377 | else |
| | 378 | { |
| | 379 | /* the user pressed on the menu item -> report */ |
| | 380 | item->SetCheckedFlag(item->IsChecked()); /* make consistent again */ |
| | 381 | } |
| | 382 | } |
| | 383 | |
| | 384 | wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, id ); |
| | 385 | event.SetEventObject( menu ); |
| | 386 | event.SetInt(id ); |
| | 387 | |
| | 388 | if (menu->GetCallback()) |
| | 389 | { |
| | 390 | (void) (*(menu->GetCallback())) (*menu, event); |
| | 391 | return; |
| | 392 | } |
| | 393 | |
| | 394 | if (menu->GetEventHandler()->ProcessEvent(event)) |
| | 395 | return; |
| | 396 | |
| | 397 | wxWindow *win = menu->GetInvokingWindow(); |
| | 398 | if (win) |
| | 399 | win->GetEventHandler()->ProcessEvent( event ); |
| | 400 | } |
| | 401 | |
| | 402 | //----------------------------------------------------------------------------- |
| | 403 | // "select" |
| | 404 | //----------------------------------------------------------------------------- |
| | 405 | |
| | 406 | static void gtk_menu_hilight_callback( GtkWidget *widget, wxMenu *menu ) |
| | 407 | { |
| | 408 | if (g_isIdle) wxapp_install_idle_handler(); |
| | 409 | |
| | 410 | int id = menu->FindMenuIdByMenuItem(widget); |
| | 411 | |
| | 412 | wxASSERT( id != -1 ); // should find it! |
| | 413 | |
| | 414 | if (!menu->IsEnabled(id)) |
| | 415 | return; |
| | 416 | |
| | 417 | wxMenuEvent event( wxEVT_MENU_HIGHLIGHT, id ); |
| | 418 | event.SetEventObject( menu ); |
| | 419 | |
| | 420 | /* wxMSW doesn't call callback here either |
| | 421 | |
| | 422 | if (menu->m_callback) |
| | 423 | { |
| | 424 | (void) (*(menu->m_callback)) (*menu, event); |
| | 425 | return; |
| | 426 | } |
| | 427 | */ |
| | 428 | |
| | 429 | if (menu->GetEventHandler()->ProcessEvent(event)) |
| | 430 | return; |
| | 431 | |
| | 432 | wxWindow *win = menu->GetInvokingWindow(); |
| | 433 | if (win) win->GetEventHandler()->ProcessEvent( event ); |
| | 434 | } |
| | 435 | |
| | 436 | //----------------------------------------------------------------------------- |
| | 437 | // "deselect" |
| | 438 | //----------------------------------------------------------------------------- |
| | 439 | |
| | 440 | static void gtk_menu_nolight_callback( GtkWidget *widget, wxMenu *menu ) |
| | 441 | { |
| | 442 | if (g_isIdle) wxapp_install_idle_handler(); |
| | 443 | |
| | 444 | int id = menu->FindMenuIdByMenuItem(widget); |
| | 445 | |
| | 446 | wxASSERT( id != -1 ); // should find it! |
| | 447 | |
| | 448 | if (!menu->IsEnabled(id)) |
| | 449 | return; |
| | 450 | |
| | 451 | wxMenuEvent event( wxEVT_MENU_HIGHLIGHT, -1 ); |
| | 452 | event.SetEventObject( menu ); |
| | 453 | |
| | 454 | if (menu->GetEventHandler()->ProcessEvent(event)) |
| | 455 | return; |
| | 456 | |
| | 457 | wxWindow *win = menu->GetInvokingWindow(); |
| | 458 | if (win) |
| | 459 | win->GetEventHandler()->ProcessEvent( event ); |
| | 460 | } |
| | 461 | |
| | 462 | //----------------------------------------------------------------------------- |
| | 463 | // wxMenuItem |
| | 464 | //----------------------------------------------------------------------------- |
| | 465 | |
| | 466 | IMPLEMENT_DYNAMIC_CLASS(wxMenuItem,wxObject) |
| | 467 | |
| | 468 | wxMenuItem::wxMenuItem() |
| | 469 | { |
| | 470 | m_id = ID_SEPARATOR; |
| | 471 | m_isCheckMenu = FALSE; |
| | 472 | m_isChecked = FALSE; |
| | 473 | m_isEnabled = TRUE; |
| | 474 | m_subMenu = (wxMenu *) NULL; |
| | 475 | m_menuItem = (GtkWidget *) NULL; |
| | 476 | } |
| | 477 | |
| | 478 | // it's valid for this function to be called even if m_menuItem == NULL |
| | 479 | void wxMenuItem::SetName( const wxString& str ) |
| | 480 | { |
| | 481 | /* '\t' is the deliminator indicating a hot key */ |
| | 482 | m_text = _T(""); |
| | 483 | const wxChar *pc = str; |
| | 484 | for (; (*pc != _T('\0')) && (*pc != _T('\t')); pc++ ) |
| | 485 | { |
| | 486 | if (*pc == _T('&')) |
| | 487 | { |
| | 488 | #if (GTK_MINOR_VERSION > 0) |
| | 489 | m_text << _T('_'); |
| | 490 | } else |
| | 491 | if (*pc == _T('/')) /* we have to filter out slashes ... */ |
| | 492 | { |
| | 493 | m_text << _T('\\'); /* ... and replace them with back slashes */ |
| | 494 | #endif |
| | 495 | } |
| | 496 | else |
| | 497 | m_text << *pc; |
| | 498 | } |
| | 499 | |
| | 500 | /* only GTK 1.2 know about hot keys */ |
| | 501 | m_hotKey = _T(""); |
| | 502 | #if (GTK_MINOR_VERSION > 0) |
| | 503 | if(*pc == _T('\t')) |
| | 504 | { |
| | 505 | pc++; |
| | 506 | m_hotKey = pc; |
| | 507 | } |
| | 508 | #endif |
| | 509 | |
| | 510 | if (m_menuItem) |
| | 511 | { |
| | 512 | GtkLabel *label = GTK_LABEL( GTK_BIN(m_menuItem)->child ); |
| | 513 | gtk_label_set( label, m_text.mb_str()); |
| | 514 | } |
| | 515 | } |
| | 516 | |
| | 517 | void wxMenuItem::Check( bool check ) |
| | 518 | { |
| | 519 | wxCHECK_RET( m_menuItem, _T("invalid menu item") ); |
| | 520 | |
| | 521 | wxCHECK_RET( IsCheckable(), _T("Can't check uncheckable item!") ) |
| | 522 | |
| | 523 | if (check == m_isChecked) return; |
| | 524 | |
| | 525 | m_isChecked = check; |
| | 526 | gtk_check_menu_item_set_state( (GtkCheckMenuItem*)m_menuItem, (gint)check ); |
| | 527 | } |
| | 528 | |
| | 529 | void wxMenuItem::Enable( bool enable ) |
| | 530 | { |
| | 531 | wxCHECK_RET( m_menuItem, _T("invalid menu item") ); |
| | 532 | |
| | 533 | gtk_widget_set_sensitive( m_menuItem, enable ); |
| | 534 | m_isEnabled = enable; |
| | 535 | } |
| | 536 | |
| | 537 | bool wxMenuItem::IsChecked() const |
| | 538 | { |
| | 539 | wxCHECK_MSG( m_menuItem, FALSE, _T("invalid menu item") ); |
| | 540 | |
| | 541 | wxCHECK( IsCheckable(), FALSE ); // can't get state of uncheckable item! |
| | 542 | |
| | 543 | bool bIsChecked = ((GtkCheckMenuItem*)m_menuItem)->active != 0; |
| | 544 | |
| | 545 | return bIsChecked; |
| | 546 | } |
| | 547 | |
| | 548 | //----------------------------------------------------------------------------- |
| | 549 | // wxMenu |
| | 550 | //----------------------------------------------------------------------------- |
| | 551 | |
| | 552 | IMPLEMENT_DYNAMIC_CLASS(wxMenu,wxEvtHandler) |
| | 553 | |
| | 554 | wxMenu::wxMenu( const wxString& title, const wxFunction func ) |
| | 555 | { |
| | 556 | m_title = title; |
| | 557 | m_items.DeleteContents( TRUE ); |
| | 558 | m_invokingWindow = (wxWindow *) NULL; |
| | 559 | |
| | 560 | #if (GTK_MINOR_VERSION > 0) |
| | 561 | m_accel = gtk_accel_group_new(); |
| | 562 | m_factory = gtk_item_factory_new( GTK_TYPE_MENU, "<main>", m_accel ); |
| | 563 | m_menu = gtk_item_factory_get_widget( m_factory, "<main>" ); |
| | 564 | #else |
| | 565 | m_menu = gtk_menu_new(); // Do not show! |
| | 566 | #endif |
| | 567 | |
| | 568 | m_callback = func; |
| | 569 | m_eventHandler = this; |
| | 570 | m_clientData = (void*) NULL; |
| | 571 | |
| | 572 | if (m_title.IsNull()) m_title = _T(""); |
| | 573 | if (m_title != _T("")) |
| | 574 | { |
| | 575 | Append(-2, m_title); |
| | 576 | AppendSeparator(); |
| | 577 | } |
| | 578 | |
| | 579 | m_owner = (GtkWidget*) NULL; |
| | 580 | } |
| | 581 | |
| | 582 | wxMenu::~wxMenu() |
| | 583 | { |
| | 584 | /* how do we delete an item-factory ? */ |
| | 585 | } |
| | 586 | |
| | 587 | void wxMenu::SetTitle( const wxString& title ) |
| | 588 | { |
| | 589 | // TODO Waiting for something better |
| | 590 | m_title = title; |
| | 591 | } |
| | 592 | |
| | 593 | const wxString wxMenu::GetTitle() const |
| | 594 | { |
| | 595 | return m_title; |
| | 596 | } |
| | 597 | |
| | 598 | void wxMenu::AppendSeparator() |
| | 599 | { |
| | 600 | wxMenuItem *mitem = new wxMenuItem(); |
| | 601 | mitem->SetId(ID_SEPARATOR); |
| | 602 | |
| | 603 | #if (GTK_MINOR_VERSION > 0) |
| | 604 | GtkItemFactoryEntry entry; |
| | 605 | entry.path = "/sep"; |
| | 606 | entry.callback = (GtkItemFactoryCallback) NULL; |
| | 607 | entry.callback_action = 0; |
| | 608 | entry.item_type = "<Separator>"; |
| | 609 | entry.accelerator = (gchar*) NULL; |
| | 610 | |
| | 611 | gtk_item_factory_create_item( m_factory, &entry, (gpointer) this, 2 ); /* what is 2 ? */ |
| | 612 | |
| | 613 | /* this will be wrong for more than one separator. do we care? */ |
| | 614 | GtkWidget *menuItem = gtk_item_factory_get_widget( m_factory, "<main>/sep" ); |
| | 615 | #else |
| | 616 | GtkWidget *menuItem = gtk_menu_item_new(); |
| | 617 | gtk_menu_append( GTK_MENU(m_menu), menuItem ); |
| | 618 | gtk_widget_show( menuItem ); |
| | 619 | #endif |
| | 620 | |
| | 621 | mitem->SetMenuItem(menuItem); |
| | 622 | m_items.Append( mitem ); |
| | 623 | } |
| | 624 | |
| | 625 | void wxMenu::Append( int id, const wxString &item, const wxString &helpStr, bool checkable ) |
| | 626 | { |
| | 627 | wxMenuItem *mitem = new wxMenuItem(); |
| | 628 | mitem->SetId(id); |
| | 629 | mitem->SetText(item); |
| | 630 | mitem->SetHelp(helpStr); |
| | 631 | mitem->SetCheckable(checkable); |
| | 632 | |
| | 633 | #if (GTK_MINOR_VERSION > 0) |
| | 634 | /* text has "_" instead of "&" after mitem->SetText() */ |
| | 635 | wxString text( mitem->GetText() ); |
| | 636 | |
| | 637 | /* local buffer in multibyte form */ |
| | 638 | char buf[200]; |
| | 639 | strcpy( buf, "/" ); |
| | 640 | strcat( buf, text.mb_str() ); |
| | 641 | |
| | 642 | GtkItemFactoryEntry entry; |
| | 643 | entry.path = buf; |
| | 644 | entry.callback = (GtkItemFactoryCallback) gtk_menu_clicked_callback; |
| | 645 | entry.callback_action = 0; |
| | 646 | if (checkable) |
| | 647 | entry.item_type = "<CheckItem>"; |
| | 648 | else |
| | 649 | entry.item_type = "<Item>"; |
| | 650 | |
| | 651 | entry.accelerator = (gchar*) NULL; |
| | 652 | char hotbuf[50]; |
| | 653 | wxString hotkey( mitem->GetHotKey() ); |
| | 654 | if (!hotkey.IsEmpty()) |
| | 655 | { |
| | 656 | switch (hotkey[0]) |
| | 657 | { |
| | 658 | case _T('a'): /* Alt */ |
| | 659 | case _T('A'): |
| | 660 | case _T('m'): /* Meta */ |
| | 661 | case _T('M'): |
| | 662 | { |
| | 663 | strcpy( hotbuf, "<alt>" ); |
| | 664 | wxString last = hotkey.Right(1); |
| | 665 | strcat( hotbuf, last.mb_str() ); |
| | 666 | entry.accelerator = hotbuf; |
| | 667 | break; |
| | 668 | } |
| | 669 | case _T('c'): /* Ctrl */ |
| | 670 | case _T('C'): |
| | 671 | case _T('s'): /* Strg, yeah man, I'm German */ |
| | 672 | case _T('S'): |
| | 673 | { |
| | 674 | strcpy( hotbuf, "<control>" ); |
| | 675 | wxString last = hotkey.Right(1); |
| | 676 | strcat( hotbuf, last.mb_str() ); |
| | 677 | entry.accelerator = hotbuf; |
| | 678 | break; |
| | 679 | } |
| | 680 | case _T('F'): /* function keys */ |
| | 681 | { |
| | 682 | strcpy( hotbuf, hotkey.mb_str() ); |
| | 683 | entry.accelerator = hotbuf; |
| | 684 | break; |
| | 685 | } |
| | 686 | default: |
| | 687 | { |
| | 688 | } |
| | 689 | } |
| | 690 | } |
| | 691 | |
| | 692 | gtk_item_factory_create_item( m_factory, &entry, (gpointer) this, 2 ); /* what is 2 ? */ |
| | 693 | |
| | 694 | /* in order to get the pointer to the item we need the item text _without_ underscores */ |
| | 695 | wxString s = _T("<main>/"); |
| | 696 | for ( const wxChar *pc = text; *pc != _T('\0'); pc++ ) |
| | 697 | { |
| | 698 | if (*pc == _T('_')) pc++; /* skip it */ |
| | 699 | s << *pc; |
| | 700 | } |
| | 701 | |
| | 702 | GtkWidget *menuItem = gtk_item_factory_get_widget( m_factory, s.mb_str() ); |
| | 703 | |
| | 704 | #else |
| | 705 | |
| | 706 | GtkWidget *menuItem = checkable ? gtk_check_menu_item_new_with_label( mitem->GetText().mb_str() ) |
| | 707 | : gtk_menu_item_new_with_label( mitem->GetText().mb_str() ); |
| | 708 | |
| | 709 | gtk_signal_connect( GTK_OBJECT(menuItem), "activate", |
| | 710 | GTK_SIGNAL_FUNC(gtk_menu_clicked_callback), |
| | 711 | (gpointer)this ); |
| | 712 | |
| | 713 | gtk_menu_append( GTK_MENU(m_menu), menuItem ); |
| | 714 | gtk_widget_show( menuItem ); |
| | 715 | |
| | 716 | #endif |
| | 717 | |
| | 718 | gtk_signal_connect( GTK_OBJECT(menuItem), "select", |
| | 719 | GTK_SIGNAL_FUNC(gtk_menu_hilight_callback), |
| | 720 | (gpointer)this ); |
| | 721 | |
| | 722 | gtk_signal_connect( GTK_OBJECT(menuItem), "deselect", |
| | 723 | GTK_SIGNAL_FUNC(gtk_menu_nolight_callback), |
| | 724 | (gpointer)this ); |
| | 725 | |
| | 726 | mitem->SetMenuItem(menuItem); |
| | 727 | |
| | 728 | m_items.Append( mitem ); |
| | 729 | } |
| | 730 | |
| | 731 | void wxMenu::Append( int id, const wxString &text, wxMenu *subMenu, const wxString &helpStr ) |
| | 732 | { |
| | 733 | wxMenuItem *mitem = new wxMenuItem(); |
| | 734 | mitem->SetId(id); |
| | 735 | mitem->SetText(text); |
| | 736 | mitem->SetHelp(helpStr); |
| | 737 | |
| | 738 | GtkWidget *menuItem = gtk_menu_item_new_with_label(mitem->GetText().mbc_str()); |
| | 739 | mitem->SetMenuItem(menuItem); |
| | 740 | mitem->SetSubMenu(subMenu); |
| | 741 | |
| | 742 | gtk_signal_connect( GTK_OBJECT(menuItem), "select", |
| | 743 | GTK_SIGNAL_FUNC(gtk_menu_hilight_callback), |
| | 744 | (gpointer*)this ); |
| | 745 | |
| | 746 | gtk_signal_connect( GTK_OBJECT(menuItem), "deselect", |
| | 747 | GTK_SIGNAL_FUNC(gtk_menu_nolight_callback), |
| | 748 | (gpointer*)this ); |
| | 749 | |
| | 750 | gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem), subMenu->m_menu ); |
| | 751 | gtk_menu_append( GTK_MENU(m_menu), menuItem ); |
| | 752 | gtk_widget_show( menuItem ); |
| | 753 | m_items.Append( mitem ); |
| | 754 | } |
| | 755 | |
| | 756 | void wxMenu::Append( wxMenuItem *item ) |
| | 757 | { |
| | 758 | m_items.Append( item ); |
| | 759 | |
| | 760 | GtkWidget *menuItem = (GtkWidget*) NULL; |
| | 761 | |
| | 762 | if (item->IsSeparator()) |
| | 763 | menuItem = gtk_menu_item_new(); |
| | 764 | else if (item->IsSubMenu()) |
| | 765 | menuItem = gtk_menu_item_new_with_label(item->GetText().mbc_str()); |
| | 766 | else |
| | 767 | menuItem = item->IsCheckable() ? gtk_check_menu_item_new_with_label(item->GetText().mbc_str()) |
| | 768 | : gtk_menu_item_new_with_label(item->GetText().mbc_str()); |
| | 769 | |
| | 770 | if (!item->IsSeparator()) |
| | 771 | { |
| | 772 | gtk_signal_connect( GTK_OBJECT(menuItem), "select", |
| | 773 | GTK_SIGNAL_FUNC(gtk_menu_hilight_callback), |
| | 774 | (gpointer*)this ); |
| | 775 | |
| | 776 | gtk_signal_connect( GTK_OBJECT(menuItem), "deselect", |
| | 777 | GTK_SIGNAL_FUNC(gtk_menu_nolight_callback), |
| | 778 | (gpointer*)this ); |
| | 779 | |
| | 780 | if (!item->IsSubMenu()) |
| | 781 | { |
| | 782 | gtk_signal_connect( GTK_OBJECT(menuItem), "activate", |
| | 783 | GTK_SIGNAL_FUNC(gtk_menu_clicked_callback), |
| | 784 | (gpointer*)this ); |
| | 785 | } |
| | 786 | } |
| | 787 | |
| | 788 | gtk_menu_append( GTK_MENU(m_menu), menuItem ); |
| | 789 | gtk_widget_show( menuItem ); |
| | 790 | item->SetMenuItem(menuItem); |
| | 791 | } |
| | 792 | |
| | 793 | int wxMenu::FindItem( const wxString itemString ) const |
| | 794 | { |
| | 795 | wxString s = _T(""); |
| | 796 | for ( const wxChar *pc = itemString; *pc != _T('\0'); pc++ ) |
| | 797 | { |
| | 798 | if (*pc == _T('&')) |
| | 799 | { |
| | 800 | pc++; /* skip it */ |
| | 801 | #if (GTK_MINOR_VERSION > 0) |
| | 802 | s << _T('_'); |
| | 803 | #endif |
| | 804 | } |
| | 805 | s << *pc; |
| | 806 | } |
| | 807 | |
| | 808 | wxNode *node = m_items.First(); |
| | 809 | while (node) |
| | 810 | { |
| | 811 | wxMenuItem *item = (wxMenuItem*)node->Data(); |
| | 812 | if (item->GetText() == s) |
| | 813 | { |
| | 814 | return item->GetId(); |
| | 815 | } |
| | 816 | node = node->Next(); |
| | 817 | } |
| | 818 | |
| | 819 | return wxNOT_FOUND; |
| | 820 | } |
| | 821 | |
| | 822 | void wxMenu::Enable( int id, bool enable ) |
| | 823 | { |
| | 824 | wxMenuItem *item = FindItem(id); |
| | 825 | |
| | 826 | wxCHECK_RET( item, _T("wxMenu::Enable: no such item") ); |
| | 827 | |
| | 828 | item->Enable(enable); |
| | 829 | } |
| | 830 | |
| | 831 | bool wxMenu::IsEnabled( int id ) const |
| | 832 | { |
| | 833 | wxMenuItem *item = FindItem(id); |
| | 834 | |
| | 835 | wxCHECK_MSG( item, FALSE, _T("wxMenu::IsEnabled: no such item") ); |
| | 836 | |
| | 837 | return item->IsEnabled(); |
| | 838 | } |
| | 839 | |
| | 840 | void wxMenu::Check( int id, bool enable ) |
| | 841 | { |
| | 842 | wxMenuItem *item = FindItem(id); |
| | 843 | |
| | 844 | wxCHECK_RET( item, _T("wxMenu::Check: no such item") ); |
| | 845 | |
| | 846 | item->Check(enable); |
| | 847 | } |
| | 848 | |
| | 849 | bool wxMenu::IsChecked( int id ) const |
| | 850 | { |
| | 851 | wxMenuItem *item = FindItem(id); |
| | 852 | |
| | 853 | wxCHECK_MSG( item, FALSE, _T("wxMenu::IsChecked: no such item") ); |
| | 854 | |
| | 855 | return item->IsChecked(); |
| | 856 | } |
| | 857 | |
| | 858 | void wxMenu::SetLabel( int id, const wxString &label ) |
| | 859 | { |
| | 860 | wxMenuItem *item = FindItem(id); |
| | 861 | |
| | 862 | wxCHECK_RET( item, _T("wxMenu::SetLabel: no such item") ); |
| | 863 | |
| | 864 | item->SetText(label); |
| | 865 | } |
| | 866 | |
| | 867 | wxString wxMenu::GetLabel( int id ) const |
| | 868 | { |
| | 869 | wxMenuItem *item = FindItem(id); |
| | 870 | |
| | 871 | wxCHECK_MSG( item, _T(""), _T("wxMenu::GetLabel: no such item") ); |
| | 872 | |
| | 873 | return item->GetText(); |
| | 874 | } |
| | 875 | |
| | 876 | void wxMenu::SetHelpString( int id, const wxString& helpString ) |
| | 877 | { |
| | 878 | wxMenuItem *item = FindItem(id); |
| | 879 | |
| | 880 | wxCHECK_RET( item, _T("wxMenu::SetHelpString: no such item") ); |
| | 881 | |
| | 882 | item->SetHelp( helpString ); |
| | 883 | } |
| | 884 | |
| | 885 | wxString wxMenu::GetHelpString( int id ) const |
| | 886 | { |
| | 887 | wxMenuItem *item = FindItem(id); |
| | 888 | |
| | 889 | wxCHECK_MSG( item, _T(""), _T("wxMenu::GetHelpString: no such item") ); |
| | 890 | |
| | 891 | return item->GetHelp(); |
| | 892 | } |
| | 893 | |
| | 894 | int wxMenu::FindMenuIdByMenuItem( GtkWidget *menuItem ) const |
| | 895 | { |
| | 896 | wxNode *node = m_items.First(); |
| | 897 | while (node) |
| | 898 | { |
| | 899 | wxMenuItem *item = (wxMenuItem*)node->Data(); |
| | 900 | if (item->GetMenuItem() == menuItem) |
| | 901 | return item->GetId(); |
| | 902 | node = node->Next(); |
| | 903 | } |
| | 904 | |
| | 905 | return wxNOT_FOUND; |
| | 906 | } |
| | 907 | |
| | 908 | wxMenuItem *wxMenu::FindItem(int id) const |
| | 909 | { |
| | 910 | wxNode *node = m_items.First(); |
| | 911 | while (node) |
| | 912 | { |
| | 913 | wxMenuItem *item = (wxMenuItem*)node->Data(); |
| | 914 | if (item->GetId() == id) |
| | 915 | { |
| | 916 | return item; |
| | 917 | } |
| | 918 | node = node->Next(); |
| | 919 | } |
| | 920 | |
| | 921 | /* Not finding anything here can be correct |
| | 922 | * when search the entire menu system for |
| | 923 | * an entry -> no error message. */ |
| | 924 | |
| | 925 | return (wxMenuItem *) NULL; |
| | 926 | } |
| | 927 | |
| | 928 | void wxMenu::SetInvokingWindow( wxWindow *win ) |
| | 929 | { |
| | 930 | m_invokingWindow = win; |
| | 931 | } |
| | 932 | |
| | 933 | wxWindow *wxMenu::GetInvokingWindow() |
| | 934 | { |
| | 935 | return m_invokingWindow; |
| | 936 | } |
| | 937 | |
| | 938 | // Update a menu and all submenus recursively. source is the object that has |
| | 939 | // the update event handlers defined for it. If NULL, the menu or associated |
| | 940 | // window will be used. |
| | 941 | void wxMenu::UpdateUI(wxEvtHandler* source) |
| | 942 | { |
| | 943 | if (!source && GetInvokingWindow()) |
| | 944 | source = GetInvokingWindow()->GetEventHandler(); |
| | 945 | if (!source) |
| | 946 | source = GetEventHandler(); |
| | 947 | if (!source) |
| | 948 | source = this; |
| | 949 | |
| | 950 | wxNode* node = GetItems().First(); |
| | 951 | while (node) |
| | 952 | { |
| | 953 | wxMenuItem* item = (wxMenuItem*) node->Data(); |
| | 954 | if ( !item->IsSeparator() ) |
| | 955 | { |
| | 956 | wxWindowID id = item->GetId(); |
| | 957 | wxUpdateUIEvent event(id); |
| | 958 | event.SetEventObject( source ); |
| | 959 | |
| | 960 | if (source->ProcessEvent(event)) |
| | 961 | { |
| | 962 | if (event.GetSetText()) |
| | 963 | SetLabel(id, event.GetText()); |
| | 964 | if (event.GetSetChecked()) |
| | 965 | Check(id, event.GetChecked()); |
| | 966 | if (event.GetSetEnabled()) |
| | 967 | Enable(id, event.GetEnabled()); |
| | 968 | } |
| | 969 | |
| | 970 | if (item->GetSubMenu()) |
| | 971 | item->GetSubMenu()->UpdateUI(source); |
| | 972 | } |
| | 973 | node = node->Next(); |
| | 974 | } |
| | 975 | } |
| | 976 | |
projects / wxWidgets.git / blame_incremental