vcl/source/window/accel.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: accel.cxx,v $
  10  * $Revision: 1.11 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_vcl.hxx"
  33 #include <tools/list.hxx>
  34 #ifndef _TABLE_HXX
  35 #include <tools/table.hxx>
  36 #endif
  37 #include <tools/debug.hxx>
  38 #include <vcl/svapp.hxx>
  39 #include <vcl/accel.h>
  40 #include <vcl/accel.hxx>
  41 #ifndef _RC_H
  42 #include <tools/rc.h>
  43 #endif
  44
  45
  46
  47 // =======================================================================
  48
  49 DECLARE_TABLE( ImplAccelTable, ImplAccelEntry* )
  50 DECLARE_LIST( ImplAccelList, ImplAccelEntry* )
  51
  52 #define ACCELENTRY_NOTFOUND     ((USHORT)0xFFFF)
  53
  54 // =======================================================================
  55
  56 class ImplAccelData
  57 {
  58 public:
  59     ImplAccelTable      maKeyTable;     // Fuer KeyCodes, die mit einem Code erzeugt wurden
  60     ImplAccelList       maIdList;               // Id-List
  61 };
  62
  63 // =======================================================================
  64
  65 DBG_NAME( Accelerator )
  66
  67 // =======================================================================
  68
  69 USHORT ImplAccelEntryGetIndex( ImplAccelList* pList, USHORT nId,
  70                                USHORT* pIndex = NULL )
  71 {
  72     ULONG       nLow;
  73     ULONG       nHigh;
  74     ULONG       nMid;
  75     ULONG       nCount = pList->Count();
  76     USHORT      nCompareId;
  77
  78     // Abpruefen, ob der erste Key groesser als der Vergleichskey ist
  79     if ( !nCount || (nId < pList->GetObject( 0 )->mnId) )
  80     {
  81         if ( pIndex )
  82             *pIndex = 0;
  83         return ACCELENTRY_NOTFOUND;
  84     }
  85
  86     // Binaeres Suchen
  87     nLow  = 0;
  88     nHigh = nCount-1;
  89     do
  90     {
  91         nMid = (nLow + nHigh) / 2;
  92         nCompareId = pList->GetObject( nMid )->mnId;
  93         if ( nId < nCompareId )
  94             nHigh = nMid-1;
  95         else
  96         {
  97             if ( nId > nCompareId )
  98                 nLow = nMid + 1;
  99             else
 100                 return (USHORT)nMid;
 101         }
 102     }
 103     while ( nLow <= nHigh );
 104
 105     if ( pIndex )
 106     {
 107         if ( nId > nCompareId )
 108             *pIndex = (USHORT)(nMid+1);
 109         else
 110             *pIndex = (USHORT)nMid;
 111     }
 112
 113     return ACCELENTRY_NOTFOUND;
 114 }
 115
 116 // -----------------------------------------------------------------------
 117
 118 static void ImplAccelEntryInsert( ImplAccelList* pList, ImplAccelEntry* pEntry )
 119 {
 120     USHORT      nInsIndex;
 121     USHORT      nIndex = ImplAccelEntryGetIndex( pList, pEntry->mnId, &nInsIndex );
 122
 123     if ( nIndex != ACCELENTRY_NOTFOUND )
 124     {
 125         do
 126         {
 127             nIndex++;
 128             ImplAccelEntry* pTempEntry = pList->GetObject( nIndex );
 129             if ( !pTempEntry || (pTempEntry->mnId != pEntry->mnId) )
 130                 break;
 131         }
 132         while ( nIndex < pList->Count() );
 133
 134         pList->Insert( pEntry, (ULONG)nIndex );
 135     }
 136     else
 137         pList->Insert( pEntry, (ULONG)nInsIndex );
 138 }
 139
 140 // -----------------------------------------------------------------------
 141
 142 static USHORT ImplAccelEntryGetFirstPos( ImplAccelList* pList, USHORT nId )
 143 {
 144     USHORT nIndex = ImplAccelEntryGetIndex( pList, nId );
 145     if ( nIndex != ACCELENTRY_NOTFOUND )
 146     {
 147         while ( nIndex )
 148         {
 149             nIndex--;
 150             if ( pList->GetObject( nIndex )->mnId != nId )
 151                 break;
 152         }
 153
 154         if ( pList->GetObject( nIndex )->mnId != nId )
 155             nIndex++;
 156     }
 157
 158     return nIndex;
 159 }
 160
 161 // =======================================================================
 162
 163 void Accelerator::ImplInit()
 164 {
 165     mnCurId                     = 0;
 166     mnCurRepeat                 = 0;
 167     mbIsCancel                  = FALSE;
 168     mpDel                               = NULL;
 169 }
 170
 171 // -----------------------------------------------------------------------
 172
 173 ImplAccelEntry* Accelerator::ImplGetAccelData( const KeyCode& rKeyCode ) const
 174 {
 175     return mpData->maKeyTable.Get( rKeyCode.GetFullKeyCode() );
 176 }
 177
 178 // -----------------------------------------------------------------------
 179
 180 void Accelerator::ImplCopyData( ImplAccelData& rAccelData )
 181 {
 182     // Tabellen kopieren
 183     ImplAccelEntry* pEntry = rAccelData.maIdList.First();
 184     while ( pEntry )
 185     {
 186         pEntry = new ImplAccelEntry( *pEntry );
 187
 188         // Folge-Accelerator, dann auch kopieren
 189         if ( pEntry->mpAccel )
 190         {
 191             pEntry->mpAccel = new Accelerator( *(pEntry->mpAccel) );
 192             pEntry->mpAutoAccel = pEntry->mpAccel;
 193         }
 194         else
 195             pEntry->mpAutoAccel = NULL;
 196
 197         mpData->maKeyTable.Insert( (ULONG)pEntry->maKeyCode.GetFullKeyCode(), pEntry );
 198         mpData->maIdList.Insert( pEntry, LIST_APPEND );
 199
 200         pEntry = rAccelData.maIdList.Next();
 201     }
 202 }
 203
 204 // -----------------------------------------------------------------------
 205
 206 void Accelerator::ImplDeleteData()
 207 {
 208     // Accelerator-Eintraege ueber die Id-Tabelle loeschen
 209     ImplAccelEntry* pEntry = mpData->maIdList.First();
 210     while ( pEntry )
 211     {
 212         // AutoResAccel zerstoeren
 213         if ( pEntry->mpAutoAccel )
 214             delete pEntry->mpAutoAccel;
 215         delete pEntry;
 216
 217         pEntry = mpData->maIdList.Next();
 218     }
 219 }
 220
 221 // -----------------------------------------------------------------------
 222
 223 void Accelerator::ImplInsertAccel( USHORT nItemId, const KeyCode& rKeyCode,
 224                                    BOOL bEnable, Accelerator* pAutoAccel )
 225 {
 226     DBG_CHKTHIS( Accelerator, NULL );
 227     DBG_ASSERT( nItemId, "Accelerator::InsertItem(): ItemId == 0" );
 228
 229     if ( rKeyCode.IsFunction() )
 230     {
 231         USHORT nCode1;
 232         USHORT nCode2;
 233         USHORT nCode3;
 234                 USHORT nCode4;
 235         ImplGetKeyCode( rKeyCode.GetFunction(), nCode1, nCode2, nCode3, nCode4 );
 236         if ( nCode1 )
 237             ImplInsertAccel( nItemId, KeyCode( nCode1, nCode1 ), bEnable, pAutoAccel );
 238         if ( nCode2 )
 239         {
 240             if ( pAutoAccel )
 241                 pAutoAccel = new Accelerator( *pAutoAccel );
 242             ImplInsertAccel( nItemId, KeyCode( nCode2, nCode2 ), bEnable, pAutoAccel );
 243             if ( nCode3 )
 244             {
 245                 if ( pAutoAccel )
 246                     pAutoAccel = new Accelerator( *pAutoAccel );
 247                 ImplInsertAccel( nItemId, KeyCode( nCode3, nCode3 ), bEnable, pAutoAccel );
 248             }
 249         }
 250         return;
 251     }
 252
 253     // Neuen Eintrag holen und fuellen
 254     ImplAccelEntry* pEntry      = new ImplAccelEntry;
 255     pEntry->mnId                        = nItemId;
 256     pEntry->maKeyCode           = rKeyCode;
 257     pEntry->mpAccel             = pAutoAccel;
 258     pEntry->mpAutoAccel         = pAutoAccel;
 259     pEntry->mbEnabled           = bEnable;
 260
 261     // Ab in die Tabellen
 262     ULONG nCode = rKeyCode.GetFullKeyCode();
 263     if ( !nCode )
 264     {
 265         DBG_ERROR( "Accelerator::InsertItem(): KeyCode with KeyCode 0 not allowed" );
 266         delete pEntry;
 267     }
 268     else if ( !mpData->maKeyTable.Insert( nCode, pEntry ) )
 269     {
 270         DBG_ERROR1( "Accelerator::InsertItem(): KeyCode (Key: %lx) already exists", nCode );
 271         delete pEntry;
 272     }
 273     else
 274         ImplAccelEntryInsert( &(mpData->maIdList), pEntry );
 275 }
 276
 277 // -----------------------------------------------------------------------
 278
 279 Accelerator::Accelerator()
 280 {
 281     DBG_CTOR( Accelerator, NULL );
 282
 283     ImplInit();
 284     mpData = new ImplAccelData;
 285 }
 286
 287 // -----------------------------------------------------------------------
 288
 289 Accelerator::Accelerator( const Accelerator& rAccel ) :
 290     Resource(),
 291     maHelpStr( rAccel.maHelpStr ),
 292     maCurKeyCode( rAccel.maCurKeyCode )
 293 {
 294     DBG_CTOR( Accelerator, NULL );
 295     DBG_CHKOBJ( &rAccel, Accelerator, NULL );
 296
 297     ImplInit();
 298     mpData = new ImplAccelData;
 299     ImplCopyData( *((ImplAccelData*)(rAccel.mpData)) );
 300 }
 301
 302 // -----------------------------------------------------------------------
 303
 304 Accelerator::Accelerator( const ResId& rResId )
 305 {
 306     DBG_CTOR( Accelerator, NULL );
 307
 308     ImplInit();
 309     mpData = new ImplAccelData;
 310     rResId.SetRT( RSC_ACCEL );
 311     ImplLoadRes( rResId );
 312 }
 313
 314 // -----------------------------------------------------------------------
 315
 316 void Accelerator::ImplLoadRes( const ResId& rResId )
 317 {
 318     GetRes( rResId );
 319
 320     maHelpStr = ReadStringRes();
 321     ULONG nObjFollows = ReadLongRes();
 322
 323     for( ULONG i = 0; i < nObjFollows; i++ )
 324     {
 325         InsertItem( ResId( (RSHEADER_TYPE *)GetClassRes(), *rResId.GetResMgr() ) );
 326         IncrementRes( GetObjSizeRes( (RSHEADER_TYPE *)GetClassRes() ) );
 327     }
 328 }
 329
 330 // -----------------------------------------------------------------------
 331
 332 Accelerator::~Accelerator()
 333 {
 334     DBG_DTOR( Accelerator, NULL );
 335
 336     // AccelManager benachrichtigen, das Accelrator geloescht wurde
 337     if ( mpDel )
 338         *mpDel = TRUE;
 339
 340     ImplDeleteData();
 341     delete mpData;
 342 }
 343
 344 // -----------------------------------------------------------------------
 345
 346 void Accelerator::Activate()
 347 {
 348     maActivateHdl.Call( this );
 349 }
 350
 351 // -----------------------------------------------------------------------
 352
 353 void Accelerator::Deactivate()
 354 {
 355     maDeactivateHdl.Call( this );
 356 }
 357
 358 // -----------------------------------------------------------------------
 359
 360 void Accelerator::Select()
 361 {
 362     maSelectHdl.Call( this );
 363 }
 364
 365 // -----------------------------------------------------------------------
 366
 367 void Accelerator::InsertItem( USHORT nItemId, const KeyCode& rKeyCode )
 368 {
 369     ImplInsertAccel( nItemId, rKeyCode, TRUE, NULL );
 370 }
 371
 372 // -----------------------------------------------------------------------
 373
 374 void Accelerator::InsertItem( const ResId& rResId )
 375 {
 376     DBG_CHKTHIS( Accelerator, NULL );
 377
 378     ULONG                               nObjMask;
 379     USHORT                              nAccelKeyId;
 380     USHORT                              bDisable;
 381     KeyCode                     aKeyCode;
 382     Accelerator*                pAutoAccel      = NULL;
 383
 384     GetRes( rResId.SetRT( RSC_ACCELITEM ) );
 385     nObjMask            = ReadLongRes();
 386     nAccelKeyId         = sal::static_int_cast<USHORT>(ReadLongRes());
 387     bDisable            = ReadShortRes();
 388
 389     if ( nObjMask & ACCELITEM_KEY )
 390     {
 391         // es wird ein neuer Kontext aufgespannt
 392         RSHEADER_TYPE * pKeyCodeRes = (RSHEADER_TYPE *)GetClassRes();
 393         ResId aResId( pKeyCodeRes, *rResId.GetResMgr());
 394         aKeyCode = KeyCode( aResId );
 395         IncrementRes( GetObjSizeRes( (RSHEADER_TYPE *)GetClassRes() ) );
 396     }
 397
 398     if ( nObjMask & ACCELITEM_ACCEL )
 399     {
 400         pAutoAccel = new Accelerator( ResId( (RSHEADER_TYPE *)GetClassRes(), *rResId.GetResMgr() ) );
 401         IncrementRes( GetObjSizeRes( (RSHEADER_TYPE *)GetClassRes() ) );
 402     }
 403
 404     ImplInsertAccel( nAccelKeyId, aKeyCode, !bDisable, pAutoAccel );
 405 }
 406
 407 // -----------------------------------------------------------------------
 408
 409 void Accelerator::RemoveItem( USHORT nItemId )
 410 {
 411     DBG_CHKTHIS( Accelerator, NULL );
 412
 413     // Aus der Id-Liste entfernen
 414     USHORT nIndex = ImplAccelEntryGetFirstPos( &(mpData->maIdList), nItemId );
 415     if ( nIndex != ACCELENTRY_NOTFOUND )
 416     {
 417         USHORT nItemCount = GetItemCount();
 418         do
 419         {
 420             ImplAccelEntry* pEntry = mpData->maIdList.GetObject( (ULONG)nIndex );
 421             if ( pEntry && pEntry->mnId == nItemId )
 422             {
 423                 mpData->maKeyTable.Remove( pEntry->maKeyCode.GetFullKeyCode() );
 424                 mpData->maIdList.Remove( (ULONG)nIndex );
 425
 426                 // AutoResAccel zerstoeren
 427                 if ( pEntry->mpAutoAccel )
 428                     delete pEntry->mpAutoAccel;
 429
 430                 delete pEntry;
 431             }
 432             else
 433                 break;
 434         }
 435         while ( nIndex < nItemCount );
 436     }
 437 }
 438
 439 // -----------------------------------------------------------------------
 440
 441 void Accelerator::RemoveItem( const KeyCode rKeyCode )
 442 {
 443     DBG_CHKTHIS( Accelerator, NULL );
 444
 445     ImplAccelEntry* pEntry = ImplGetAccelData( rKeyCode );
 446     if ( pEntry )
 447     {
 448         // Aus der Id-Liste entfernen
 449         USHORT nIndex = ImplAccelEntryGetFirstPos( &(mpData->maIdList), pEntry->mnId );
 450         USHORT nItemCount = GetItemCount();
 451         do
 452         {
 453             if ( mpData->maIdList.GetObject( (ULONG)nIndex ) == pEntry )
 454                 break;
 455             nIndex++;
 456         }
 457         while ( nIndex < nItemCount );
 458
 459         mpData->maKeyTable.Remove( rKeyCode.GetFullKeyCode() );
 460         mpData->maIdList.Remove( (ULONG)nIndex );
 461
 462         // AutoResAccel zerstoeren
 463         if ( pEntry->mpAutoAccel )
 464             delete pEntry->mpAutoAccel;
 465
 466         delete pEntry;
 467     }
 468 }
 469
 470 // -----------------------------------------------------------------------
 471
 472 void Accelerator::Clear()
 473 {
 474     DBG_CHKTHIS( Accelerator, NULL );
 475
 476     ImplDeleteData();
 477     mpData->maKeyTable.Clear();
 478     mpData->maIdList.Clear();
 479 }
 480
 481 // -----------------------------------------------------------------------
 482
 483 USHORT Accelerator::GetItemCount() const
 484 {
 485     DBG_CHKTHIS( Accelerator, NULL );
 486
 487     return (USHORT)mpData->maIdList.Count();
 488 }
 489
 490 // -----------------------------------------------------------------------
 491
 492 USHORT Accelerator::GetItemId( USHORT nPos ) const
 493 {
 494     DBG_CHKTHIS( Accelerator, NULL );
 495
 496     ImplAccelEntry* pEntry = mpData->maIdList.GetObject( (ULONG)nPos );
 497     if ( pEntry )
 498         return pEntry->mnId;
 499     else
 500         return 0;
 501 }
 502
 503 // -----------------------------------------------------------------------
 504
 505 KeyCode Accelerator::GetItemKeyCode( USHORT nPos ) const
 506 {
 507     DBG_CHKTHIS( Accelerator, NULL );
 508
 509     ImplAccelEntry* pEntry = mpData->maIdList.GetObject( (ULONG)nPos );
 510     if ( pEntry )
 511         return pEntry->maKeyCode;
 512     else
 513         return KeyCode();
 514 }
 515
 516 // -----------------------------------------------------------------------
 517
 518 USHORT Accelerator::GetItemId( const KeyCode& rKeyCode ) const
 519 {
 520     DBG_CHKTHIS( Accelerator, NULL );
 521
 522     ImplAccelEntry* pEntry = ImplGetAccelData( rKeyCode );
 523     if ( pEntry )
 524         return pEntry->mnId;
 525     else
 526         return 0;
 527 }
 528
 529 // -----------------------------------------------------------------------
 530
 531 KeyCode Accelerator::GetKeyCode( USHORT nItemId ) const
 532 {
 533     DBG_CHKTHIS( Accelerator, NULL );
 534
 535     USHORT nIndex = ImplAccelEntryGetFirstPos( &(mpData->maIdList), nItemId );
 536     if ( nIndex != ACCELENTRY_NOTFOUND )
 537         return mpData->maIdList.GetObject( (ULONG)nIndex )->maKeyCode;
 538     else
 539         return KeyCode();
 540 }
 541
 542 // -----------------------------------------------------------------------
 543
 544 BOOL Accelerator::IsIdValid( USHORT nItemId ) const
 545 {
 546     DBG_CHKTHIS( Accelerator, NULL );
 547
 548     USHORT nIndex = ImplAccelEntryGetIndex( &(mpData->maIdList), nItemId );
 549     return (nIndex != ACCELENTRY_NOTFOUND);
 550 }
 551
 552 // -----------------------------------------------------------------------
 553
 554 BOOL Accelerator::IsKeyCodeValid( const KeyCode rKeyCode ) const
 555 {
 556     DBG_CHKTHIS( Accelerator, NULL );
 557
 558     ImplAccelEntry* pEntry = ImplGetAccelData( rKeyCode );
 559     return (pEntry != NULL);
 560 }
 561
 562 // -----------------------------------------------------------------------
 563
 564 BOOL Accelerator::Call( const KeyCode& rKeyCode, USHORT nRepeat )
 565 {
 566     DBG_CHKTHIS( Accelerator, NULL );
 567
 568     ImplAccelEntry* pEntry = ImplGetAccelData( rKeyCode );
 569     if ( pEntry )
 570     {
 571         if ( pEntry->mbEnabled )
 572         {
 573             BOOL bDel = FALSE;
 574             mnCurId             = pEntry->mnId;
 575             maCurKeyCode        = rKeyCode;
 576             mnCurRepeat         = nRepeat;
 577             mpDel                       = &bDel;
 578             Select();
 579             if ( !bDel )
 580             {
 581                 mnCurId                 = 0;
 582                 maCurKeyCode    = KeyCode();
 583                 mnCurRepeat     = 0;
 584             }
 585
 586             return TRUE;
 587         }
 588     }
 589
 590     return FALSE;
 591 }
 592
 593 // -----------------------------------------------------------------------
 594
 595 void Accelerator::SetAccel( USHORT nItemId, Accelerator* pAccel )
 596 {
 597     DBG_CHKTHIS( Accelerator, NULL );
 598
 599     USHORT nIndex = ImplAccelEntryGetFirstPos( &(mpData->maIdList), nItemId );
 600     if ( nIndex != ACCELENTRY_NOTFOUND )
 601     {
 602         USHORT nItemCount = GetItemCount();
 603         do
 604         {
 605             ImplAccelEntry* pEntry = mpData->maIdList.GetObject( (ULONG)nIndex );
 606             if ( pEntry->mnId != nItemId )
 607                 break;
 608
 609             pEntry->mpAccel = pAccel;
 610             nIndex++;
 611         }
 612         while ( nIndex < nItemCount );
 613     }
 614 }
 615
 616 // -----------------------------------------------------------------------
 617
 618 Accelerator* Accelerator::GetAccel( USHORT nItemId ) const
 619 {
 620     DBG_CHKTHIS( Accelerator, NULL );
 621
 622     USHORT nIndex = ImplAccelEntryGetIndex( &(mpData->maIdList), nItemId );
 623     if ( nIndex != ACCELENTRY_NOTFOUND )
 624         return mpData->maIdList.GetObject( (ULONG)nIndex )->mpAccel;
 625     else
 626         return NULL;
 627 }
 628
 629 // -----------------------------------------------------------------------
 630
 631 void Accelerator::SetAccel( const KeyCode rKeyCode, Accelerator* pAccel )
 632 {
 633     DBG_CHKTHIS( Accelerator, NULL );
 634
 635     ImplAccelEntry* pEntry = ImplGetAccelData( rKeyCode );
 636     if ( pEntry )
 637         pEntry->mpAccel = pAccel;
 638 }
 639
 640 // -----------------------------------------------------------------------
 641
 642 Accelerator* Accelerator::GetAccel( const KeyCode rKeyCode ) const
 643 {
 644     DBG_CHKTHIS( Accelerator, NULL );
 645
 646     ImplAccelEntry* pEntry = ImplGetAccelData( rKeyCode );
 647     if ( pEntry )
 648         return pEntry->mpAccel;
 649     else
 650         return FALSE;
 651 }
 652
 653 // -----------------------------------------------------------------------
 654
 655 void Accelerator::EnableItem( USHORT nItemId, BOOL bEnable )
 656 {
 657     DBG_CHKTHIS( Accelerator, NULL );
 658
 659     USHORT nIndex = ImplAccelEntryGetFirstPos( &(mpData->maIdList), nItemId );
 660     if ( nIndex != ACCELENTRY_NOTFOUND )
 661     {
 662         USHORT nItemCount = GetItemCount();
 663         do
 664         {
 665             ImplAccelEntry* pEntry = mpData->maIdList.GetObject( (ULONG)nIndex );
 666             if ( pEntry->mnId != nItemId )
 667                 break;
 668
 669             pEntry->mbEnabled = bEnable;
 670             nIndex++;
 671         }
 672         while ( nIndex < nItemCount );
 673     }
 674 }
 675
 676 // -----------------------------------------------------------------------
 677
 678 BOOL Accelerator::IsItemEnabled( USHORT nItemId ) const
 679 {
 680     DBG_CHKTHIS( Accelerator, NULL );
 681
 682     USHORT nIndex = ImplAccelEntryGetIndex( &(mpData->maIdList), nItemId );
 683     if ( nIndex != ACCELENTRY_NOTFOUND )
 684         return mpData->maIdList.GetObject( (ULONG)nIndex )->mbEnabled;
 685     else
 686         return FALSE;
 687 }
 688
 689 // -----------------------------------------------------------------------
 690
 691 void Accelerator::EnableItem( const KeyCode rKeyCode, BOOL bEnable )
 692 {
 693     DBG_CHKTHIS( Accelerator, NULL );
 694
 695     ImplAccelEntry* pEntry = ImplGetAccelData( rKeyCode );
 696     if ( pEntry )
 697         pEntry->mbEnabled = bEnable;
 698 }
 699
 700 // -----------------------------------------------------------------------
 701
 702 BOOL Accelerator::IsItemEnabled( const KeyCode rKeyCode ) const
 703 {
 704     DBG_CHKTHIS( Accelerator, NULL );
 705
 706     ImplAccelEntry* pEntry = ImplGetAccelData( rKeyCode );
 707     if ( pEntry )
 708         return pEntry->mbEnabled;
 709     else
 710         return FALSE;
 711 }
 712
 713 // -----------------------------------------------------------------------
 714
 715 Accelerator& Accelerator::operator=( const Accelerator& rAccel )
 716 {
 717     DBG_CHKTHIS( Accelerator, NULL );
 718     DBG_CHKOBJ( &rAccel, Accelerator, NULL );
 719
 720     // Neue Daten zuweisen
 721     maHelpStr           = rAccel.maHelpStr;
 722     maCurKeyCode        = KeyCode();
 723     mnCurId             = 0;
 724     mnCurRepeat         = 0;
 725     mbIsCancel          = FALSE;
 726
 727     // Tabellen loeschen und kopieren
 728     ImplDeleteData();
 729     mpData->maKeyTable.Clear();
 730     mpData->maIdList.Clear();
 731     ImplCopyData( *((ImplAccelData*)(rAccel.mpData)) );
 732
 733     return *this;
 734 }