vcl/osx/salmenu.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include <objc/objc-runtime.h>
  23
  24 #include <comphelper/string.hxx>
  25 #include <rtl/ustrbuf.hxx>
  26
  27 #include <vcl/commandevent.hxx>
  28 #include <vcl/floatwin.hxx>
  29 #include <vcl/window.hxx>
  30 #include <vcl/svapp.hxx>
  31
  32 #include "osx/saldata.hxx"
  33 #include "osx/salinst.h"
  34 #include "osx/salmenu.h"
  35 #include "osx/salnsmenu.h"
  36 #include "osx/salframe.h"
  37 #include "osx/a11ywrapper.h"
  38 #include "quartz/utils.h"
  39 #include "svids.hrc"
  40 #include "window.h"
  41
  42 namespace {
  43
  44 void releaseButtonEntry( AquaSalMenu::MenuBarButtonEntry& i_rEntry )
  45 {
  46     if( i_rEntry.mpNSImage )
  47     {
  48         [i_rEntry.mpNSImage release];
  49         i_rEntry.mpNSImage = nil;
  50     }
  51     if( i_rEntry.mpToolTipString )
  52     {
  53         [i_rEntry.mpToolTipString release];
  54         i_rEntry.mpToolTipString = nil;
  55     }
  56 }
  57
  58 }
  59
  60 const AquaSalMenu* AquaSalMenu::pCurrentMenuBar = nullptr;
  61
  62 @interface MainMenuSelector : NSObject
  63 {
  64 }
  65 -(void)showDialog: (ShowDialogId)nDialog;
  66 -(void)showPreferences: (id)sender;
  67 -(void)showAbout: (id)sender;
  68 @end
  69
  70 @implementation MainMenuSelector
  71 -(void)showDialog: (ShowDialogId)nDialog
  72 {
  73     if( AquaSalMenu::pCurrentMenuBar )
  74     {
  75         const AquaSalFrame* pFrame = AquaSalMenu::pCurrentMenuBar->mpFrame;
  76         if( pFrame && AquaSalFrame::isAlive( pFrame ) )
  77         {
  78             pFrame->CallCallback( SalEvent::ShowDialog, reinterpret_cast<void*>(nDialog) );
  79         }
  80     }
  81     else
  82     {
  83         OUString aDialog;
  84         if( nDialog == ShowDialogId::About )
  85             aDialog = "ABOUT";
  86         else if( nDialog == ShowDialogId::Preferences )
  87             aDialog = "PREFERENCES";
  88         const ApplicationEvent* pAppEvent = new ApplicationEvent(
  89             ApplicationEvent::Type::ShowDialog, aDialog);
  90         AquaSalInstance::aAppEventList.push_back( pAppEvent );
  91     }
  92 }
  93
  94 -(void)showPreferences: (id) sender
  95 {
  96     (void)sender;
  97     SolarMutexGuard aGuard;
  98
  99     [self showDialog: ShowDialogId::Preferences];
 100 }
 101 -(void)showAbout: (id) sender
 102 {
 103     (void)sender;
 104     SolarMutexGuard aGuard;
 105
 106     [self showDialog: ShowDialogId::About];
 107 }
 108 @end
 109
 110 // FIXME: currently this is leaked
 111 static MainMenuSelector* pMainMenuSelector = nil;
 112
 113 static void initAppMenu()
 114 {
 115     static bool bOnce = true;
 116     if( bOnce )
 117     {
 118         bOnce = false;
 119
 120         ResMgr* pMgr = ImplGetResMgr();
 121         if( pMgr )
 122         {
 123             // get the main menu
 124             NSMenu* pMainMenu = [NSApp mainMenu];
 125             if( pMainMenu != nil )
 126             {
 127                 // create the action selector
 128                 pMainMenuSelector = [[MainMenuSelector alloc] init];
 129
 130                 // get the proper submenu
 131                 NSMenu* pAppMenu = [[pMainMenu itemAtIndex: 0] submenu];
 132                 if( pAppMenu )
 133                 {
 134                     // insert about entry
 135                     OUString aAbout( ResId( SV_STDTEXT_ABOUT, *pMgr ) );
 136                     NSString* pString = CreateNSString( aAbout );
 137                     NSMenuItem* pNewItem = [pAppMenu insertItemWithTitle: pString
 138                                                      action: @selector(showAbout:)
 139                                                      keyEquivalent: @""
 140                                                      atIndex: 0];
 141                     if (pString)
 142                         [pString release];
 143                     if( pNewItem )
 144                     {
 145                         [pNewItem setTarget: pMainMenuSelector];
 146                         [pAppMenu insertItem: [NSMenuItem separatorItem] atIndex: 1];
 147                     }
 148
 149                     // insert preferences entry
 150                     OUString aPref( ResId( SV_STDTEXT_PREFERENCES, *pMgr ) );
 151                     pString = CreateNSString( aPref );
 152                     pNewItem = [pAppMenu insertItemWithTitle: pString
 153                                          action: @selector(showPreferences:)
 154                                          keyEquivalent: @","
 155                                          atIndex: 2];
 156                     if (pString)
 157                         [pString release];
 158                     if( pNewItem )
 159                     {
 160 SAL_WNODEPRECATED_DECLARATIONS_PUSH
 161     // 'NSCommandKeyMask' is deprecated: first deprecated in macOS 10.12
 162                         [pNewItem setKeyEquivalentModifierMask: NSCommandKeyMask];
 163 SAL_WNODEPRECATED_DECLARATIONS_POP
 164                         [pNewItem setTarget: pMainMenuSelector];
 165                         [pAppMenu insertItem: [NSMenuItem separatorItem] atIndex: 3];
 166                     }
 167
 168                     // WARNING: ultra ugly code ahead
 169
 170                     // rename standard entries
 171                     // rename "Services"
 172                     pNewItem = [pAppMenu itemAtIndex: 4];
 173                     if( pNewItem )
 174                     {
 175                         pString = CreateNSString( OUString( ResId( SV_MENU_MAC_SERVICES, *pMgr ) ) );
 176                         [pNewItem  setTitle: pString];
 177                         if( pString )
 178                             [pString release];
 179                     }
 180
 181                     // rename "Hide NewApplication"
 182                     pNewItem = [pAppMenu itemAtIndex: 6];
 183                     if( pNewItem )
 184                     {
 185                         pString = CreateNSString( OUString( ResId( SV_MENU_MAC_HIDEAPP, *pMgr ) ) );
 186                         [pNewItem  setTitle: pString];
 187                         if( pString )
 188                             [pString release];
 189                     }
 190
 191                     // rename "Hide Others"
 192                     pNewItem = [pAppMenu itemAtIndex: 7];
 193                     if( pNewItem )
 194                     {
 195                         pString = CreateNSString( OUString( ResId( SV_MENU_MAC_HIDEALL, *pMgr ) ) );
 196                         [pNewItem  setTitle: pString];
 197                         if( pString )
 198                             [pString release];
 199                     }
 200
 201                     // rename "Show all"
 202                     pNewItem = [pAppMenu itemAtIndex: 8];
 203                     if( pNewItem )
 204                     {
 205                         pString = CreateNSString( OUString( ResId( SV_MENU_MAC_SHOWALL, *pMgr ) ) );
 206                         [pNewItem  setTitle: pString];
 207                         if( pString )
 208                             [pString release];
 209                     }
 210
 211                     // rename "Quit NewApplication"
 212                     pNewItem = [pAppMenu itemAtIndex: 10];
 213                     if( pNewItem )
 214                     {
 215                         pString = CreateNSString( OUString( ResId( SV_MENU_MAC_QUITAPP, *pMgr ) ) );
 216                         [pNewItem  setTitle: pString];
 217                         if( pString )
 218                             [pString release];
 219                     }
 220                 }
 221             }
 222         }
 223     }
 224 }
 225
 226 SalMenu* AquaSalInstance::CreateMenu( bool bMenuBar, Menu* pVCLMenu )
 227 {
 228     initAppMenu();
 229
 230     AquaSalMenu *pAquaSalMenu = new AquaSalMenu( bMenuBar );
 231     pAquaSalMenu->mpVCLMenu = pVCLMenu;
 232
 233     return pAquaSalMenu;
 234 }
 235
 236 void AquaSalInstance::DestroyMenu( SalMenu* pSalMenu )
 237 {
 238     delete pSalMenu;
 239 }
 240
 241 SalMenuItem* AquaSalInstance::CreateMenuItem( const SalItemParams* pItemData )
 242 {
 243     if( !pItemData )
 244         return nullptr;
 245
 246     AquaSalMenuItem *pSalMenuItem = new AquaSalMenuItem( pItemData );
 247
 248     return pSalMenuItem;
 249 }
 250
 251 void AquaSalInstance::DestroyMenuItem( SalMenuItem* pSalMenuItem )
 252 {
 253     delete pSalMenuItem;
 254 }
 255
 256 /*
 257  * AquaSalMenu
 258  */
 259
 260 AquaSalMenu::AquaSalMenu( bool bMenuBar ) :
 261     mbMenuBar( bMenuBar ),
 262     mpMenu( nil ),
 263     mpFrame( nullptr ),
 264     mpParentSalMenu( nullptr )
 265 {
 266     if( ! mbMenuBar )
 267     {
 268         mpMenu = [[SalNSMenu alloc] initWithMenu: this];
 269         [mpMenu setDelegate: reinterpret_cast< id<NSMenuDelegate> >(mpMenu)];
 270     }
 271     else
 272     {
 273         mpMenu = [NSApp mainMenu];
 274     }
 275     [mpMenu setAutoenablesItems: NO];
 276 }
 277
 278 AquaSalMenu::~AquaSalMenu()
 279 {
 280     // actually someone should have done AquaSalFrame::SetMenu( NULL )
 281     // on our frame, alas it is not so
 282     if( mpFrame && AquaSalFrame::isAlive( mpFrame ) && mpFrame->mpMenu == this )
 283         const_cast<AquaSalFrame*>(mpFrame)->mpMenu = nullptr;
 284
 285     // this should normally be empty already, but be careful...
 286     for( size_t i = 0; i < maButtons.size(); i++ )
 287         releaseButtonEntry( maButtons[i] );
 288     maButtons.clear();
 289
 290     // is this leaking in some cases ? the release often leads to a duplicate release
 291     // it seems the parent item gets ownership of the menu
 292     if( mpMenu )
 293     {
 294         if( mbMenuBar )
 295         {
 296             if( pCurrentMenuBar == this )
 297             {
 298                 // if the current menubar gets destroyed, set the default menubar
 299                 setDefaultMenu();
 300             }
 301         }
 302         else
 303             // the system may still hold a reference on mpMenu
 304         {
 305             // so set the pointer to this AquaSalMenu to NULL
 306             // to protect from calling a dead object
 307
 308             // in ! mbMenuBar case our mpMenu is actually a SalNSMenu*
 309             // so we can safely cast here
 310             [static_cast<SalNSMenu*>(mpMenu) setSalMenu: nullptr];
 311             /* #i89860# FIXME:
 312                using [autorelease] here (and in AquaSalMenuItem::~AquaSalMenuItem)
 313                instead of [release] fixes an occasional crash. That should
 314                indicate that we release menus / menu items in the wrong order
 315                somewhere, but I could not find that case.
 316             */
 317             [mpMenu autorelease];
 318         }
 319     }
 320 }
 321
 322 bool AquaSalMenu::ShowNativePopupMenu(FloatingWindow * pWin, const tools::Rectangle& rRect, FloatWinPopupFlags nFlags)
 323 {
 324     // do not use native popup menu when AQUA_NATIVE_MENUS is set to false
 325     if( ! VisibleMenuBar() ) {
 326         return false;
 327     }
 328
 329     // set offsets for positioning
 330     const float offset = 9.0;
 331
 332     // get the pointers
 333     AquaSalFrame * pParentAquaSalFrame = static_cast<AquaSalFrame *>(pWin->ImplGetWindowImpl()->mpRealParent->ImplGetFrame());
 334     NSWindow* pParentNSWindow = pParentAquaSalFrame->mpNSWindow;
 335     NSView* pParentNSView = [pParentNSWindow contentView];
 336     NSView* pPopupNSView = static_cast<AquaSalFrame *>(pWin->ImplGetWindow()->ImplGetFrame())->mpNSView;
 337     NSRect popupFrame = [pPopupNSView frame];
 338
 339     // create frame rect
 340     NSRect displayPopupFrame = NSMakeRect( rRect.Left()+(offset-1), rRect.Top()+(offset+1), popupFrame.size.width, 0 );
 341     pParentAquaSalFrame->VCLToCocoa(displayPopupFrame, false);
 342
 343     // do the same strange semantics as vcl popup windows to arrive at a frame geometry
 344     // in mirrored UI case; best done by actually executing the same code
 345     sal_uInt16 nArrangeIndex;
 346     pWin->SetPosPixel( FloatingWindow::ImplCalcPos( pWin, rRect, nFlags, nArrangeIndex ) );
 347     displayPopupFrame.origin.x = pWin->ImplGetFrame()->maGeometry.nX - pParentAquaSalFrame->maGeometry.nX + offset;
 348     displayPopupFrame.origin.y = pWin->ImplGetFrame()->maGeometry.nY - pParentAquaSalFrame->maGeometry.nY + offset;
 349     pParentAquaSalFrame->VCLToCocoa(displayPopupFrame, false);
 350
 351     // #i111992# if this menu was opened due to a key event, prevent dispatching that yet again
 352     if( [pParentNSView respondsToSelector: @selector(clearLastEvent)] )
 353         [pParentNSView performSelector:@selector(clearLastEvent)];
 354
 355     // open popup menu
 356     NSPopUpButtonCell * pPopUpButtonCell = [[NSPopUpButtonCell alloc] initTextCell:@"" pullsDown:NO];
 357     [pPopUpButtonCell setMenu: mpMenu];
 358     [pPopUpButtonCell selectItem:nil];
 359     [AquaA11yWrapper setPopupMenuOpen: YES];
 360     [pPopUpButtonCell performClickWithFrame:displayPopupFrame inView:pParentNSView];
 361     [pPopUpButtonCell release];
 362     [AquaA11yWrapper setPopupMenuOpen: NO];
 363
 364     return true;
 365 }
 366
 367 int AquaSalMenu::getItemIndexByPos( sal_uInt16 nPos ) const
 368 {
 369     int nIndex = 0;
 370     if( nPos == MENU_APPEND )
 371         nIndex = [mpMenu numberOfItems];
 372     else
 373         nIndex = sal::static_int_cast<int>( mbMenuBar ? nPos+1 : nPos );
 374     return nIndex;
 375 }
 376
 377 const AquaSalFrame* AquaSalMenu::getFrame() const
 378 {
 379     const AquaSalMenu* pMenu = this;
 380     while( pMenu && ! pMenu->mpFrame )
 381         pMenu = pMenu->mpParentSalMenu;
 382     return pMenu ? pMenu->mpFrame : nullptr;
 383 }
 384
 385 void AquaSalMenu::unsetMainMenu()
 386 {
 387     pCurrentMenuBar = nullptr;
 388
 389     // remove items from main menu
 390     NSMenu* pMenu = [NSApp mainMenu];
 391     for( int nItems = [pMenu numberOfItems]; nItems > 1; nItems-- )
 392         [pMenu removeItemAtIndex: 1];
 393 }
 394
 395 void AquaSalMenu::setMainMenu()
 396 {
 397     SAL_WARN_IF( !mbMenuBar, "vcl", "setMainMenu on non menubar" );
 398     if( mbMenuBar )
 399     {
 400         if( pCurrentMenuBar != this )
 401         {
 402             unsetMainMenu();
 403             // insert our items
 404             for( std::vector<AquaSalMenuItem *>::size_type i = 0; i < maItems.size(); i++ )
 405             {
 406                 NSMenuItem* pItem = maItems[i]->mpMenuItem;
 407                 [mpMenu insertItem: pItem atIndex: i+1];
 408             }
 409             pCurrentMenuBar = this;
 410
 411             // change status item
 412             statusLayout();
 413         }
 414         enableMainMenu( true );
 415     }
 416 }
 417
 418 void AquaSalMenu::setDefaultMenu()
 419 {
 420     NSMenu* pMenu = [NSApp mainMenu];
 421
 422     unsetMainMenu();
 423
 424     // insert default items
 425     std::vector< NSMenuItem* >& rFallbackMenu( GetSalData()->maFallbackMenu );
 426     for( unsigned int i = 0, nAddItems = rFallbackMenu.size(); i < nAddItems; i++ )
 427     {
 428         NSMenuItem* pItem = rFallbackMenu[i];
 429         if( [pItem menu] == nil )
 430             [pMenu insertItem: pItem atIndex: i+1];
 431     }
 432 }
 433
 434 void AquaSalMenu::enableMainMenu( bool bEnable )
 435 {
 436     NSMenu* pMainMenu = [NSApp mainMenu];
 437     if( pMainMenu )
 438     {
 439         // enable/disable items from main menu
 440         int nItems = [pMainMenu numberOfItems];
 441         for( int n = 1; n < nItems; n++ )
 442         {
 443             NSMenuItem* pItem = [pMainMenu itemAtIndex: n];
 444             [pItem setEnabled: bEnable ? YES : NO];
 445         }
 446     }
 447 }
 448
 449 void AquaSalMenu::addFallbackMenuItem( NSMenuItem* pNewItem )
 450 {
 451     initAppMenu();
 452
 453     std::vector< NSMenuItem* >& rFallbackMenu( GetSalData()->maFallbackMenu );
 454
 455     // prevent duplicate insertion
 456     int nItems = rFallbackMenu.size();
 457     for( int i = 0; i < nItems; i++ )
 458     {
 459         if( rFallbackMenu[i] == pNewItem )
 460             return;
 461     }
 462
 463     // push the item to the back and retain it
 464     [pNewItem retain];
 465     rFallbackMenu.push_back( pNewItem );
 466
 467     if( pCurrentMenuBar == nullptr )
 468         setDefaultMenu();
 469 }
 470
 471 void AquaSalMenu::removeFallbackMenuItem( NSMenuItem* pOldItem )
 472 {
 473     std::vector< NSMenuItem* >& rFallbackMenu( GetSalData()->maFallbackMenu );
 474
 475     // find item
 476     unsigned int nItems = rFallbackMenu.size();
 477     for( unsigned int i = 0; i < nItems; i++ )
 478     {
 479         if( rFallbackMenu[i] == pOldItem )
 480         {
 481             // remove item and release
 482             rFallbackMenu.erase( rFallbackMenu.begin() + i );
 483             [pOldItem release];
 484
 485             if( pCurrentMenuBar == nullptr )
 486                 setDefaultMenu();
 487
 488             return;
 489         }
 490     }
 491 }
 492
 493 bool AquaSalMenu::VisibleMenuBar()
 494 {
 495     // Enable/disable experimental native menus code?
 496
 497     // To disable native menus, set the environment variable AQUA_NATIVE_MENUS to FALSE
 498
 499     static const char *pExperimental = getenv ("AQUA_NATIVE_MENUS");
 500
 501     if ( pExperimental && !strcasecmp(pExperimental, "FALSE") )
 502         return false;
 503
 504     // End of experimental code enable/disable part
 505
 506     return true;
 507 }
 508
 509 void AquaSalMenu::SetFrame( const SalFrame *pFrame )
 510 {
 511     mpFrame = static_cast<const AquaSalFrame*>(pFrame);
 512 }
 513
 514 void AquaSalMenu::InsertItem( SalMenuItem* pSalMenuItem, unsigned nPos )
 515 {
 516     AquaSalMenuItem *pAquaSalMenuItem = static_cast<AquaSalMenuItem*>(pSalMenuItem);
 517
 518     pAquaSalMenuItem->mpParentMenu = this;
 519     DBG_ASSERT( pAquaSalMenuItem->mpVCLMenu == nullptr        ||
 520                 pAquaSalMenuItem->mpVCLMenu == mpVCLMenu   ||
 521                 mpVCLMenu == nullptr,
 522                 "resetting menu ?" );
 523     if( pAquaSalMenuItem->mpVCLMenu )
 524         mpVCLMenu = pAquaSalMenuItem->mpVCLMenu;
 525
 526     if( nPos == MENU_APPEND || nPos == maItems.size() )
 527         maItems.push_back( pAquaSalMenuItem );
 528     else if( nPos < maItems.size() )
 529         maItems.insert( maItems.begin() + nPos, pAquaSalMenuItem );
 530     else
 531     {
 532         OSL_FAIL( "invalid item index in insert" );
 533         return;
 534     }
 535
 536     if( ! mbMenuBar || pCurrentMenuBar == this )
 537         [mpMenu insertItem: pAquaSalMenuItem->mpMenuItem atIndex: getItemIndexByPos(nPos)];
 538 }
 539
 540 void AquaSalMenu::RemoveItem( unsigned nPos )
 541 {
 542     AquaSalMenuItem* pRemoveItem = nullptr;
 543     if( nPos == MENU_APPEND || nPos == (maItems.size()-1) )
 544     {
 545         pRemoveItem = maItems.back();
 546         maItems.pop_back();
 547     }
 548     else if( nPos < maItems.size() )
 549     {
 550         pRemoveItem = maItems[ nPos ];
 551         maItems.erase( maItems.begin()+nPos );
 552     }
 553     else
 554     {
 555         OSL_FAIL( "invalid item index in remove" );
 556         return;
 557     }
 558
 559     pRemoveItem->mpParentMenu = nullptr;
 560
 561     if( ! mbMenuBar || pCurrentMenuBar == this )
 562         [mpMenu removeItemAtIndex: getItemIndexByPos(nPos)];
 563 }
 564
 565 void AquaSalMenu::SetSubMenu( SalMenuItem* pSalMenuItem, SalMenu* pSubMenu, unsigned /*nPos*/ )
 566 {
 567     AquaSalMenuItem *pAquaSalMenuItem = static_cast<AquaSalMenuItem*>(pSalMenuItem);
 568     AquaSalMenu *subAquaSalMenu = static_cast<AquaSalMenu*>(pSubMenu);
 569
 570     if (subAquaSalMenu)
 571     {
 572         pAquaSalMenuItem->mpSubMenu = subAquaSalMenu;
 573         if( subAquaSalMenu->mpParentSalMenu == nullptr )
 574         {
 575             subAquaSalMenu->mpParentSalMenu = this;
 576             [pAquaSalMenuItem->mpMenuItem setSubmenu: subAquaSalMenu->mpMenu];
 577
 578             // set title of submenu
 579             [subAquaSalMenu->mpMenu setTitle: [pAquaSalMenuItem->mpMenuItem title]];
 580         }
 581         else if( subAquaSalMenu->mpParentSalMenu != this )
 582         {
 583             // cocoa doesn't allow menus to be submenus of multiple
 584             // menu items, so place a copy in the menu item instead ?
 585             // let's hope that NSMenu copy does the right thing
 586             NSMenu* pCopy = [subAquaSalMenu->mpMenu copy];
 587             [pAquaSalMenuItem->mpMenuItem setSubmenu: pCopy];
 588
 589             // set title of submenu
 590             [pCopy setTitle: [pAquaSalMenuItem->mpMenuItem title]];
 591         }
 592     }
 593     else
 594     {
 595         if( pAquaSalMenuItem->mpSubMenu )
 596         {
 597             if( pAquaSalMenuItem->mpSubMenu->mpParentSalMenu == this )
 598                 pAquaSalMenuItem->mpSubMenu->mpParentSalMenu = nullptr;
 599         }
 600         pAquaSalMenuItem->mpSubMenu = nullptr;
 601         [pAquaSalMenuItem->mpMenuItem setSubmenu: nil];
 602     }
 603 }
 604
 605 void AquaSalMenu::CheckItem( unsigned nPos, bool bCheck )
 606 {
 607     if( nPos < maItems.size() )
 608     {
 609         NSMenuItem* pItem = maItems[nPos]->mpMenuItem;
 610         [pItem setState: bCheck ? NSOnState : NSOffState];
 611     }
 612 }
 613
 614 void AquaSalMenu::EnableItem( unsigned nPos, bool bEnable )
 615 {
 616     if( nPos < maItems.size() )
 617     {
 618         NSMenuItem* pItem = maItems[nPos]->mpMenuItem;
 619         [pItem setEnabled: bEnable ? YES : NO];
 620     }
 621 }
 622
 623 void AquaSalMenu::SetItemImage( unsigned /*nPos*/, SalMenuItem* pSMI, const Image& rImage )
 624 {
 625     AquaSalMenuItem* pSalMenuItem = static_cast<AquaSalMenuItem*>( pSMI );
 626     if( ! pSalMenuItem || ! pSalMenuItem->mpMenuItem )
 627         return;
 628
 629     NSImage* pImage = CreateNSImage( rImage );
 630
 631     [pSalMenuItem->mpMenuItem setImage: pImage];
 632     if( pImage )
 633         [pImage release];
 634 }
 635
 636 void AquaSalMenu::SetItemText( unsigned /*i_nPos*/, SalMenuItem* i_pSalMenuItem, const OUString& i_rText )
 637 {
 638     if (!i_pSalMenuItem)
 639         return;
 640
 641     AquaSalMenuItem *pAquaSalMenuItem = static_cast<AquaSalMenuItem *>(i_pSalMenuItem);
 642
 643     // Delete mnemonics
 644     OUString aText = i_rText.replaceAll("~", "");
 645
 646     /* #i90015# until there is a correct solution
 647        strip out any appended (.*) in menubar entries
 648     */
 649     if( mbMenuBar )
 650     {
 651         sal_Int32 nPos = aText.lastIndexOf( '(' );
 652         if( nPos != -1 )
 653         {
 654             sal_Int32 nPos2 = aText.indexOf( ')' );
 655             if( nPos2 != -1 )
 656                 aText = aText.replaceAt( nPos, nPos2-nPos+1, "" );
 657         }
 658     }
 659
 660     NSString* pString = CreateNSString( aText );
 661     if (pString)
 662     {
 663         [pAquaSalMenuItem->mpMenuItem setTitle: pString];
 664         // if the menu item has a submenu, change its title as well
 665         if (pAquaSalMenuItem->mpSubMenu)
 666             [pAquaSalMenuItem->mpSubMenu->mpMenu setTitle: pString];
 667         [pString release];
 668     }
 669 }
 670
 671 void AquaSalMenu::SetAccelerator( unsigned /*nPos*/, SalMenuItem* pSalMenuItem, const vcl::KeyCode& rKeyCode, const OUString& /*rKeyName*/ )
 672 {
 673     sal_uInt16 nModifier;
 674     sal_Unicode nCommandKey = 0;
 675
 676     sal_uInt16 nKeyCode=rKeyCode.GetCode();
 677     if( nKeyCode )
 678     {
 679         if ((nKeyCode>=KEY_A) && (nKeyCode<=KEY_Z))           // letter A..Z
 680             nCommandKey = nKeyCode-KEY_A + 'a';
 681         else if ((nKeyCode>=KEY_0) && (nKeyCode<=KEY_9))      // numbers 0..9
 682             nCommandKey = nKeyCode-KEY_0 + '0';
 683         else if ((nKeyCode>=KEY_F1) && (nKeyCode<=KEY_F26))   // function keys F1..F26
 684             nCommandKey = nKeyCode-KEY_F1 + NSF1FunctionKey;
 685         else if( nKeyCode == KEY_REPEAT )
 686             nCommandKey = NSRedoFunctionKey;
 687         else if( nKeyCode == KEY_SPACE )
 688             nCommandKey = ' ';
 689         else
 690         {
 691             switch (nKeyCode)
 692             {
 693             case KEY_ADD:
 694                 nCommandKey='+';
 695                 break;
 696             case KEY_SUBTRACT:
 697                 nCommandKey='-';
 698                 break;
 699             case KEY_MULTIPLY:
 700                 nCommandKey='*';
 701                 break;
 702             case KEY_DIVIDE:
 703                 nCommandKey='/';
 704                 break;
 705             case KEY_POINT:
 706                 nCommandKey='.';
 707                 break;
 708             case KEY_LESS:
 709                 nCommandKey='<';
 710                 break;
 711             case KEY_GREATER:
 712                 nCommandKey='>';
 713                 break;
 714             case KEY_EQUAL:
 715                 nCommandKey='=';
 716                 break;
 717             case KEY_SEMICOLON:
 718                 nCommandKey=';';
 719                 break;
 720             case KEY_BACKSPACE:
 721                 nCommandKey=u'\x232b';
 722                 break;
 723             case KEY_PAGEUP:
 724                 nCommandKey=u'\x21de';
 725                 break;
 726             case KEY_PAGEDOWN:
 727                 nCommandKey=u'\x21df';
 728                 break;
 729             case KEY_UP:
 730                 nCommandKey=u'\x21e1';
 731                 break;
 732             case KEY_DOWN:
 733                 nCommandKey=u'\x21e3';
 734                 break;
 735             case KEY_RETURN:
 736                 nCommandKey=u'\x21a9';
 737                 break;
 738             case KEY_BRACKETLEFT:
 739                 nCommandKey='[';
 740                 break;
 741             case KEY_BRACKETRIGHT:
 742                 nCommandKey=']';
 743                 break;
 744             }
 745         }
 746     }
 747     else // not even a code ? nonsense -> ignore
 748         return;
 749
 750     SAL_WARN_IF( !nCommandKey, "vcl", "unmapped accelerator key" );
 751
 752     nModifier=rKeyCode.GetModifier();
 753
 754     // should always use the command key
 755     int nItemModifier = 0;
 756
 757 SAL_WNODEPRECATED_DECLARATIONS_PUSH
 758         // 'NSAlternateKeyMask' is deprecated: first deprecated in macOS 10.12
 759         // 'NSCommandKeyMask' is deprecated: first deprecated in macOS 10.12
 760         // 'NSControlKeyMask' is deprecated: first deprecated in macOS 10.12
 761         // 'NSShiftKeyMask' is deprecated: first deprecated in macOS 10.12
 762     if (nModifier & KEY_SHIFT)
 763     {
 764         nItemModifier |= NSShiftKeyMask;   // actually useful only for function keys
 765         if( nKeyCode >= KEY_A && nKeyCode <= KEY_Z )
 766             nCommandKey = nKeyCode - KEY_A + 'A';
 767     }
 768
 769     if (nModifier & KEY_MOD1)
 770         nItemModifier |= NSCommandKeyMask;
 771
 772     if(nModifier & KEY_MOD2)
 773         nItemModifier |= NSAlternateKeyMask;
 774
 775     if(nModifier & KEY_MOD3)
 776         nItemModifier |= NSControlKeyMask;
 777 SAL_WNODEPRECATED_DECLARATIONS_POP
 778
 779     AquaSalMenuItem *pAquaSalMenuItem = static_cast<AquaSalMenuItem *>(pSalMenuItem);
 780     NSString* pString = CreateNSString( OUString( &nCommandKey, 1 ) );
 781     [pAquaSalMenuItem->mpMenuItem setKeyEquivalent: pString];
 782     [pAquaSalMenuItem->mpMenuItem setKeyEquivalentModifierMask: nItemModifier];
 783     if (pString)
 784         [pString release];
 785 }
 786
 787 void AquaSalMenu::GetSystemMenuData( SystemMenuData* )
 788 {
 789 }
 790
 791 AquaSalMenu::MenuBarButtonEntry* AquaSalMenu::findButtonItem( sal_uInt16 i_nItemId )
 792 {
 793     for( size_t i = 0; i < maButtons.size(); ++i )
 794     {
 795         if( maButtons[i].maButton.mnId == i_nItemId )
 796             return &maButtons[i];
 797     }
 798     return nullptr;
 799 }
 800
 801 void AquaSalMenu::statusLayout()
 802 {
 803     if( GetSalData()->mpStatusItem )
 804     {
 805         NSView* pNSView = [GetSalData()->mpStatusItem view];
 806         if( [pNSView isMemberOfClass: [OOStatusItemView class]] ) // well of course it is
 807             [(OOStatusItemView*)pNSView layout];
 808         else
 809             OSL_FAIL( "someone stole our status view" );
 810     }
 811 }
 812
 813 bool AquaSalMenu::AddMenuBarButton( const SalMenuButtonItem& i_rNewItem )
 814 {
 815     if( ! mbMenuBar || ! VisibleMenuBar() )
 816         return false;
 817
 818     MenuBarButtonEntry* pEntry = findButtonItem( i_rNewItem.mnId );
 819     if( pEntry )
 820     {
 821         releaseButtonEntry( *pEntry );
 822         pEntry->maButton = i_rNewItem;
 823         pEntry->mpNSImage = CreateNSImage( i_rNewItem.maImage );
 824         if( i_rNewItem.maToolTipText.getLength() )
 825             pEntry->mpToolTipString = CreateNSString( i_rNewItem.maToolTipText );
 826     }
 827     else
 828     {
 829         maButtons.push_back( MenuBarButtonEntry( i_rNewItem ) );
 830         maButtons.back().mpNSImage = CreateNSImage( i_rNewItem.maImage );
 831         maButtons.back().mpToolTipString = CreateNSString( i_rNewItem.maToolTipText );
 832     }
 833
 834     // lazy create status item
 835     SalData::getStatusItem();
 836
 837     if( pCurrentMenuBar == this )
 838         statusLayout();
 839
 840     return true;
 841 }
 842
 843 void AquaSalMenu::RemoveMenuBarButton( sal_uInt16 i_nId )
 844 {
 845     MenuBarButtonEntry* pEntry = findButtonItem( i_nId );
 846     if( pEntry )
 847     {
 848         releaseButtonEntry( *pEntry );
 849         // note: vector guarantees that its contents are in a plain array
 850         maButtons.erase( maButtons.begin() + (pEntry - &maButtons[0]) );
 851     }
 852
 853     if( pCurrentMenuBar == this )
 854         statusLayout();
 855 }
 856
 857 tools::Rectangle AquaSalMenu::GetMenuBarButtonRectPixel( sal_uInt16 i_nItemId, SalFrame* i_pReferenceFrame )
 858 {
 859     if( ! i_pReferenceFrame || ! AquaSalFrame::isAlive( static_cast<AquaSalFrame*>(i_pReferenceFrame) ) )
 860         return tools::Rectangle();
 861
 862     MenuBarButtonEntry* pEntry = findButtonItem( i_nItemId );
 863
 864     if( ! pEntry )
 865         return tools::Rectangle();
 866
 867     NSStatusItem* pItem = SalData::getStatusItem();
 868     if( ! pItem )
 869         return tools::Rectangle();
 870
 871     NSView* pNSView = [pItem view];
 872     if( ! pNSView )
 873         return tools::Rectangle();
 874     NSWindow* pNSWin = [pNSView window];
 875     if( ! pNSWin )
 876         return tools::Rectangle();
 877
 878     NSRect aRect = [pNSWin convertRectToScreen:[pNSWin frame]];
 879
 880     // make coordinates relative to reference frame
 881     static_cast<AquaSalFrame*>(i_pReferenceFrame)->CocoaToVCL( aRect.origin );
 882     aRect.origin.x -= i_pReferenceFrame->maGeometry.nX;
 883     aRect.origin.y -= i_pReferenceFrame->maGeometry.nY + aRect.size.height;
 884
 885     return tools::Rectangle( Point(static_cast<long int>(aRect.origin.x),
 886                 static_cast<long int>(aRect.origin.y)
 887                 ),
 888               Size( static_cast<long int>(aRect.size.width),
 889                 static_cast<long int>(aRect.size.height)
 890               )
 891             );
 892 }
 893
 894 /*
 895  * SalMenuItem
 896  */
 897
 898 AquaSalMenuItem::AquaSalMenuItem( const SalItemParams* pItemData ) :
 899     mnId( pItemData->nId ),
 900     mpVCLMenu( pItemData->pMenu ),
 901     mpParentMenu( nullptr ),
 902     mpSubMenu( nullptr ),
 903     mpMenuItem( nil )
 904 {
 905     if (pItemData->eType == MenuItemType::SEPARATOR)
 906     {
 907         mpMenuItem = [NSMenuItem separatorItem];
 908         // these can go occasionally go in and out of a menu, ensure their lifecycle
 909         // also for the release in AquaSalMenuItem destructor
 910         [mpMenuItem retain];
 911     }
 912     else
 913     {
 914         mpMenuItem = [[SalNSMenuItem alloc] initWithMenuItem: this];
 915         [mpMenuItem setEnabled: YES];
 916
 917         // peel mnemonics because on mac there are no such things for menu items
 918         NSString* pString = CreateNSString( pItemData->aText.replaceAll( "~", "" ) );
 919         if (pString)
 920         {
 921             [mpMenuItem setTitle: pString];
 922             [pString release];
 923         }
 924         // anything but a separator should set a menu to dispatch to
 925         SAL_WARN_IF( !mpVCLMenu, "vcl", "no menu" );
 926     }
 927 }
 928
 929 AquaSalMenuItem::~AquaSalMenuItem()
 930 {
 931     /* #i89860# FIXME:
 932        using [autorelease] here (and in AquaSalMenu:::~AquaSalMenu) instead of
 933        [release] fixes an occasional crash. That should indicate that we release
 934        menus / menu items in the wrong order somewhere, but I
 935        could not find that case.
 936     */
 937     if( mpMenuItem )
 938         [mpMenuItem autorelease];
 939 }
 940
 941 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */