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