src/motif/menu.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        menu.cpp
   3 // Purpose:     wxMenu, wxMenuBar, wxMenuItem
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     17/09/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12
  13 // ============================================================================
  14 // headers & declarations
  15 // ============================================================================
  16
  17 // wxWindows headers
  18 // -----------------
  19
  20 #ifdef __GNUG__
  21 #pragma implementation "menu.h"
  22 #pragma implementation "menuitem.h"
  23 #endif
  24
  25 #include "wx/menu.h"
  26 #include "wx/menuitem.h"
  27 #include "wx/log.h"
  28 #include "wx/utils.h"
  29 #include "wx/app.h"
  30 #include "wx/frame.h"
  31 #include "wx/settings.h"
  32
  33 #include <Xm/Label.h>
  34 #include <Xm/LabelG.h>
  35 #include <Xm/CascadeBG.h>
  36 #include <Xm/CascadeB.h>
  37 #include <Xm/SeparatoG.h>
  38 #include <Xm/PushBG.h>
  39 #include <Xm/ToggleB.h>
  40 #include <Xm/ToggleBG.h>
  41 #include <Xm/RowColumn.h>
  42
  43 #include "wx/motif/private.h"
  44
  45 // other standard headers
  46 // ----------------------
  47 #include <string.h>
  48
  49 #if !USE_SHARED_LIBRARY
  50 IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
  51 IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxEvtHandler)
  52 #endif
  53
  54 // ============================================================================
  55 // implementation
  56 // ============================================================================
  57
  58 // Menus
  59
  60 // Construct a menu with optional title (then use append)
  61 wxMenu::wxMenu(const wxString& title, const wxFunction func)
  62 {
  63     m_title = title;
  64     m_parent = (wxEvtHandler*) NULL;
  65     m_eventHandler = this;
  66     m_noItems = 0;
  67     m_menuBar = NULL;
  68     m_pInvokingWindow = NULL;
  69
  70     //// Motif-specific members
  71     m_numColumns = 1;
  72     m_menuWidget = (WXWidget) NULL;
  73     m_popupShell = (WXWidget) NULL;
  74     m_buttonWidget = (WXWidget) NULL;
  75     m_menuId = 0;
  76     m_topLevelMenu  = (wxMenu*) NULL;
  77     m_ownedByMenuBar = FALSE;
  78     m_menuParent = (wxMenu*) NULL;
  79     m_clientData = (void*) NULL;
  80
  81     if (m_title != "")
  82     {
  83         Append(ID_SEPARATOR, m_title) ;
  84         AppendSeparator() ;
  85     }
  86     m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_MENU);
  87     m_foregroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_MENUTEXT);
  88     m_font = wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT);
  89
  90     Callback(func);
  91 }
  92
  93 // The wxWindow destructor will take care of deleting the submenus.
  94 wxMenu::~wxMenu()
  95 {
  96     if (m_menuWidget)
  97     {
  98         if (m_menuParent)
  99             DestroyMenu(TRUE);
 100         else
 101             DestroyMenu(FALSE);
 102     }
 103
 104     // Not sure if this is right
 105     if (m_menuParent && m_menuBar)
 106     {
 107         m_menuParent = NULL;
 108         //      m_menuBar = NULL;
 109     }
 110
 111     wxNode *node = m_menuItems.First();
 112     while (node)
 113     {
 114         wxMenuItem *item = (wxMenuItem *)node->Data();
 115
 116         /*
 117         if (item->GetSubMenu())
 118         item->DeleteSubMenu();
 119         */
 120
 121         wxNode *next = node->Next();
 122         delete item;
 123         delete node;
 124         node = next;
 125     }
 126 }
 127
 128 void wxMenu::Break()
 129 {
 130     m_numColumns ++;
 131 }
 132
 133 // function appends a new item or submenu to the menu
 134 void wxMenu::Append(wxMenuItem *pItem)
 135 {
 136     wxCHECK_RET( pItem != NULL, "can't append NULL item to the menu" );
 137
 138     m_menuItems.Append(pItem);
 139
 140     if (m_menuWidget)
 141         pItem->CreateItem (m_menuWidget, m_menuBar, m_topLevelMenu);    // this is a dynamic Append
 142
 143     m_noItems++;
 144 }
 145
 146 void wxMenu::AppendSeparator()
 147 {
 148     Append(new wxMenuItem(this, ID_SEPARATOR));
 149 }
 150
 151 // Pullright item
 152 // N.B.: difference between old and new code.
 153 // Old code stores subMenu in 'children' for later deletion,
 154 // as well as in m_menuItems, whereas we only store it in
 155 // m_menuItems here. What implications does this have?
 156
 157 void wxMenu::Append(int id, const wxString& label, wxMenu *subMenu,
 158                     const wxString& helpString)
 159 {
 160     Append(new wxMenuItem(this, id, label, helpString, FALSE, subMenu));
 161
 162     subMenu->m_topLevelMenu = m_topLevelMenu;
 163 }
 164
 165 // Ordinary menu item
 166 void wxMenu::Append(int id, const wxString& label,
 167                     const wxString& helpString, bool checkable)
 168 {
 169     // 'checkable' parameter is useless for Windows.
 170     Append(new wxMenuItem(this, id, label, helpString, checkable));
 171 }
 172
 173 void wxMenu::Delete(int id)
 174 {
 175     wxNode *node;
 176     wxMenuItem *item;
 177     int pos;
 178
 179     for (pos = 0, node = m_menuItems.First(); node; node = node->Next(), pos++)
 180     {
 181         item = (wxMenuItem *)node->Data();
 182         if (item->GetId() == id)
 183             break;
 184     }
 185
 186     if (!node)
 187         return;
 188
 189     item->DestroyItem(TRUE);
 190
 191     // See also old code - don't know if this is needed (seems redundant).
 192     /*
 193     if (item->GetSubMenu()) {
 194     item->subMenu->top_level_menu = item->GetSubMenu();
 195     item->subMenu->window_parent = NULL;
 196     children->DeleteObject(item->GetSubMenu());
 197     }
 198     */
 199
 200     m_menuItems.DeleteNode(node);
 201     delete item;
 202 }
 203
 204 void wxMenu::Enable(int id, bool flag)
 205 {
 206     wxMenuItem *item = FindItemForId(id);
 207     wxCHECK_RET( item != NULL, "can't enable non-existing menu item" );
 208
 209     item->Enable(flag);
 210 }
 211
 212 bool wxMenu::Enabled(int Id) const
 213 {
 214     wxMenuItem *item = FindItemForId(Id);
 215     wxCHECK( item != NULL, FALSE );
 216
 217     return item->IsEnabled();
 218 }
 219
 220 void wxMenu::Check(int Id, bool Flag)
 221 {
 222     wxMenuItem *item = FindItemForId(Id);
 223     wxCHECK_RET( item != NULL, "can't get status of non-existing menu item" );
 224
 225     item->Check(Flag);
 226 }
 227
 228 bool wxMenu::Checked(int id) const
 229 {
 230     wxMenuItem *item = FindItemForId(id);
 231     wxCHECK( item != NULL, FALSE );
 232
 233     return item->IsChecked();
 234 }
 235
 236 void wxMenu::SetTitle(const wxString& label)
 237 {
 238     m_title = label ;
 239
 240     wxNode *node = m_menuItems.First ();
 241     if (!node)
 242         return;
 243
 244     wxMenuItem *item = (wxMenuItem *) node->Data ();
 245     Widget widget = (Widget) item->GetButtonWidget();
 246     if (!widget)
 247         return;
 248
 249     XmString title_str = XmStringCreateSimple ((char*) (const char*) label);
 250     XtVaSetValues (widget,
 251         XmNlabelString, title_str,
 252         NULL);
 253     // TODO: should we delete title_str now?
 254 }
 255
 256 const wxString wxMenu::GetTitle() const
 257 {
 258     return m_title;
 259 }
 260
 261 void wxMenu::SetLabel(int id, const wxString& label)
 262 {
 263     wxMenuItem *item = FindItemForId(id);
 264     if (item == (wxMenuItem*) NULL)
 265         return;
 266
 267     item->SetLabel(label);
 268 }
 269
 270 wxString wxMenu::GetLabel(int id) const
 271 {
 272     wxMenuItem *it = NULL;
 273     WXWidget w = FindMenuItem (id, &it);
 274     if (w)
 275     {
 276         XmString text;
 277         char *s;
 278         XtVaGetValues ((Widget) w,
 279             XmNlabelString, &text,
 280             NULL);
 281
 282         if (XmStringGetLtoR (text, XmSTRING_DEFAULT_CHARSET, &s))
 283         {
 284             wxString str(s);
 285             XtFree (s);
 286             return str;
 287         }
 288         else
 289         {
 290             XmStringFree (text);
 291             return wxEmptyString;
 292         }
 293     }
 294     else
 295         return wxEmptyString;
 296 }
 297
 298 // Finds the item id matching the given string, -1 if not found.
 299 int wxMenu::FindItem (const wxString& itemString) const
 300 {
 301     char buf1[200];
 302     char buf2[200];
 303     wxStripMenuCodes ((char *)(const char *)itemString, buf1);
 304
 305     for (wxNode * node = m_menuItems.First (); node; node = node->Next ())
 306     {
 307         wxMenuItem *item = (wxMenuItem *) node->Data ();
 308         if (item->GetSubMenu())
 309         {
 310             int ans = item->GetSubMenu()->FindItem(itemString);
 311             if (ans > -1)
 312                 return ans;
 313         }
 314         if ( !item->IsSeparator() )
 315         {
 316             wxStripMenuCodes((char *)item->GetName().c_str(), buf2);
 317             if (strcmp(buf1, buf2) == 0)
 318                 return item->GetId();
 319         }
 320     }
 321
 322     return -1;
 323 }
 324
 325 wxMenuItem *wxMenu::FindItemForId(int itemId, wxMenu ** itemMenu) const
 326 {
 327     if (itemMenu)
 328         *itemMenu = NULL;
 329     for (wxNode * node = m_menuItems.First (); node; node = node->Next ())
 330     {
 331         wxMenuItem *item = (wxMenuItem *) node->Data ();
 332
 333         if (item->GetId() == itemId)
 334         {
 335             if (itemMenu)
 336                 *itemMenu = (wxMenu *) this;
 337             return item;
 338         }
 339
 340         if (item->GetSubMenu())
 341         {
 342             wxMenuItem *ans = item->GetSubMenu()->FindItemForId (itemId, itemMenu);
 343             if (ans)
 344                 return ans;
 345         }
 346     }
 347
 348     if (itemMenu)
 349         *itemMenu = NULL;
 350     return NULL;
 351 }
 352
 353 void wxMenu::SetHelpString(int itemId, const wxString& helpString)
 354 {
 355     wxMenuItem *item = FindItemForId (itemId);
 356     if (item)
 357         item->SetHelp(helpString);
 358 }
 359
 360 wxString wxMenu::GetHelpString (int itemId) const
 361 {
 362     wxMenuItem *item = FindItemForId (itemId);
 363     wxString str("");
 364     return (item == NULL) ? str : item->GetHelp();
 365 }
 366
 367 void wxMenu::ProcessCommand(wxCommandEvent & event)
 368 {
 369     bool processed = FALSE;
 370
 371     // Try a callback
 372     if (m_callback)
 373     {
 374         (void) (*(m_callback)) (*this, event);
 375         processed = TRUE;
 376     }
 377
 378     // Try the menu's event handler
 379     if ( !processed && GetEventHandler())
 380     {
 381         processed = GetEventHandler()->ProcessEvent(event);
 382     }
 383     // Try the window the menu was popped up from (and up
 384     // through the hierarchy)
 385     if ( !processed && GetInvokingWindow())
 386     processed = GetInvokingWindow()->ProcessEvent(event);
 387 }
 388
 389 // Update a menu and all submenus recursively.
 390 // source is the object that has the update event handlers
 391 // defined for it. If NULL, the menu or associated window
 392 // will be used.
 393 void wxMenu::UpdateUI(wxEvtHandler* source)
 394 {
 395   if (!source && GetInvokingWindow())
 396     source = GetInvokingWindow()->GetEventHandler();
 397   if (!source)
 398     source = GetEventHandler();
 399   if (!source)
 400     source = this;
 401
 402   wxNode* node = GetItems().First();
 403   while (node)
 404   {
 405     wxMenuItem* item = (wxMenuItem*) node->Data();
 406     if ( !item->IsSeparator() )
 407     {
 408       wxWindowID id = item->GetId();
 409       wxUpdateUIEvent event(id);
 410       event.SetEventObject( source );
 411
 412       if (source->ProcessEvent(event))
 413       {
 414         if (event.GetSetText())
 415           SetLabel(id, event.GetText());
 416         if (event.GetSetChecked())
 417           Check(id, event.GetChecked());
 418         if (event.GetSetEnabled())
 419           Enable(id, event.GetEnabled());
 420       }
 421
 422       if (item->GetSubMenu())
 423         item->GetSubMenu()->UpdateUI(source);
 424     }
 425     node = node->Next();
 426   }
 427 }
 428
 429 bool wxWindow::PopupMenu(wxMenu *menu, int x, int y)
 430 {
 431     Widget widget = (Widget) GetMainWidget();
 432
 433     /* The menuId field seems to be usused, so we'll use it to
 434     indicate whether a menu is popped up or not:
 435     0: Not currently created as a popup
 436     -1: Created as a popup, but not active
 437     1: Active popup.
 438     */
 439
 440     if (menu->GetParent() && (menu->GetId() != -1))
 441         return FALSE;
 442
 443     if (menu->GetMainWidget()) {
 444         menu->DestroyMenu(TRUE);
 445     }
 446
 447     wxWindow *parent = this;
 448
 449     menu->SetId(1); /* Mark as popped-up */
 450     menu->CreateMenu(NULL, widget, menu);
 451     menu->SetInvokingWindow(this);
 452
 453     menu->UpdateUI();
 454
 455     //  menu->SetParent(parent);
 456     //  parent->children->Append(menu);  // Store menu for later deletion
 457
 458     Widget menuWidget = (Widget) menu->GetMainWidget();
 459
 460     int rootX = 0;
 461     int rootY = 0;
 462
 463     int deviceX = x;
 464     int deviceY = y;
 465     /*
 466     if (this->IsKindOf(CLASSINFO(wxCanvas)))
 467     {
 468     wxCanvas *canvas = (wxCanvas *) this;
 469     deviceX = canvas->GetDC ()->LogicalToDeviceX (x);
 470     deviceY = canvas->GetDC ()->LogicalToDeviceY (y);
 471     }
 472     */
 473
 474     Display *display = XtDisplay (widget);
 475     Window rootWindow = RootWindowOfScreen (XtScreen((Widget)widget));
 476     Window thisWindow = XtWindow (widget);
 477     Window childWindow;
 478     XTranslateCoordinates (display, thisWindow, rootWindow, (int) deviceX, (int) deviceY,
 479         &rootX, &rootY, &childWindow);
 480
 481     XButtonPressedEvent event;
 482     event.type = ButtonPress;
 483     event.button = 1;
 484
 485     event.x = deviceX;
 486     event.y = deviceY;
 487
 488     event.x_root = rootX;
 489     event.y_root = rootY;
 490
 491     XmMenuPosition (menuWidget, &event);
 492     XtManageChild (menuWidget);
 493
 494     return TRUE;
 495 }
 496
 497 // Menu Bar
 498 wxMenuBar::wxMenuBar()
 499 {
 500     m_eventHandler = this;
 501     m_menuCount = 0;
 502     m_menus = NULL;
 503     m_titles = NULL;
 504     m_menuBarFrame = NULL;
 505     m_mainWidget = (WXWidget) NULL;
 506     m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_MENU);
 507     m_foregroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_MENUTEXT);
 508     m_font = wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT);
 509 }
 510
 511 wxMenuBar::wxMenuBar(long WXUNUSED(style))
 512 {
 513     m_eventHandler = this;
 514     m_menuCount = 0;
 515     m_menus = NULL;
 516     m_titles = NULL;
 517     m_menuBarFrame = NULL;
 518     m_mainWidget = (WXWidget) NULL;
 519     m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_MENU);
 520     m_foregroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_MENUTEXT);
 521     m_font = wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT);
 522 }
 523
 524 wxMenuBar::wxMenuBar(int n, wxMenu *menus[], const wxString titles[])
 525 {
 526     m_eventHandler = this;
 527     m_menuCount = n;
 528     m_menus = menus;
 529     m_titles = new wxString[n];
 530     int i;
 531     for ( i = 0; i < n; i++ )
 532         m_titles[i] = titles[i];
 533     m_menuBarFrame = NULL;
 534     m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_MENU);
 535     m_foregroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_MENUTEXT);
 536     m_font = wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT);
 537 }
 538
 539 wxMenuBar::~wxMenuBar()
 540 {
 541     int i;
 542     for (i = 0; i < m_menuCount; i++)
 543     {
 544         delete m_menus[i];
 545     }
 546     delete[] m_menus;
 547     delete[] m_titles;
 548 }
 549
 550 // Must only be used AFTER menu has been attached to frame,
 551 // otherwise use individual menus to enable/disable items
 552 void wxMenuBar::Enable(int id, bool flag)
 553 {
 554     wxMenu *itemMenu = NULL;
 555     wxMenuItem *item = FindItemForId(id, &itemMenu) ;
 556     if (!item)
 557         return;
 558     item->Enable(flag);
 559 }
 560
 561 void wxMenuBar::EnableTop(int pos, bool flag)
 562 {
 563     // TODO
 564 }
 565
 566 // Must only be used AFTER menu has been attached to frame,
 567 // otherwise use individual menus
 568 void wxMenuBar::Check(int id, bool flag)
 569 {
 570     wxMenu *itemMenu = NULL;
 571     wxMenuItem *item = FindItemForId(id, &itemMenu) ;
 572     if (!item)
 573         return;
 574
 575     if (!item->IsCheckable())
 576         return ;
 577
 578     item->Check(flag);
 579 }
 580
 581 bool wxMenuBar::Checked(int id) const
 582 {
 583     wxMenu *itemMenu = NULL;
 584     wxMenuItem *item = FindItemForId(id, &itemMenu) ;
 585     if (!item)
 586         return FALSE;
 587
 588     return item->IsChecked();
 589 }
 590
 591 bool wxMenuBar::Enabled(int id) const
 592 {
 593     wxMenu *itemMenu = NULL;
 594     wxMenuItem *item = FindItemForId(id, &itemMenu) ;
 595     if (!item)
 596         return FALSE;
 597
 598     return item->IsEnabled();
 599 }
 600
 601 void wxMenuBar::SetLabel(int id, const wxString& label)
 602 {
 603     wxMenu *itemMenu = NULL;
 604     wxMenuItem *item = FindItemForId(id, &itemMenu) ;
 605
 606     if (!item)
 607         return;
 608
 609     item->SetLabel(label);
 610 }
 611
 612 wxString wxMenuBar::GetLabel(int id) const
 613 {
 614     wxMenu *itemMenu = NULL;
 615     wxMenuItem *item = FindItemForId(id, &itemMenu) ;
 616
 617     if (!item)
 618         return wxString("");
 619
 620     return item->GetLabel();
 621 }
 622
 623 void wxMenuBar::SetLabelTop(int pos, const wxString& label)
 624 {
 625     wxASSERT( (pos < m_menuCount) );
 626
 627     Widget w = (Widget) m_menus[pos]->GetButtonWidget();
 628     if (w)
 629     {
 630         XmString label_str = XmStringCreateSimple ((char*) (const char*) label);
 631         XtVaSetValues (w,
 632             XmNlabelString, label_str,
 633             NULL);
 634         XmStringFree (label_str);
 635     }
 636 }
 637
 638 wxString wxMenuBar::GetLabelTop(int pos) const
 639 {
 640     wxASSERT( (pos < m_menuCount) );
 641
 642     Widget w = (Widget) m_menus[pos]->GetButtonWidget();
 643     if (w)
 644     {
 645         XmString text;
 646         char *s;
 647         XtVaGetValues (w,
 648             XmNlabelString, &text,
 649             NULL);
 650
 651         if (XmStringGetLtoR (text, XmSTRING_DEFAULT_CHARSET, &s))
 652         {
 653             wxString str(s);
 654             XtFree (s);
 655             return str;
 656         }
 657         else
 658         {
 659             return wxEmptyString;
 660         }
 661     }
 662     else
 663         return wxEmptyString;
 664
 665 }
 666
 667 bool wxMenuBar::OnDelete(wxMenu *menu, int pos)
 668 {
 669     // Only applies to dynamic deletion (when set in frame)
 670     if (!m_menuBarFrame)
 671         return TRUE;
 672
 673     menu->DestroyMenu(TRUE);
 674     return TRUE;
 675 }
 676
 677 bool wxMenuBar::OnAppend(wxMenu *menu, const char *title)
 678 {
 679     // Only applies to dynamic append (when set in frame)
 680     if (!m_menuBarFrame)
 681         return TRUE;
 682
 683     // Probably should be an assert here
 684     if (menu->GetParent())
 685         return FALSE;
 686
 687     // Has already been appended
 688     if (menu->GetButtonWidget())
 689         return FALSE;
 690
 691     WXWidget w = menu->CreateMenu(this, GetMainWidget(), menu, title, TRUE);
 692     menu->SetButtonWidget(w);
 693
 694     return TRUE;
 695 }
 696
 697 void wxMenuBar::Append (wxMenu * menu, const wxString& title)
 698 {
 699     if (!OnAppend(menu, title))
 700         return;
 701
 702     m_menuCount ++;
 703     wxMenu **new_menus = new wxMenu *[m_menuCount];
 704     wxString *new_titles = new wxString[m_menuCount];
 705     int i;
 706
 707     for (i = 0; i < m_menuCount - 1; i++)
 708     {
 709         new_menus[i] = m_menus[i];
 710         m_menus[i] = NULL;
 711         new_titles[i] = m_titles[i];
 712         m_titles[i] = "";
 713     }
 714     if (m_menus)
 715     {
 716         delete[]m_menus;
 717         delete[]m_titles;
 718     }
 719     m_menus = new_menus;
 720     m_titles = new_titles;
 721
 722     m_menus[m_menuCount - 1] = (wxMenu *)menu;
 723     m_titles[m_menuCount - 1] = title;
 724
 725     menu->SetMenuBar(this);
 726     menu->SetParent(this);
 727 }
 728
 729 void wxMenuBar::Delete(wxMenu * menu, int i)
 730 {
 731     int j;
 732     int ii = (int) i;
 733
 734     if (menu != 0)
 735     {
 736         for (ii = 0; ii < m_menuCount; ii++)
 737         {
 738             if (m_menus[ii] == menu)
 739                 break;
 740         }
 741         if (ii >= m_menuCount)
 742             return;
 743     } else
 744     {
 745         if (ii < 0 || ii >= m_menuCount)
 746             return;
 747         menu = m_menus[ii];
 748     }
 749
 750     if (!OnDelete(menu, ii))
 751         return;
 752
 753     menu->SetParent((wxEvtHandler*) NULL);
 754
 755     -- m_menuCount;
 756     for (j = ii; j < m_menuCount; j++)
 757     {
 758         m_menus[j] = m_menus[j + 1];
 759         m_titles[j] = m_titles[j + 1];
 760     }
 761 }
 762
 763 // Find the menu menuString, item itemString, and return the item id.
 764 // Returns -1 if none found.
 765 int wxMenuBar::FindMenuItem (const wxString& menuString, const wxString& itemString) const
 766 {
 767     char buf1[200];
 768     char buf2[200];
 769     wxStripMenuCodes ((char *)(const char *)menuString, buf1);
 770     int i;
 771     for (i = 0; i < m_menuCount; i++)
 772     {
 773         wxStripMenuCodes ((char *)(const char *)m_titles[i], buf2);
 774         if (strcmp (buf1, buf2) == 0)
 775             return m_menus[i]->FindItem (itemString);
 776     }
 777     return -1;
 778 }
 779
 780 wxMenuItem *wxMenuBar::FindItemForId (int id, wxMenu ** itemMenu) const
 781 {
 782     if (itemMenu)
 783         *itemMenu = NULL;
 784
 785     wxMenuItem *item = NULL;
 786     int i;
 787     for (i = 0; i < m_menuCount; i++)
 788         if ((item = m_menus[i]->FindItemForId (id, itemMenu)))
 789             return item;
 790         return NULL;
 791 }
 792
 793 void wxMenuBar::SetHelpString (int id, const wxString& helpString)
 794 {
 795     int i;
 796     for (i = 0; i < m_menuCount; i++)
 797     {
 798         if (m_menus[i]->FindItemForId (id))
 799         {
 800             m_menus[i]->SetHelpString (id, helpString);
 801             return;
 802         }
 803     }
 804 }
 805
 806 wxString wxMenuBar::GetHelpString (int id) const
 807 {
 808     int i;
 809     for (i = 0; i < m_menuCount; i++)
 810     {
 811         if (m_menus[i]->FindItemForId (id))
 812             return wxString(m_menus[i]->GetHelpString (id));
 813     }
 814     return wxString("");
 815 }
 816
 817 // Create menubar
 818 bool wxMenuBar::CreateMenuBar(wxFrame* parent)
 819 {
 820     if (m_mainWidget)
 821     {
 822         XtVaSetValues((Widget) parent->GetMainWindowWidget(), XmNmenuBar, (Widget) m_mainWidget, NULL);
 823         /*
 824         if (!XtIsManaged((Widget) m_mainWidget))
 825         XtManageChild((Widget) m_mainWidget);
 826         */
 827         XtMapWidget((Widget) m_mainWidget);
 828         return TRUE;
 829     }
 830
 831     Widget menuBarW = XmCreateMenuBar ((Widget) parent->GetMainWindowWidget(), "MenuBar", NULL, 0);
 832     m_mainWidget = (WXWidget) menuBarW;
 833
 834     int i;
 835     for (i = 0; i < GetMenuCount(); i++)
 836     {
 837         wxMenu *menu = GetMenu(i);
 838         wxString title(m_titles[i]);
 839         menu->SetButtonWidget(menu->CreateMenu (this, menuBarW, menu, title, TRUE));
 840
 841         /*
 842         * COMMENT THIS OUT IF YOU DON'T LIKE A RIGHT-JUSTIFIED HELP MENU
 843         */
 844         wxStripMenuCodes ((char*) (const char*) title, wxBuffer);
 845
 846         if (strcmp (wxBuffer, "Help") == 0)
 847             XtVaSetValues ((Widget) menuBarW, XmNmenuHelpWidget, (Widget) menu->GetButtonWidget(), NULL);
 848     }
 849
 850     SetBackgroundColour(m_backgroundColour);
 851     SetForegroundColour(m_foregroundColour);
 852     SetFont(m_font);
 853
 854     XtVaSetValues((Widget) parent->GetMainWindowWidget(), XmNmenuBar, (Widget) m_mainWidget, NULL);
 855     XtRealizeWidget ((Widget) menuBarW);
 856     XtManageChild ((Widget) menuBarW);
 857     SetMenuBarFrame(parent);
 858
 859     return TRUE;
 860 }
 861
 862 // Destroy menubar, but keep data structures intact so we can recreate it.
 863 bool wxMenuBar::DestroyMenuBar()
 864 {
 865     if (!m_mainWidget)
 866     {
 867         SetMenuBarFrame((wxFrame*) NULL);
 868         return FALSE;
 869     }
 870
 871     XtUnmanageChild ((Widget) m_mainWidget);
 872     XtUnrealizeWidget ((Widget) m_mainWidget);
 873
 874     int i;
 875     for (i = 0; i < GetMenuCount(); i++)
 876     {
 877         wxMenu *menu = GetMenu(i);
 878         menu->DestroyMenu(TRUE);
 879
 880     }
 881     XtDestroyWidget((Widget) m_mainWidget);
 882     m_mainWidget = (WXWidget) 0;
 883
 884     SetMenuBarFrame((wxFrame*) NULL);
 885
 886     return TRUE;
 887 }
 888
 889 //// Motif-specific
 890
 891 extern wxApp *wxTheApp;
 892 static XtWorkProcId WorkProcMenuId;
 893
 894 /* Since PopupMenu under Motif stills grab right mouse button events
 895 * after it was closed, we need to delete the associated widgets to
 896 * allow next PopUpMenu to appear...
 897 */
 898
 899 int PostDeletionOfMenu( XtPointer* clientData )
 900 {
 901     XtRemoveWorkProc(WorkProcMenuId);
 902     wxMenu *menu = (wxMenu *)clientData;
 903
 904     if (menu->GetMainWidget()) {
 905         if (menu->GetParent())
 906         {
 907             wxList& list = menu->GetParent()->GetItems();
 908             list.DeleteObject(menu);
 909         }
 910         menu->DestroyMenu(TRUE);
 911     }
 912     /* Mark as no longer popped up */
 913     menu->m_menuId = -1;
 914     return TRUE;
 915 }
 916
 917 void
 918 wxMenuPopdownCallback(Widget w, XtPointer clientData,
 919                       XtPointer ptr)
 920 {
 921     wxMenu *menu = (wxMenu *)clientData;
 922
 923     // Added by JOREL Jean-Charles <jjorel@silr.ireste.fr>
 924     /* Since Callbacks of MenuItems are not yet processed, we put a
 925     * background job which will be done when system will be idle.
 926     * What awful hack!! :(
 927     */
 928
 929     WorkProcMenuId = XtAppAddWorkProc(
 930         (XtAppContext) wxTheApp->GetAppContext(),
 931         (XtWorkProc) PostDeletionOfMenu,
 932         (XtPointer) menu );
 933     // Apparently not found in Motif headers
 934     //  XtVaSetValues( w, XmNpopupEnabled, XmPOPUP_DISABLED, NULL );
 935 }
 936
 937 /*
 938 * Create a popup or pulldown menu.
 939 * Submenus of a popup will be pulldown.
 940 *
 941 */
 942
 943 WXWidget wxMenu::CreateMenu (wxMenuBar * menuBar, WXWidget parent, wxMenu * topMenu, const wxString& title, bool pullDown)
 944 {
 945     Widget menu = (Widget) 0;
 946     Widget buttonWidget = (Widget) 0;
 947     Arg args[5];
 948     XtSetArg (args[0], XmNnumColumns, m_numColumns);
 949     XtSetArg (args[1], XmNpacking, XmPACK_COLUMN);
 950
 951     if (!pullDown)
 952     {
 953         menu = XmCreatePopupMenu ((Widget) parent, "popup", args, 2);
 954         XtAddCallback(menu,
 955             XmNunmapCallback,
 956             (XtCallbackProc)wxMenuPopdownCallback,
 957             (XtPointer)this);
 958     }
 959     else
 960     {
 961         char mnem = wxFindMnemonic (title);
 962         wxStripMenuCodes ((char*) (const char*) title, wxBuffer);
 963
 964         menu = XmCreatePulldownMenu ((Widget) parent, "pulldown", args, 2);
 965
 966         XmString label_str = XmStringCreateSimple (wxBuffer);
 967         buttonWidget = XtVaCreateManagedWidget (wxBuffer,
 968 #if wxUSE_GADGETS
 969             xmCascadeButtonGadgetClass, (Widget) parent,
 970 #else
 971             xmCascadeButtonWidgetClass, (Widget) parent,
 972 #endif
 973             XmNlabelString, label_str,
 974             XmNsubMenuId, menu,
 975             NULL);
 976
 977         if (mnem != 0)
 978             XtVaSetValues (buttonWidget, XmNmnemonic, mnem, NULL);
 979
 980         XmStringFree (label_str);
 981     }
 982
 983     m_menuWidget = (WXWidget) menu;
 984
 985     m_menuBar = menuBar;
 986     m_topLevelMenu = topMenu;
 987
 988     for (wxNode * node = m_menuItems.First (); node; node = node->Next ())
 989     {
 990         wxMenuItem *item = (wxMenuItem *) node->Data ();
 991         item->CreateItem (menu, menuBar, topMenu);
 992     }
 993
 994     SetBackgroundColour(m_backgroundColour);
 995     SetForegroundColour(m_foregroundColour);
 996     SetFont(m_font);
 997
 998     return buttonWidget;
 999 }
1000
1001 // Destroys the Motif implementation of the menu,
1002 // but maintains the wxWindows data structures so we can
1003 // do a CreateMenu again.
1004 void wxMenu::DestroyMenu (bool full)
1005 {
1006     for (wxNode * node = m_menuItems.First (); node; node = node->Next ())
1007     {
1008         wxMenuItem *item = (wxMenuItem *) node->Data ();
1009         item->SetMenuBar((wxMenuBar*) NULL);
1010
1011         item->DestroyItem(full);
1012     }                           // for()
1013
1014     if (m_buttonWidget)
1015     {
1016         if (full)
1017         {
1018             XtVaSetValues((Widget) m_buttonWidget, XmNsubMenuId, NULL, NULL);
1019             XtDestroyWidget ((Widget) m_buttonWidget);
1020             m_buttonWidget = (WXWidget) 0;
1021         }
1022     }
1023     if (m_menuWidget && full)
1024     {
1025         XtDestroyWidget((Widget) m_menuWidget);
1026         m_menuWidget = (WXWidget) NULL;
1027     }
1028 }
1029
1030 WXWidget wxMenu::FindMenuItem (int id, wxMenuItem ** it) const
1031 {
1032     if (id == m_menuId)
1033     {
1034         if (it)
1035             *it = (wxMenuItem*) NULL;
1036         return m_buttonWidget;
1037     }
1038
1039     for (wxNode * node = m_menuItems.First (); node; node = node->Next ())
1040     {
1041         wxMenuItem *item = (wxMenuItem *) node->Data ();
1042         if (item->GetId() == id)
1043         {
1044             if (it)
1045                 *it = item;
1046             return item->GetButtonWidget();
1047         }
1048
1049         if (item->GetSubMenu())
1050         {
1051             WXWidget w = item->GetSubMenu()->FindMenuItem (id, it);
1052             if (w)
1053             {
1054                 return w;
1055             }
1056         }
1057     }                           // for()
1058
1059     if (it)
1060         *it = (wxMenuItem*) NULL;
1061     return (WXWidget) NULL;
1062 }
1063
1064 void wxMenu::SetBackgroundColour(const wxColour& col)
1065 {
1066     m_backgroundColour = col;
1067     if (m_menuWidget)
1068         wxDoChangeBackgroundColour(m_menuWidget, (wxColour&) col);
1069     if (m_buttonWidget)
1070         wxDoChangeBackgroundColour(m_buttonWidget, (wxColour&) col, TRUE);
1071
1072     wxNode* node = m_menuItems.First();
1073     while (node)
1074     {
1075         wxMenuItem* item = (wxMenuItem*) node->Data();
1076         if (item->GetButtonWidget())
1077         {
1078             // This crashes because it uses gadgets
1079             //            wxDoChangeBackgroundColour(item->GetButtonWidget(), (wxColour&) col, TRUE);
1080         }
1081         if (item->GetSubMenu())
1082             item->GetSubMenu()->SetBackgroundColour((wxColour&) col);
1083         node = node->Next();
1084     }
1085 }
1086
1087 void wxMenu::SetForegroundColour(const wxColour& col)
1088 {
1089     m_foregroundColour = col;
1090     if (m_menuWidget)
1091         wxDoChangeForegroundColour(m_menuWidget, (wxColour&) col);
1092     if (m_buttonWidget)
1093         wxDoChangeForegroundColour(m_buttonWidget, (wxColour&) col);
1094
1095     wxNode* node = m_menuItems.First();
1096     while (node)
1097     {
1098         wxMenuItem* item = (wxMenuItem*) node->Data();
1099         if (item->GetButtonWidget())
1100         {
1101             // This crashes because it uses gadgets
1102             //            wxDoChangeForegroundColour(item->GetButtonWidget(), (wxColour&) col);
1103         }
1104         if (item->GetSubMenu())
1105             item->GetSubMenu()->SetForegroundColour((wxColour&) col);
1106         node = node->Next();
1107     }
1108 }
1109
1110 void wxMenu::ChangeFont(bool keepOriginalSize)
1111 {
1112     // lesstif 0.87 hangs when setting XmNfontList
1113 #ifndef LESSTIF_VERSION
1114     if (!m_font.Ok() || !m_menuWidget)
1115         return;
1116
1117     XmFontList fontList = (XmFontList) m_font.GetFontList(1.0, XtDisplay((Widget) m_menuWidget));
1118
1119     XtVaSetValues ((Widget) m_menuWidget,
1120         XmNfontList, fontList,
1121         NULL);
1122     if (m_buttonWidget)
1123     {
1124         XtVaSetValues ((Widget) m_buttonWidget,
1125             XmNfontList, fontList,
1126             NULL);
1127     }
1128     wxNode* node = m_menuItems.First();
1129     while (node)
1130     {
1131         wxMenuItem* item = (wxMenuItem*) node->Data();
1132         if (m_menuWidget && item->GetButtonWidget() && m_font.Ok())
1133         {
1134             XtVaSetValues ((Widget) item->GetButtonWidget(),
1135                 XmNfontList, fontList,
1136                 NULL);
1137         }
1138         if (item->GetSubMenu())
1139             item->GetSubMenu()->ChangeFont(keepOriginalSize);
1140         node = node->Next();
1141     }
1142 #endif
1143 }
1144
1145 void wxMenu::SetFont(const wxFont& font)
1146 {
1147     m_font = font;
1148     ChangeFont();
1149 }
1150
1151 void wxMenuBar::SetBackgroundColour(const wxColour& col)
1152 {
1153
1154     m_backgroundColour = col;
1155     if (m_mainWidget)
1156         wxDoChangeBackgroundColour(m_mainWidget, (wxColour&) col);
1157     int i;
1158     for (i = 0; i < m_menuCount; i++)
1159         m_menus[i]->SetBackgroundColour((wxColour&) col);
1160 }
1161
1162 void wxMenuBar::SetForegroundColour(const wxColour& col)
1163 {
1164     m_foregroundColour = col;
1165     if (m_mainWidget)
1166         wxDoChangeForegroundColour(m_mainWidget, (wxColour&) col);
1167
1168     int i;
1169     for (i = 0; i < m_menuCount; i++)
1170         m_menus[i]->SetForegroundColour((wxColour&) col);
1171 }
1172
1173 void wxMenuBar::ChangeFont(bool keepOriginalSize)
1174 {
1175     // Nothing to do for menubar, fonts are kept in wxMenus
1176 }
1177
1178 void wxMenuBar::SetFont(const wxFont& font)
1179 {
1180     m_font = font;
1181     ChangeFont();
1182
1183     int i;
1184     for (i = 0; i < m_menuCount; i++)
1185         m_menus[i]->SetFont(font);
1186 }
1187