toolkit/source/awt/vclxmenu.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 <toolkit/awt/vclxmenu.hxx>
  21 #include <toolkit/helper/convert.hxx>
  22 #include <toolkit/helper/vclunohelper.hxx>
  23
  24 #include <com/sun/star/uno/XComponentContext.hpp>
  25 #include <cppuhelper/supportsservice.hxx>
  26 #include <cppuhelper/queryinterface.hxx>
  27 #include <cppuhelper/typeprovider.hxx>
  28 #include <tools/debug.hxx>
  29 #include <vcl/dialoghelper.hxx>
  30 #include <vcl/graph.hxx>
  31 #include <vcl/menu.hxx>
  32 #include <vcl/keycod.hxx>
  33 #include <vcl/image.hxx>
  34 #include <vcl/svapp.hxx>
  35 #include <vcl/window.hxx>
  36
  37 #include <com/sun/star/awt/KeyModifier.hpp>
  38
  39 VCLXMenu::VCLXMenu()
  40     : maMenuListeners( *this )
  41     , mnDefaultItem(0)
  42 {
  43     mpMenu = nullptr;
  44 }
  45
  46 VCLXMenu::VCLXMenu( Menu* pMenu )
  47     : maMenuListeners( *this )
  48     , mnDefaultItem(0)
  49 {
  50     mpMenu = pMenu;
  51 }
  52
  53 VCLXMenu::~VCLXMenu()
  54 {
  55     maPopupMenuRefs.clear();
  56     if ( mpMenu )
  57     {
  58         SolarMutexGuard g;
  59         mpMenu->RemoveEventListener( LINK( this, VCLXMenu, MenuEventListener ) );
  60         mpMenu.disposeAndClear();
  61     }
  62 }
  63
  64 bool VCLXMenu::IsPopupMenu() const
  65 {
  66     return (mpMenu && ! mpMenu->IsMenuBar());
  67 }
  68
  69 void VCLXMenu::ImplCreateMenu( bool bPopup )
  70 {
  71     DBG_ASSERT( !mpMenu, "CreateMenu: Menu exists!" );
  72
  73     if ( bPopup )
  74         mpMenu = VclPtr<PopupMenu>::Create();
  75     else
  76         mpMenu = VclPtr<MenuBar>::Create();
  77
  78     mpMenu->AddEventListener( LINK( this, VCLXMenu, MenuEventListener ) );
  79 }
  80
  81 void VCLXMenu::ImplAddListener()
  82 {
  83     assert(mpMenu);
  84     mpMenu->AddEventListener( LINK( this, VCLXMenu, MenuEventListener ) );
  85 }
  86
  87 IMPL_LINK( VCLXMenu, MenuEventListener, VclMenuEvent&, rMenuEvent, void )
  88 {
  89     DBG_ASSERT( rMenuEvent.GetMenu() && mpMenu, "Menu???" );
  90
  91     if ( rMenuEvent.GetMenu() != mpMenu )  // Also called for the root menu
  92         return;
  93
  94     switch ( rMenuEvent.GetId() )
  95     {
  96         case VclEventId::MenuSelect:
  97         {
  98             if ( maMenuListeners.getLength() )
  99             {
 100                 css::awt::MenuEvent aEvent;
 101                 aEvent.Source = getXWeak();
 102                 aEvent.MenuId = mpMenu->GetCurItemId();
 103                 maMenuListeners.itemSelected( aEvent );
 104             }
 105         }
 106         break;
 107         case VclEventId::ObjectDying:
 108         {
 109             mpMenu = nullptr;
 110         }
 111         break;
 112         case VclEventId::MenuHighlight:
 113         {
 114             if ( maMenuListeners.getLength() )
 115             {
 116                 css::awt::MenuEvent aEvent;
 117                 aEvent.Source = getXWeak();
 118                 aEvent.MenuId = mpMenu->GetCurItemId();
 119                 maMenuListeners.itemHighlighted( aEvent );
 120             }
 121         }
 122         break;
 123         case VclEventId::MenuActivate:
 124         {
 125             if ( maMenuListeners.getLength() )
 126             {
 127                 css::awt::MenuEvent aEvent;
 128                 aEvent.Source = getXWeak();
 129                 aEvent.MenuId = mpMenu->GetCurItemId();
 130                 maMenuListeners.itemActivated( aEvent );
 131             }
 132         }
 133         break;
 134         case VclEventId::MenuDeactivate:
 135         {
 136             if ( maMenuListeners.getLength() )
 137             {
 138                 css::awt::MenuEvent aEvent;
 139                 aEvent.Source = getXWeak();
 140                 aEvent.MenuId = mpMenu->GetCurItemId();
 141                 maMenuListeners.itemDeactivated( aEvent );
 142             }
 143         }
 144         break;
 145
 146         // ignore accessibility events
 147         case VclEventId::MenuEnable:
 148         case VclEventId::MenuInsertItem:
 149         case VclEventId::MenuRemoveItem:
 150         case VclEventId::MenuSubmenuActivate:
 151         case VclEventId::MenuSubmenuDeactivate:
 152         case VclEventId::MenuSubmenuChanged:
 153         case VclEventId::MenuDehighlight:
 154         case VclEventId::MenuDisable:
 155         case VclEventId::MenuItemRoleChanged:
 156         case VclEventId::MenuItemTextChanged:
 157         case VclEventId::MenuItemChecked:
 158         case VclEventId::MenuItemUnchecked:
 159         case VclEventId::MenuShow:
 160         case VclEventId::MenuHide:
 161         break;
 162
 163         default:    OSL_FAIL( "MenuEventListener - Unknown event!" );
 164    }
 165 }
 166
 167
 168 OUString SAL_CALL VCLXMenu::getImplementationName(  )
 169 {
 170     std::unique_lock aGuard( maMutex );
 171     const bool bIsPopupMenu = IsPopupMenu();
 172     aGuard.unlock();
 173
 174     OUString implName( "stardiv.Toolkit." );
 175     if ( bIsPopupMenu )
 176         implName += "VCLXPopupMenu";
 177     else
 178         implName += "VCLXMenuBar";
 179
 180     return implName;
 181 }
 182
 183 css::uno::Sequence< OUString > SAL_CALL VCLXMenu::getSupportedServiceNames(  )
 184 {
 185     std::unique_lock aGuard( maMutex );
 186     const bool bIsPopupMenu = IsPopupMenu();
 187     aGuard.unlock();
 188
 189     if ( bIsPopupMenu )
 190         return css::uno::Sequence<OUString>{
 191             "com.sun.star.awt.PopupMenu",
 192             "stardiv.vcl.PopupMenu"};
 193     else
 194         return css::uno::Sequence<OUString>{
 195             "com.sun.star.awt.MenuBar",
 196             "stardiv.vcl.MenuBar"};
 197 }
 198
 199 sal_Bool SAL_CALL VCLXMenu::supportsService(const OUString& rServiceName )
 200 {
 201     return cppu::supportsService(this, rServiceName);
 202 }
 203
 204 css::uno::Any VCLXMenu::queryInterface(
 205     const css::uno::Type & rType )
 206 {
 207     std::unique_lock aGuard( maMutex );
 208     const bool bIsPopupMenu = IsPopupMenu();
 209     aGuard.unlock();
 210
 211     css::uno::Any aRet;
 212
 213     if ( bIsPopupMenu )
 214         aRet = ::cppu::queryInterface(  rType,
 215                                         static_cast< css::awt::XMenu* >(static_cast<css::awt::XMenuBar*>(this)),
 216                                         static_cast< css::awt::XPopupMenu* >(this),
 217                                         static_cast< css::lang::XTypeProvider* >(this),
 218                                         static_cast< css::lang::XServiceInfo* >(this) );
 219     else
 220         aRet = ::cppu::queryInterface(  rType,
 221                                         static_cast< css::awt::XMenu* >(static_cast<css::awt::XMenuBar*>(this)),
 222                                         static_cast< css::awt::XMenuBar* >(this),
 223                                         static_cast< css::lang::XTypeProvider* >(this),
 224                                         static_cast< css::lang::XServiceInfo* >(this) );
 225
 226     return (aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType ));
 227 }
 228
 229
 230 css::uno::Sequence< css::uno::Type > VCLXMenu::getTypes()
 231 {
 232     std::unique_lock aGuard( maMutex );
 233     const bool bIsPopupMenu = IsPopupMenu();
 234     aGuard.unlock();
 235
 236     if ( bIsPopupMenu )
 237     {
 238         static cppu::OTypeCollection collectionPopupMenu(
 239             cppu::UnoType<css::lang::XTypeProvider>::get(), cppu::UnoType<css::awt::XMenu>::get(),
 240             cppu::UnoType<css::awt::XPopupMenu>::get(),
 241             cppu::UnoType<css::lang::XServiceInfo>::get());
 242         return collectionPopupMenu.getTypes();
 243     }
 244     else
 245     {
 246         static cppu::OTypeCollection collectionMenuBar(
 247             cppu::UnoType<css::lang::XTypeProvider>::get(), cppu::UnoType<css::awt::XMenu>::get(),
 248             cppu::UnoType<css::awt::XMenuBar>::get(),
 249             cppu::UnoType<css::lang::XServiceInfo>::get());
 250         return collectionMenuBar.getTypes();
 251     }
 252 }
 253
 254
 255 css::uno::Sequence< sal_Int8 > VCLXMenu::getImplementationId()
 256 {
 257     return css::uno::Sequence<sal_Int8>();
 258 }
 259
 260 void VCLXMenu::addMenuListener(
 261     const css::uno::Reference< css::awt::XMenuListener >& rxListener )
 262 {
 263     std::unique_lock aGuard( maMutex );
 264
 265     maMenuListeners.addInterface( rxListener );
 266 }
 267
 268 void VCLXMenu::removeMenuListener(
 269     const css::uno::Reference< css::awt::XMenuListener >& rxListener )
 270 {
 271     std::unique_lock aGuard( maMutex );
 272
 273     maMenuListeners.removeInterface( rxListener );
 274 }
 275
 276 void VCLXMenu::insertItem(
 277     sal_Int16 nItemId,
 278     const OUString& aText,
 279     sal_Int16 nItemStyle,
 280     sal_Int16 nPos )
 281 {
 282     SolarMutexGuard aSolarGuard;
 283     std::unique_lock aGuard( maMutex );
 284
 285     if ( mpMenu )
 286         mpMenu->InsertItem(nItemId, aText, static_cast<MenuItemBits>(nItemStyle), {}, nPos);
 287 }
 288
 289 void VCLXMenu::removeItem(
 290     sal_Int16 nPos,
 291     sal_Int16 nCount )
 292 {
 293     SolarMutexGuard aSolarGuard;
 294     std::unique_lock aGuard( maMutex );
 295
 296     if (!mpMenu)
 297         return;
 298
 299     sal_Int32 nItemCount = static_cast<sal_Int32>(mpMenu->GetItemCount());
 300     if ((nCount > 0) && (nPos >= 0) && (nPos < nItemCount))
 301     {
 302         sal_Int16 nP = sal::static_int_cast< sal_Int16 >(
 303             std::min( static_cast<int>(nPos+nCount), static_cast<int>(nItemCount) ));
 304         while( nP-nPos > 0 )
 305             mpMenu->RemoveItem( --nP );
 306     }
 307 }
 308
 309 sal_Int16 VCLXMenu::getItemCount(  )
 310 {
 311     SolarMutexGuard aSolarGuard;
 312     std::unique_lock aGuard( maMutex );
 313
 314     return mpMenu ? mpMenu->GetItemCount() : 0;
 315 }
 316
 317 sal_Int16 VCLXMenu::getItemId(
 318     sal_Int16 nPos )
 319 {
 320     SolarMutexGuard aSolarGuard;
 321     std::unique_lock aGuard( maMutex );
 322
 323     return mpMenu ? mpMenu->GetItemId( nPos ) : 0;
 324 }
 325
 326 sal_Int16 VCLXMenu::getItemPos(
 327     sal_Int16 nId )
 328 {
 329     SolarMutexGuard aSolarGuard;
 330     std::unique_lock aGuard( maMutex );
 331
 332     return mpMenu ? mpMenu->GetItemPos( nId ) : 0;
 333 }
 334
 335 void VCLXMenu::enableItem(
 336     sal_Int16 nItemId,
 337     sal_Bool bEnable )
 338 {
 339     SolarMutexGuard aSolarGuard;
 340     std::unique_lock aGuard( maMutex );
 341
 342     if ( mpMenu )
 343         mpMenu->EnableItem( nItemId, bEnable );
 344 }
 345
 346 sal_Bool VCLXMenu::isItemEnabled(
 347     sal_Int16 nItemId )
 348 {
 349     SolarMutexGuard aSolarGuard;
 350     std::unique_lock aGuard( maMutex );
 351
 352     return mpMenu && mpMenu->IsItemEnabled( nItemId );
 353 }
 354
 355 void VCLXMenu::setItemText(
 356     sal_Int16 nItemId,
 357     const OUString& aText )
 358 {
 359     SolarMutexGuard aSolarGuard;
 360     std::unique_lock aGuard( maMutex );
 361
 362     if ( mpMenu )
 363         mpMenu->SetItemText( nItemId, aText );
 364 }
 365
 366 OUString VCLXMenu::getItemText(
 367     sal_Int16 nItemId )
 368 {
 369     SolarMutexGuard aSolarGuard;
 370     std::unique_lock aGuard( maMutex );
 371
 372     OUString aItemText;
 373     if ( mpMenu )
 374         aItemText = mpMenu->GetItemText( nItemId );
 375     return aItemText;
 376 }
 377
 378 void VCLXMenu::setPopupMenu(
 379     sal_Int16 nItemId,
 380     const css::uno::Reference< css::awt::XPopupMenu >& rxPopupMenu )
 381 {
 382     SolarMutexGuard aSolarGuard;
 383     std::unique_lock aGuard( maMutex );
 384
 385     VCLXMenu* pVCLMenu = dynamic_cast<VCLXMenu*>( rxPopupMenu.get() );
 386     DBG_ASSERT( pVCLMenu && pVCLMenu->GetMenu() && pVCLMenu->IsPopupMenu(), "setPopupMenu: Invalid Menu!" );
 387
 388     if ( mpMenu && pVCLMenu && pVCLMenu->GetMenu() && pVCLMenu->IsPopupMenu() )
 389     {
 390         maPopupMenuRefs.push_back( rxPopupMenu );
 391
 392         mpMenu->SetPopupMenu( nItemId, static_cast<PopupMenu*>( pVCLMenu->GetMenu() ) );
 393     }
 394 }
 395
 396 css::uno::Reference< css::awt::XPopupMenu > VCLXMenu::getPopupMenu(
 397     sal_Int16 nItemId )
 398 {
 399     SolarMutexGuard aSolarGuard;
 400     std::unique_lock aGuard( maMutex );
 401
 402     css::uno::Reference< css::awt::XPopupMenu >  aRef;
 403     Menu* pMenu = mpMenu ? mpMenu->GetPopupMenu( nItemId ) : nullptr;
 404     if ( pMenu )
 405     {
 406         for ( size_t n = maPopupMenuRefs.size(); n; )
 407         {
 408             css::uno::Reference< css::awt::XPopupMenu >& rRef = maPopupMenuRefs[ --n ];
 409             Menu* pM = static_cast<VCLXMenu*>(rRef.get())->GetMenu();
 410             if ( pM == pMenu )
 411             {
 412                 aRef = rRef;
 413                 break;
 414             }
 415         }
 416         /*
 417            If the popup menu is not inserted via setPopupMenu then
 418            maPopupMenuRefs won't have an entry for it, so create an XPopupMenu
 419            for it now.
 420
 421            This means that this vcl PopupMenu "pMenu" either existed as a child
 422            of the vcl Menu "mpMenu" before the VCLXMenu was created for that or
 423            it was added directly via vcl.
 424         */
 425         if( !aRef.is() )
 426         {
 427             aRef = new VCLXPopupMenu( static_cast<PopupMenu*>(pMenu) );
 428             /*
 429                In any case, the VCLXMenu has ownership of "mpMenu" and will
 430                destroy it in the VCLXMenu dtor.
 431
 432                Similarly because VCLXPopupMenu takes ownership of the vcl
 433                PopupMenu "pMenu", the underlying vcl popup will be destroyed
 434                when VCLXPopupMenu is, so we should add it now to
 435                maPopupMenuRefs to ensure its lifecycle is at least bound to
 436                the VCLXMenu that owns the parent "mpMenu" similarly to
 437                PopupMenus added via the more conventional setPopupMenu.
 438             */
 439             maPopupMenuRefs.push_back( aRef );
 440         }
 441     }
 442     return aRef;
 443 }
 444
 445 // css::awt::XPopupMenu
 446 void VCLXMenu::insertSeparator(
 447     sal_Int16 nPos )
 448 {
 449     SolarMutexGuard aSolarGuard;
 450     std::unique_lock aGuard( maMutex );
 451
 452     if ( mpMenu )
 453         mpMenu->InsertSeparator({}, nPos);
 454 }
 455
 456 void VCLXMenu::setDefaultItem(
 457     sal_Int16 nItemId )
 458 {
 459     std::unique_lock aGuard( maMutex );
 460
 461     mnDefaultItem = nItemId;
 462 }
 463
 464 sal_Int16 VCLXMenu::getDefaultItem(  )
 465 {
 466     std::unique_lock aGuard( maMutex );
 467
 468     return mnDefaultItem;
 469 }
 470
 471 void VCLXMenu::checkItem(
 472     sal_Int16 nItemId,
 473     sal_Bool bCheck )
 474 {
 475     SolarMutexGuard aSolarGuard;
 476     std::unique_lock aGuard( maMutex );
 477
 478     if ( mpMenu )
 479         mpMenu->CheckItem( nItemId, bCheck );
 480 }
 481
 482 sal_Bool VCLXMenu::isItemChecked(
 483     sal_Int16 nItemId )
 484 {
 485     SolarMutexGuard aSolarGuard;
 486     std::unique_lock aGuard( maMutex );
 487
 488     return mpMenu && mpMenu->IsItemChecked( nItemId );
 489 }
 490
 491 sal_Int16 VCLXMenu::execute(
 492     const css::uno::Reference< css::awt::XWindowPeer >& rxWindowPeer,
 493     const css::awt::Rectangle& rPos,
 494     sal_Int16 nFlags )
 495 {
 496     SolarMutexGuard aSolarGuard;
 497     auto pMenu = mpMenu;
 498     {
 499         std::unique_lock aGuard( maMutex );
 500         if ( !mpMenu || !IsPopupMenu() )
 501             return 0;
 502     }
 503     PopupMenu* pPopupMenu = static_cast<PopupMenu*>(pMenu.get());
 504     MenuFlags nMenuFlags = pPopupMenu->GetMenuFlags();
 505     // #102790# context menus shall never show disabled entries
 506     nMenuFlags |= MenuFlags::HideDisabledEntries;
 507     pPopupMenu->SetMenuFlags(nMenuFlags);
 508     // cannot call this with mutex locked because it will call back into us
 509     return pPopupMenu->Execute(
 510                 VCLUnoHelper::GetWindow( rxWindowPeer ),
 511                 VCLRectangle( rPos ),
 512                 static_cast<PopupMenuFlags>(nFlags) | PopupMenuFlags::NoMouseUpClose );
 513 }
 514
 515
 516 void SAL_CALL VCLXMenu::setCommand(
 517     sal_Int16 nItemId,
 518     const OUString& aCommand )
 519 {
 520     SolarMutexGuard aSolarGuard;
 521     std::unique_lock aGuard( maMutex );
 522
 523     if ( mpMenu )
 524         mpMenu->SetItemCommand( nItemId, aCommand );
 525 }
 526
 527 OUString SAL_CALL VCLXMenu::getCommand(
 528     sal_Int16 nItemId )
 529 {
 530     SolarMutexGuard aSolarGuard;
 531     std::unique_lock aGuard( maMutex );
 532
 533     OUString aItemCommand;
 534     if ( mpMenu )
 535         aItemCommand = mpMenu->GetItemCommand( nItemId );
 536     return aItemCommand;
 537 }
 538
 539 void SAL_CALL VCLXMenu::setHelpCommand(
 540     sal_Int16 nItemId,
 541     const OUString& aHelp )
 542 {
 543     SolarMutexGuard aSolarGuard;
 544     std::unique_lock aGuard( maMutex );
 545
 546     if ( mpMenu )
 547         mpMenu->SetHelpCommand( nItemId, aHelp );
 548 }
 549
 550 OUString SAL_CALL VCLXMenu::getHelpCommand(
 551     sal_Int16 nItemId )
 552 {
 553     SolarMutexGuard aSolarGuard;
 554     std::unique_lock aGuard( maMutex );
 555
 556     OUString aHelpCommand;
 557     if ( mpMenu )
 558         aHelpCommand = mpMenu->GetHelpCommand( nItemId );
 559     return aHelpCommand;
 560 }
 561
 562
 563 namespace
 564 {
 565     Image lcl_XGraphic2VCLImage(
 566         const css::uno::Reference< css::graphic::XGraphic >& xGraphic,
 567         bool bResize )
 568     {
 569         Image aImage;
 570         if ( !xGraphic.is() )
 571             return aImage;
 572
 573         aImage = Image( xGraphic );
 574         const ::Size aCurSize = aImage.GetSizePixel();
 575         const sal_Int32 nCurWidth = aCurSize.Width();
 576         const sal_Int32 nCurHeight = aCurSize.Height();
 577         constexpr sal_Int32 nIdeal( 16 );
 578
 579         if ( nCurWidth > 0 && nCurHeight > 0 )
 580         {
 581             if ( bResize && ( nCurWidth > nIdeal || nCurHeight > nIdeal ) )
 582             {
 583                 sal_Int32 nIdealWidth  = std::min(nCurWidth, nIdeal);
 584                 sal_Int32 nIdealHeight = std::min(nCurHeight, nIdeal);
 585
 586                 ::Size aNewSize( nIdealWidth, nIdealHeight );
 587
 588                 bool bModified( false );
 589                 BitmapEx aBitmapEx = aImage.GetBitmapEx();
 590                 bModified = aBitmapEx.Scale( aNewSize, BmpScaleFlag::BestQuality );
 591
 592                 if ( bModified )
 593                     aImage = Image( aBitmapEx );
 594             }
 595         }
 596         return aImage;
 597     }
 598
 599     /** Copied from include/svtools/acceleratorexecute.hxx */
 600     css::awt::KeyEvent lcl_VCLKey2AWTKey(
 601         const vcl::KeyCode& aVCLKey)
 602     {
 603         css::awt::KeyEvent aAWTKey;
 604         aAWTKey.Modifiers = 0;
 605         aAWTKey.KeyCode   = static_cast<sal_Int16>(aVCLKey.GetCode());
 606
 607         if (aVCLKey.IsShift())
 608             aAWTKey.Modifiers |= css::awt::KeyModifier::SHIFT;
 609         if (aVCLKey.IsMod1())
 610             aAWTKey.Modifiers |= css::awt::KeyModifier::MOD1;
 611         if (aVCLKey.IsMod2())
 612             aAWTKey.Modifiers |= css::awt::KeyModifier::MOD2;
 613         if (aVCLKey.IsMod3())
 614             aAWTKey.Modifiers |= css::awt::KeyModifier::MOD3;
 615
 616         return aAWTKey;
 617     }
 618
 619     vcl::KeyCode lcl_AWTKey2VCLKey(const css::awt::KeyEvent& aAWTKey)
 620     {
 621         bool bShift = ((aAWTKey.Modifiers & css::awt::KeyModifier::SHIFT) == css::awt::KeyModifier::SHIFT );
 622         bool bMod1  = ((aAWTKey.Modifiers & css::awt::KeyModifier::MOD1 ) == css::awt::KeyModifier::MOD1  );
 623         bool bMod2  = ((aAWTKey.Modifiers & css::awt::KeyModifier::MOD2 ) == css::awt::KeyModifier::MOD2  );
 624         bool bMod3  = ((aAWTKey.Modifiers & css::awt::KeyModifier::MOD3 ) == css::awt::KeyModifier::MOD3  );
 625         sal_uInt16   nKey   = static_cast<sal_uInt16>(aAWTKey.KeyCode);
 626
 627         return vcl::KeyCode(nKey, bShift, bMod1, bMod2, bMod3);
 628     }
 629
 630 }
 631
 632
 633 sal_Bool SAL_CALL VCLXMenu::isPopupMenu(  )
 634 {
 635     SolarMutexGuard aSolarGuard;
 636     std::unique_lock aGuard( maMutex );
 637     return IsPopupMenu();
 638 }
 639
 640 void SAL_CALL VCLXMenu::clear(  )
 641 {
 642     SolarMutexGuard aSolarGuard;
 643     std::unique_lock aGuard( maMutex );
 644     if ( mpMenu )
 645         mpMenu->Clear();
 646 }
 647
 648
 649 css::awt::MenuItemType SAL_CALL VCLXMenu::getItemType(
 650     ::sal_Int16 nItemPos )
 651 {
 652     SolarMutexGuard aSolarGuard;
 653     std::unique_lock aGuard( maMutex );
 654
 655     css::awt::MenuItemType aMenuItemType =
 656         css::awt::MenuItemType_DONTKNOW;
 657     if ( mpMenu )
 658     {
 659         aMenuItemType = static_cast<css::awt::MenuItemType>(mpMenu->GetItemType( nItemPos ));
 660     }
 661
 662     return aMenuItemType;
 663 }
 664
 665 void SAL_CALL VCLXMenu::hideDisabledEntries(
 666     sal_Bool bHide )
 667 {
 668     SolarMutexGuard aSolarGuard;
 669     std::unique_lock aGuard( maMutex );
 670     if ( mpMenu )
 671     {
 672         if ( bHide )
 673             mpMenu->SetMenuFlags( mpMenu->GetMenuFlags() | MenuFlags::HideDisabledEntries );
 674         else
 675             mpMenu->SetMenuFlags( mpMenu->GetMenuFlags() & ~MenuFlags::HideDisabledEntries );
 676     }
 677 }
 678
 679
 680 sal_Bool SAL_CALL VCLXMenu::isInExecute(  )
 681 {
 682     SolarMutexGuard aSolarGuard;
 683     std::unique_lock aGuard( maMutex );
 684
 685     if ( mpMenu && IsPopupMenu() )
 686         return vcl::IsInPopupMenuExecute();
 687     else
 688         return false;
 689 }
 690
 691
 692 void SAL_CALL VCLXMenu::endExecute()
 693 {
 694     SolarMutexGuard aSolarGuard;
 695     std::unique_lock aGuard( maMutex );
 696
 697     if ( mpMenu && IsPopupMenu() )
 698         static_cast<PopupMenu*>( mpMenu.get() )->EndExecute();
 699 }
 700
 701
 702 void SAL_CALL VCLXMenu::enableAutoMnemonics(
 703     sal_Bool bEnable )
 704 {
 705     SolarMutexGuard aSolarGuard;
 706     std::unique_lock aGuard( maMutex );
 707     if ( mpMenu )
 708     {
 709         if ( !bEnable )
 710             mpMenu->SetMenuFlags( mpMenu->GetMenuFlags() | MenuFlags::NoAutoMnemonics );
 711         else
 712             mpMenu->SetMenuFlags( mpMenu->GetMenuFlags() & ~MenuFlags::NoAutoMnemonics );
 713     }
 714 }
 715
 716
 717 void SAL_CALL VCLXMenu::setAcceleratorKeyEvent(
 718     ::sal_Int16 nItemId,
 719     const css::awt::KeyEvent& aKeyEvent )
 720 {
 721     SolarMutexGuard aSolarGuard;
 722     std::unique_lock aGuard( maMutex );
 723
 724     if ( mpMenu && IsPopupMenu() && MENU_ITEM_NOTFOUND != mpMenu->GetItemPos( nItemId ) )
 725     {
 726         vcl::KeyCode aVCLKeyCode = lcl_AWTKey2VCLKey( aKeyEvent );
 727         mpMenu->SetAccelKey( nItemId, aVCLKeyCode );
 728     }
 729 }
 730
 731
 732 css::awt::KeyEvent SAL_CALL VCLXMenu::getAcceleratorKeyEvent(
 733     ::sal_Int16 nItemId )
 734 {
 735     SolarMutexGuard aSolarGuard;
 736     std::unique_lock aGuard( maMutex );
 737
 738     css::awt::KeyEvent aKeyEvent;
 739     if ( mpMenu && IsPopupMenu() && MENU_ITEM_NOTFOUND != mpMenu->GetItemPos( nItemId ) )
 740     {
 741         vcl::KeyCode nKeyCode = mpMenu->GetAccelKey( nItemId );
 742         aKeyEvent = lcl_VCLKey2AWTKey( nKeyCode );
 743     }
 744
 745     return aKeyEvent;
 746 }
 747
 748
 749 void SAL_CALL VCLXMenu::setHelpText(
 750     ::sal_Int16 nItemId,
 751     const OUString& sHelpText )
 752 {
 753     SolarMutexGuard aSolarGuard;
 754     std::unique_lock aGuard( maMutex );
 755
 756     if ( mpMenu && MENU_ITEM_NOTFOUND != mpMenu->GetItemPos( nItemId ) )
 757     {
 758         mpMenu->SetHelpText( nItemId, sHelpText );
 759     }
 760 }
 761
 762
 763 OUString SAL_CALL VCLXMenu::getHelpText(
 764     ::sal_Int16 nItemId )
 765 {
 766     SolarMutexGuard aSolarGuard;
 767     std::unique_lock aGuard( maMutex );
 768
 769     OUString sHelpText;
 770     if ( mpMenu && MENU_ITEM_NOTFOUND != mpMenu->GetItemPos( nItemId ) )
 771     {
 772         sHelpText = mpMenu->GetHelpText( nItemId );
 773     }
 774
 775     return sHelpText;
 776 }
 777
 778
 779 void SAL_CALL VCLXMenu::setTipHelpText(
 780     ::sal_Int16 nItemId,
 781     const OUString& sTipHelpText )
 782 {
 783     SolarMutexGuard aSolarGuard;
 784     std::unique_lock aGuard( maMutex );
 785
 786     if ( mpMenu && MENU_ITEM_NOTFOUND != mpMenu->GetItemPos( nItemId ) )
 787     {
 788         mpMenu->SetTipHelpText( nItemId, sTipHelpText );
 789     }
 790 }
 791
 792
 793 OUString SAL_CALL VCLXMenu::getTipHelpText(
 794     ::sal_Int16 nItemId )
 795 {
 796     SolarMutexGuard aSolarGuard;
 797     std::unique_lock aGuard( maMutex );
 798
 799     OUString sTipHelpText;
 800     if ( mpMenu && MENU_ITEM_NOTFOUND != mpMenu->GetItemPos( nItemId ) )
 801     {
 802         sTipHelpText = mpMenu->GetTipHelpText( nItemId );
 803     }
 804     return sTipHelpText;
 805 }
 806
 807
 808 void SAL_CALL VCLXMenu::setItemImage(
 809     ::sal_Int16 nItemId,
 810     const css::uno::Reference< css::graphic::XGraphic >& xGraphic,
 811     sal_Bool bScale )
 812 {
 813     SolarMutexGuard aSolarGuard;
 814     std::unique_lock aGuard( maMutex );
 815
 816     if ( mpMenu && IsPopupMenu() && MENU_ITEM_NOTFOUND != mpMenu->GetItemPos( nItemId ) )
 817     {
 818         Image aImage = lcl_XGraphic2VCLImage( xGraphic, bScale );
 819         mpMenu->SetItemImage( nItemId, aImage );
 820     }
 821 }
 822
 823
 824 css::uno::Reference< css::graphic::XGraphic > SAL_CALL
 825 VCLXMenu::getItemImage(
 826     ::sal_Int16 nItemId )
 827 {
 828     SolarMutexGuard aSolarGuard;
 829     std::unique_lock aGuard( maMutex );
 830
 831     css::uno::Reference< css::graphic::XGraphic > rxGraphic;
 832
 833     if ( mpMenu && IsPopupMenu() && MENU_ITEM_NOTFOUND != mpMenu->GetItemPos( nItemId ) )
 834     {
 835         Image aImage = mpMenu->GetItemImage( nItemId );
 836         if ( !!aImage )
 837             rxGraphic = Graphic(aImage.GetBitmapEx()).GetXGraphic();
 838     }
 839     return rxGraphic;
 840 }
 841
 842 void VCLXMenu::setUserValue(sal_uInt16 nItemId, void* nUserValue, MenuUserDataReleaseFunction aFunc)
 843 {
 844     SolarMutexGuard aSolarGuard;
 845     std::unique_lock aGuard(maMutex);
 846
 847     mpMenu->SetUserValue(nItemId, nUserValue, aFunc);
 848 }
 849
 850 void* VCLXMenu::getUserValue(sal_uInt16 nItemId)
 851 {
 852     SolarMutexGuard aSolarGuard;
 853     std::unique_lock aGuard(maMutex);
 854
 855     return mpMenu->GetUserValue(nItemId);
 856 }
 857
 858 VCLXMenuBar::VCLXMenuBar()
 859 {
 860     ImplCreateMenu( false );
 861 }
 862
 863 VCLXMenuBar::VCLXMenuBar( MenuBar* pMenuBar ) : VCLXMenu( static_cast<Menu *>(pMenuBar) )
 864 {
 865 }
 866
 867 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 868 stardiv_Toolkit_VCLXMenuBar_get_implementation(
 869     css::uno::XComponentContext *,
 870     css::uno::Sequence<css::uno::Any> const &)
 871 {
 872     return cppu::acquire(new VCLXMenuBar());
 873 }
 874
 875 VCLXPopupMenu::VCLXPopupMenu()
 876 {
 877     ImplCreateMenu( true );
 878 }
 879
 880 VCLXPopupMenu::VCLXPopupMenu( PopupMenu* pPopMenu ) : VCLXMenu( static_cast<Menu *>(pPopMenu) )
 881 {
 882     ImplAddListener();
 883 }
 884
 885 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 886 stardiv_Toolkit_VCLXPopupMenu_get_implementation(
 887     css::uno::XComponentContext *,
 888     css::uno::Sequence<css::uno::Any> const &)
 889 {
 890     return cppu::acquire(new VCLXPopupMenu());
 891 }
 892
 893 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */