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