/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_vcl.hxx"
#include <tools/list.hxx>
#include <tools/table.hxx>
#include <tools/debug.hxx>
#include <tools/rc.h>

#include <vcl/svapp.hxx>
#include <accel.h>
#include <vcl/accel.hxx>


// =======================================================================

DECLARE_TABLE( ImplAccelTable, ImplAccelEntry* )
DECLARE_LIST( ImplAccelList, ImplAccelEntry* )

#define ACCELENTRY_NOTFOUND 	((sal_uInt16)0xFFFF)

// =======================================================================

class ImplAccelData
{
public:
	ImplAccelTable	maKeyTable; 	// Fuer KeyCodes, die mit einem Code erzeugt wurden
	ImplAccelList	maIdList;		// Id-List
};

// =======================================================================

DBG_NAME( Accelerator )

// =======================================================================

sal_uInt16 ImplAccelEntryGetIndex( ImplAccelList* pList, sal_uInt16 nId,
							   sal_uInt16* pIndex = NULL )
{
	sal_uLong	nLow;
	sal_uLong	nHigh;
	sal_uLong	nMid;
	sal_uLong	nCount = pList->Count();
	sal_uInt16	nCompareId;

	// Abpruefen, ob der erste Key groesser als der Vergleichskey ist
	if ( !nCount || (nId < pList->GetObject( 0 )->mnId) )
	{
		if ( pIndex )
			*pIndex = 0;
		return ACCELENTRY_NOTFOUND;
	}

	// Binaeres Suchen
	nLow  = 0;
	nHigh = nCount-1;
	do
	{
		nMid = (nLow + nHigh) / 2;
		nCompareId = pList->GetObject( nMid )->mnId;
		if ( nId < nCompareId )
			nHigh = nMid-1;
		else
		{
			if ( nId > nCompareId )
				nLow = nMid + 1;
			else
				return (sal_uInt16)nMid;
		}
	}
	while ( nLow <= nHigh );

	if ( pIndex )
	{
		if ( nId > nCompareId )
			*pIndex = (sal_uInt16)(nMid+1);
		else
			*pIndex = (sal_uInt16)nMid;
	}

	return ACCELENTRY_NOTFOUND;
}

// -----------------------------------------------------------------------

static void ImplAccelEntryInsert( ImplAccelList* pList, ImplAccelEntry* pEntry )
{
	sal_uInt16	nInsIndex;
	sal_uInt16	nIndex = ImplAccelEntryGetIndex( pList, pEntry->mnId, &nInsIndex );

	if ( nIndex != ACCELENTRY_NOTFOUND )
	{
		do
		{
			nIndex++;
			ImplAccelEntry* pTempEntry = pList->GetObject( nIndex );
			if ( !pTempEntry || (pTempEntry->mnId != pEntry->mnId) )
				break;
		}
		while ( nIndex < pList->Count() );

		pList->Insert( pEntry, (sal_uLong)nIndex );
	}
	else
		pList->Insert( pEntry, (sal_uLong)nInsIndex );
}

// -----------------------------------------------------------------------

static sal_uInt16 ImplAccelEntryGetFirstPos( ImplAccelList* pList, sal_uInt16 nId )
{
	sal_uInt16 nIndex = ImplAccelEntryGetIndex( pList, nId );
	if ( nIndex != ACCELENTRY_NOTFOUND )
	{
		while ( nIndex )
		{
			nIndex--;
			if ( pList->GetObject( nIndex )->mnId != nId )
				break;
		}

		if ( pList->GetObject( nIndex )->mnId != nId )
			nIndex++;
	}

	return nIndex;
}

// =======================================================================

void Accelerator::ImplInit()
{
	mnCurId 			= 0;
	mnCurRepeat 		= 0;
	mbIsCancel			= sal_False;
	mpDel				= NULL;
}

// -----------------------------------------------------------------------

ImplAccelEntry* Accelerator::ImplGetAccelData( const KeyCode& rKeyCode ) const
{
	return mpData->maKeyTable.Get( rKeyCode.GetFullKeyCode() );
}

// -----------------------------------------------------------------------

void Accelerator::ImplCopyData( ImplAccelData& rAccelData )
{
	// Tabellen kopieren
	ImplAccelEntry* pEntry = rAccelData.maIdList.First();
	while ( pEntry )
	{
		pEntry = new ImplAccelEntry( *pEntry );

		// Folge-Accelerator, dann auch kopieren
		if ( pEntry->mpAccel )
		{
			pEntry->mpAccel = new Accelerator( *(pEntry->mpAccel) );
			pEntry->mpAutoAccel = pEntry->mpAccel;
		}
		else
			pEntry->mpAutoAccel = NULL;

		mpData->maKeyTable.Insert( (sal_uLong)pEntry->maKeyCode.GetFullKeyCode(), pEntry );
		mpData->maIdList.Insert( pEntry, LIST_APPEND );

		pEntry = rAccelData.maIdList.Next();
	}
}

// -----------------------------------------------------------------------

void Accelerator::ImplDeleteData()
{
	// Accelerator-Eintraege ueber die Id-Tabelle loeschen
	ImplAccelEntry* pEntry = mpData->maIdList.First();
	while ( pEntry )
	{
		// AutoResAccel zerstoeren
		if ( pEntry->mpAutoAccel )
			delete pEntry->mpAutoAccel;
		delete pEntry;

		pEntry = mpData->maIdList.Next();
	}
}

// -----------------------------------------------------------------------

void Accelerator::ImplInsertAccel( sal_uInt16 nItemId, const KeyCode& rKeyCode,
								   sal_Bool bEnable, Accelerator* pAutoAccel )
{
	DBG_CHKTHIS( Accelerator, NULL );
	DBG_ASSERT( nItemId, "Accelerator::InsertItem(): ItemId == 0" );

	if ( rKeyCode.IsFunction() )
	{
		sal_uInt16 nCode1;
		sal_uInt16 nCode2;
		sal_uInt16 nCode3;
                sal_uInt16 nCode4;
		ImplGetKeyCode( rKeyCode.GetFunction(), nCode1, nCode2, nCode3, nCode4 );
		if ( nCode1 )
			ImplInsertAccel( nItemId, KeyCode( nCode1, nCode1 ), bEnable, pAutoAccel );
		if ( nCode2 )
		{
			if ( pAutoAccel )
				pAutoAccel = new Accelerator( *pAutoAccel );
			ImplInsertAccel( nItemId, KeyCode( nCode2, nCode2 ), bEnable, pAutoAccel );
			if ( nCode3 )
			{
				if ( pAutoAccel )
					pAutoAccel = new Accelerator( *pAutoAccel );
				ImplInsertAccel( nItemId, KeyCode( nCode3, nCode3 ), bEnable, pAutoAccel );
			}
		}
		return;
	}

	// Neuen Eintrag holen und fuellen
	ImplAccelEntry* pEntry	= new ImplAccelEntry;
	pEntry->mnId			= nItemId;
	pEntry->maKeyCode		= rKeyCode;
	pEntry->mpAccel 		= pAutoAccel;
	pEntry->mpAutoAccel 	= pAutoAccel;
	pEntry->mbEnabled		= bEnable;

	// Ab in die Tabellen
	sal_uLong nCode = rKeyCode.GetFullKeyCode();
	if ( !nCode )
	{
		DBG_ERROR( "Accelerator::InsertItem(): KeyCode with KeyCode 0 not allowed" );
		delete pEntry;
	}
	else if ( !mpData->maKeyTable.Insert( nCode, pEntry ) )
	{
		DBG_ERROR1( "Accelerator::InsertItem(): KeyCode (Key: %lx) already exists", nCode );
		delete pEntry;
	}
	else
		ImplAccelEntryInsert( &(mpData->maIdList), pEntry );
}

// -----------------------------------------------------------------------

Accelerator::Accelerator()
{
	DBG_CTOR( Accelerator, NULL );

	ImplInit();
	mpData = new ImplAccelData;
}

// -----------------------------------------------------------------------

Accelerator::Accelerator( const Accelerator& rAccel ) :
    Resource(),
	maHelpStr( rAccel.maHelpStr ),
	maCurKeyCode( rAccel.maCurKeyCode )
{
	DBG_CTOR( Accelerator, NULL );
	DBG_CHKOBJ( &rAccel, Accelerator, NULL );

	ImplInit();
	mpData = new ImplAccelData;
	ImplCopyData( *((ImplAccelData*)(rAccel.mpData)) );
}

// -----------------------------------------------------------------------

Accelerator::Accelerator( const ResId& rResId )
{
	DBG_CTOR( Accelerator, NULL );

	ImplInit();
	mpData = new ImplAccelData;
	rResId.SetRT( RSC_ACCEL );
	ImplLoadRes( rResId );
}

// -----------------------------------------------------------------------

void Accelerator::ImplLoadRes( const ResId& rResId )
{
	GetRes( rResId );

	maHelpStr = ReadStringRes();
	sal_uLong nObjFollows = ReadLongRes();

	for( sal_uLong i = 0; i < nObjFollows; i++ )
	{
		InsertItem( ResId( (RSHEADER_TYPE *)GetClassRes(), *rResId.GetResMgr() ) );
		IncrementRes( GetObjSizeRes( (RSHEADER_TYPE *)GetClassRes() ) );
	}
}

// -----------------------------------------------------------------------

Accelerator::~Accelerator()
{
	DBG_DTOR( Accelerator, NULL );

	// AccelManager benachrichtigen, das Accelrator geloescht wurde
	if ( mpDel )
		*mpDel = sal_True;

	ImplDeleteData();
	delete mpData;
}

// -----------------------------------------------------------------------

void Accelerator::Activate()
{
	maActivateHdl.Call( this );
}

// -----------------------------------------------------------------------

void Accelerator::Deactivate()
{
	maDeactivateHdl.Call( this );
}

// -----------------------------------------------------------------------

void Accelerator::Select()
{
	maSelectHdl.Call( this );
}

// -----------------------------------------------------------------------

void Accelerator::InsertItem( sal_uInt16 nItemId, const KeyCode& rKeyCode )
{
	ImplInsertAccel( nItemId, rKeyCode, sal_True, NULL );
}

// -----------------------------------------------------------------------

void Accelerator::InsertItem( const ResId& rResId )
{
	DBG_CHKTHIS( Accelerator, NULL );

	sal_uLong				nObjMask;
	sal_uInt16				nAccelKeyId;
	sal_uInt16				bDisable;
	KeyCode 			aKeyCode;
	Accelerator*		pAutoAccel	= NULL;

	GetRes( rResId.SetRT( RSC_ACCELITEM ) );
	nObjMask		= ReadLongRes();
	nAccelKeyId		= sal::static_int_cast<sal_uInt16>(ReadLongRes());
	bDisable		= ReadShortRes();

	if ( nObjMask & ACCELITEM_KEY )
	{
		// es wird ein neuer Kontext aufgespannt
		RSHEADER_TYPE * pKeyCodeRes = (RSHEADER_TYPE *)GetClassRes();
		ResId aResId( pKeyCodeRes, *rResId.GetResMgr());
		aKeyCode = KeyCode( aResId );
		IncrementRes( GetObjSizeRes( (RSHEADER_TYPE *)GetClassRes() ) );
	}

	if ( nObjMask & ACCELITEM_ACCEL )
	{
		pAutoAccel = new Accelerator( ResId( (RSHEADER_TYPE *)GetClassRes(), *rResId.GetResMgr() ) );
		IncrementRes( GetObjSizeRes( (RSHEADER_TYPE *)GetClassRes() ) );
	}

	ImplInsertAccel( nAccelKeyId, aKeyCode, !bDisable, pAutoAccel );
}

// -----------------------------------------------------------------------

void Accelerator::RemoveItem( sal_uInt16 nItemId )
{
	DBG_CHKTHIS( Accelerator, NULL );

	// Aus der Id-Liste entfernen
	sal_uInt16 nIndex = ImplAccelEntryGetFirstPos( &(mpData->maIdList), nItemId );
	if ( nIndex != ACCELENTRY_NOTFOUND )
	{
		sal_uInt16 nItemCount = GetItemCount();
		do
		{
			ImplAccelEntry* pEntry = mpData->maIdList.GetObject( (sal_uLong)nIndex );
            if ( pEntry && pEntry->mnId == nItemId )
			{
				mpData->maKeyTable.Remove( pEntry->maKeyCode.GetFullKeyCode() );
				mpData->maIdList.Remove( (sal_uLong)nIndex );

				// AutoResAccel zerstoeren
				if ( pEntry->mpAutoAccel )
					delete pEntry->mpAutoAccel;

				delete pEntry;
			}
			else
				break;
		}
		while ( nIndex < nItemCount );
	}
}

// -----------------------------------------------------------------------

void Accelerator::RemoveItem( const KeyCode rKeyCode )
{
	DBG_CHKTHIS( Accelerator, NULL );

	ImplAccelEntry* pEntry = ImplGetAccelData( rKeyCode );
	if ( pEntry )
	{
		// Aus der Id-Liste entfernen
		sal_uInt16 nIndex = ImplAccelEntryGetFirstPos( &(mpData->maIdList), pEntry->mnId );
		sal_uInt16 nItemCount = GetItemCount();
		do
		{
			if ( mpData->maIdList.GetObject( (sal_uLong)nIndex ) == pEntry )
				break;
			nIndex++;
		}
		while ( nIndex < nItemCount );

		mpData->maKeyTable.Remove( rKeyCode.GetFullKeyCode() );
		mpData->maIdList.Remove( (sal_uLong)nIndex );

		// AutoResAccel zerstoeren
		if ( pEntry->mpAutoAccel )
			delete pEntry->mpAutoAccel;

		delete pEntry;
	}
}

// -----------------------------------------------------------------------

void Accelerator::Clear()
{
	DBG_CHKTHIS( Accelerator, NULL );

	ImplDeleteData();
	mpData->maKeyTable.Clear();
	mpData->maIdList.Clear();
}

// -----------------------------------------------------------------------

sal_uInt16 Accelerator::GetItemCount() const
{
	DBG_CHKTHIS( Accelerator, NULL );

	return (sal_uInt16)mpData->maIdList.Count();
}

// -----------------------------------------------------------------------

sal_uInt16 Accelerator::GetItemId( sal_uInt16 nPos ) const
{
	DBG_CHKTHIS( Accelerator, NULL );

	ImplAccelEntry* pEntry = mpData->maIdList.GetObject( (sal_uLong)nPos );
	if ( pEntry )
		return pEntry->mnId;
	else
		return 0;
}

// -----------------------------------------------------------------------

KeyCode Accelerator::GetItemKeyCode( sal_uInt16 nPos ) const
{
	DBG_CHKTHIS( Accelerator, NULL );

	ImplAccelEntry* pEntry = mpData->maIdList.GetObject( (sal_uLong)nPos );
	if ( pEntry )
		return pEntry->maKeyCode;
	else
		return KeyCode();
}

// -----------------------------------------------------------------------

sal_uInt16 Accelerator::GetItemId( const KeyCode& rKeyCode ) const
{
	DBG_CHKTHIS( Accelerator, NULL );

	ImplAccelEntry* pEntry = ImplGetAccelData( rKeyCode );
	if ( pEntry )
		return pEntry->mnId;
	else
		return 0;
}

// -----------------------------------------------------------------------

KeyCode Accelerator::GetKeyCode( sal_uInt16 nItemId ) const
{
	DBG_CHKTHIS( Accelerator, NULL );

	sal_uInt16 nIndex = ImplAccelEntryGetFirstPos( &(mpData->maIdList), nItemId );
	if ( nIndex != ACCELENTRY_NOTFOUND )
		return mpData->maIdList.GetObject( (sal_uLong)nIndex )->maKeyCode;
	else
		return KeyCode();
}

// -----------------------------------------------------------------------

sal_Bool Accelerator::IsIdValid( sal_uInt16 nItemId ) const
{
	DBG_CHKTHIS( Accelerator, NULL );

	sal_uInt16 nIndex = ImplAccelEntryGetIndex( &(mpData->maIdList), nItemId );
	return (nIndex != ACCELENTRY_NOTFOUND);
}

// -----------------------------------------------------------------------

sal_Bool Accelerator::IsKeyCodeValid( const KeyCode rKeyCode ) const
{
	DBG_CHKTHIS( Accelerator, NULL );

	ImplAccelEntry* pEntry = ImplGetAccelData( rKeyCode );
	return (pEntry != NULL);
}

// -----------------------------------------------------------------------

sal_Bool Accelerator::Call( const KeyCode& rKeyCode, sal_uInt16 nRepeat )
{
	DBG_CHKTHIS( Accelerator, NULL );

	ImplAccelEntry* pEntry = ImplGetAccelData( rKeyCode );
	if ( pEntry )
	{
		if ( pEntry->mbEnabled )
		{
			sal_Bool bDel = sal_False;
			mnCurId 		= pEntry->mnId;
			maCurKeyCode	= rKeyCode;
			mnCurRepeat 	= nRepeat;
			mpDel			= &bDel;
			Select();
			if ( !bDel )
			{
				mnCurId 		= 0;
				maCurKeyCode	= KeyCode();
				mnCurRepeat 	= 0;
			}

			return sal_True;
		}
	}

	return sal_False;
}

// -----------------------------------------------------------------------

void Accelerator::SetAccel( sal_uInt16 nItemId, Accelerator* pAccel )
{
	DBG_CHKTHIS( Accelerator, NULL );

	sal_uInt16 nIndex = ImplAccelEntryGetFirstPos( &(mpData->maIdList), nItemId );
	if ( nIndex != ACCELENTRY_NOTFOUND )
	{
		sal_uInt16 nItemCount = GetItemCount();
		do
		{
			ImplAccelEntry* pEntry = mpData->maIdList.GetObject( (sal_uLong)nIndex );
			if ( pEntry->mnId != nItemId )
				break;

			pEntry->mpAccel = pAccel;
			nIndex++;
		}
		while ( nIndex < nItemCount );
	}
}

// -----------------------------------------------------------------------

Accelerator* Accelerator::GetAccel( sal_uInt16 nItemId ) const
{
	DBG_CHKTHIS( Accelerator, NULL );

	sal_uInt16 nIndex = ImplAccelEntryGetIndex( &(mpData->maIdList), nItemId );
	if ( nIndex != ACCELENTRY_NOTFOUND )
		return mpData->maIdList.GetObject( (sal_uLong)nIndex )->mpAccel;
	else
		return NULL;
}

// -----------------------------------------------------------------------

void Accelerator::SetAccel( const KeyCode rKeyCode, Accelerator* pAccel )
{
	DBG_CHKTHIS( Accelerator, NULL );

	ImplAccelEntry* pEntry = ImplGetAccelData( rKeyCode );
	if ( pEntry )
		pEntry->mpAccel = pAccel;
}

// -----------------------------------------------------------------------

Accelerator* Accelerator::GetAccel( const KeyCode rKeyCode ) const
{
	DBG_CHKTHIS( Accelerator, NULL );

	ImplAccelEntry* pEntry = ImplGetAccelData( rKeyCode );
	if ( pEntry )
		return pEntry->mpAccel;
	else
		return NULL;
}

// -----------------------------------------------------------------------

void Accelerator::EnableItem( sal_uInt16 nItemId, sal_Bool bEnable )
{
	DBG_CHKTHIS( Accelerator, NULL );

	sal_uInt16 nIndex = ImplAccelEntryGetFirstPos( &(mpData->maIdList), nItemId );
	if ( nIndex != ACCELENTRY_NOTFOUND )
	{
		sal_uInt16 nItemCount = GetItemCount();
		do
		{
			ImplAccelEntry* pEntry = mpData->maIdList.GetObject( (sal_uLong)nIndex );
			if ( pEntry->mnId != nItemId )
				break;

			pEntry->mbEnabled = bEnable;
			nIndex++;
		}
		while ( nIndex < nItemCount );
	}
}

// -----------------------------------------------------------------------

sal_Bool Accelerator::IsItemEnabled( sal_uInt16 nItemId ) const
{
	DBG_CHKTHIS( Accelerator, NULL );

	sal_uInt16 nIndex = ImplAccelEntryGetIndex( &(mpData->maIdList), nItemId );
	if ( nIndex != ACCELENTRY_NOTFOUND )
		return mpData->maIdList.GetObject( (sal_uLong)nIndex )->mbEnabled;
	else
		return sal_False;
}

// -----------------------------------------------------------------------

void Accelerator::EnableItem( const KeyCode rKeyCode, sal_Bool bEnable )
{
	DBG_CHKTHIS( Accelerator, NULL );

	ImplAccelEntry* pEntry = ImplGetAccelData( rKeyCode );
	if ( pEntry )
		pEntry->mbEnabled = bEnable;
}

// -----------------------------------------------------------------------

sal_Bool Accelerator::IsItemEnabled( const KeyCode rKeyCode ) const
{
	DBG_CHKTHIS( Accelerator, NULL );

	ImplAccelEntry* pEntry = ImplGetAccelData( rKeyCode );
	if ( pEntry )
		return pEntry->mbEnabled;
	else
		return sal_False;
}

// -----------------------------------------------------------------------

Accelerator& Accelerator::operator=( const Accelerator& rAccel )
{
	DBG_CHKTHIS( Accelerator, NULL );
	DBG_CHKOBJ( &rAccel, Accelerator, NULL );

	// Neue Daten zuweisen
	maHelpStr		= rAccel.maHelpStr;
	maCurKeyCode	= KeyCode();
	mnCurId 		= 0;
	mnCurRepeat 	= 0;
	mbIsCancel		= sal_False;

	// Tabellen loeschen und kopieren
	ImplDeleteData();
	mpData->maKeyTable.Clear();
	mpData->maIdList.Clear();
	ImplCopyData( *((ImplAccelData*)(rAccel.mpData)) );

	return *this;
}