kkeydialog.cpp

PIXIL is a small footprint operating environment, complete with PDA PIM applications, a browser and

{
	//debug("KKeyChooser::readStdKeys()");
	
	stdDict->clear();
	
	
	// Insert all standard keys into globalDict
	int *keyCode;
	KConfig pConfig;
	KEntryIterator *sIt = pConfig.entryIterator( i18n("Keys") );
	if (sIt){
	  sIt->toFirst();
	  while ( sIt->current() ) {
	    keyCode = new int;
	    *keyCode = stringToKey( sIt->current()->aValue );
	    stdDict->insert( sIt->currentKey(), keyCode);
	    ++(*sIt);
	  }
	}
	
	// Only insert std keys which don't appear in the dictionary to be configured
	aIt->toFirst();
	while ( aIt->current() ) {
		if ( stdDict->find( aIt->currentKey() ) ) {
		  stdDict->remove( aIt->currentKey());
		}
		++ ( *aIt );
	}
	
}

void KKeyChooser::toChange( int index )
{
	bKeyIntercept = FALSE;
	
	/* get the entry */
	aIt->toFirst();
	(*aIt) += wList->getId(index);

	sEntryKey = aIt->currentKey();
	pEntry = aIt->current();
	
	//eKey->setEnabled( FALSE );
	
	/* Is the key configurable or has the user turned it off ? */
	if ( !pEntry->bConfigurable || kbMode == NoKey ) {
		lInfo->setEnabled( FALSE );
		cShift->setEnabled( FALSE ); cCtrl->setEnabled( FALSE ); cAlt->setEnabled( FALSE );
		bChange->setEnabled( FALSE );  //bDefault->setEnabled( FALSE );
		lNotConfig->setEnabled( TRUE );
		
		uint kCode = pEntry->aConfigKeyCode;
		uint kSCode = kCode & ~(SHIFT | CTRL | ALT);
		
		if ( kSCode == Key_Shift ) cShift->setChecked(FALSE);
		else cShift->setChecked( kCode & SHIFT );
		if ( kSCode == Key_Control ) cCtrl->setChecked(FALSE);
		else cCtrl->setChecked( kCode & CTRL );
		if ( kSCode == Key_Alt ) cAlt->setChecked(FALSE);
		else cAlt->setChecked( kCode & ALT );
		
		QString str = keyToString( kSCode );
		bChange->setText(str);
		
	} else {
		lNotConfig->setEnabled( FALSE );
		lInfo->setText(""); lInfo->setEnabled( TRUE );
		
		uint kCode = pEntry->aConfigKeyCode;
		uint kSCode = kCode & ~(SHIFT | CTRL | ALT);
		
		//cShift->setEnabled( TRUE ); cCtrl->setEnabled( TRUE ); cAlt->setEnabled( TRUE );
		if ( kSCode == Key_Shift ) cShift->setChecked(FALSE);
		else cShift->setChecked( kCode & SHIFT );
		if ( kSCode == Key_Control ) cCtrl->setChecked(FALSE);
		else cCtrl->setChecked( kCode & CTRL );
		if ( kSCode == Key_Alt ) cAlt->setChecked(FALSE);
		else cAlt->setChecked( kCode & ALT );
		
		QString str = keyToString( kSCode );
		bChange->setText(str); //eKey->setText(str);
		//bChange->setEnabled( TRUE ); //bDefault->setEnabled( TRUE );
		
		if ( isKeyPresent() ) {
			lInfo->setText(i18n("Attention : key already used") );
		}
		
		if ( kbMode == DefaultKey ) {
			cAlt->setEnabled( false );
			cShift->setEnabled( false );
			cCtrl->setEnabled( false );
			bChange->setEnabled( false );
		} else {
			cAlt->setEnabled( true );
			cShift->setEnabled( true );
			cCtrl->setEnabled( true );
			bChange->setEnabled( true );
		}
	}
		
	((QRadioButton *)kbGroup->find(NoKey))->setChecked( kbMode == NoKey );
	((QRadioButton *)kbGroup->find(DefaultKey))->setChecked( kbMode == DefaultKey );
	((QRadioButton *)kbGroup->find(CustomKey))->setChecked( kbMode == CustomKey );
	
	if ( !pEntry->bConfigurable ) {
		cAlt->setEnabled( false );
		cShift->setEnabled( false );
		cCtrl->setEnabled( false );
		bChange->setEnabled( false );
		((QRadioButton *)kbGroup->find(NoKey))->setEnabled( false );
		((QRadioButton *)kbGroup->find(DefaultKey))->setEnabled( false );
		((QRadioButton *)kbGroup->find(CustomKey))->setEnabled( false );
	} else {
		((QRadioButton *)kbGroup->find(NoKey))->setEnabled( true );
		((QRadioButton *)kbGroup->find(DefaultKey))->setEnabled( pEntry->aDefaultKeyCode != 0);
		((QRadioButton *)kbGroup->find(CustomKey))->setEnabled( true );
	}	
}

void KKeyChooser::fontChange( const QFont & )
{
	actLabel->setFixedHeight( actLabel->sizeHint().height() );
	keyLabel->setFixedHeight( keyLabel->sizeHint().height() );

	cAlt->setFixedHeight( bChange->sizeHint().height() );
	cShift->setFixedHeight( bChange->sizeHint().height() );
	cCtrl->setFixedHeight( bChange->sizeHint().height() );
	
	fCArea->setMinimumHeight( 4*bChange->sizeHint().height() );
	
	int widget_width = 0;
	
	setMinimumWidth( 20+5*(widget_width+10) );
}

void KKeyChooser::keyMode( int m )
{
	kbMode = m;
	switch( kbMode ) {
		case NoKey:
			noKey();
			break;
		case DefaultKey:
			defaultKey();
			break;
		case CustomKey: default:
			toChange( wList->currentItem() );
			break;
	}
}

void KKeyChooser::noKey()
{
  if (!pEntry)
    return;
	pEntry->aConfigKeyCode = 0;
	
	/* update the list and the change area */
	
	KSplitListItem *sli = new KSplitListItem(
		 item(pEntry->aConfigKeyCode, pEntry->descr),
		 wList->getId(wList->currentItem() )
	);
		
	//connect( wList, SIGNAL( newWidth( int ) ),
	//		 	sli, SLOT( setWidth( int ) ) );
				
	sli->setWidth( wList->width() );
	
	if ( bChange->editing == TRUE ) bChange->setEdit(FALSE);

	wList->changeItem( sli, wList->currentItem()  );
	toChange(wList->currentItem());
	emit keyChange();
}

void KKeyChooser::defaultKey()
{
  if (!pEntry)
    return;
	/* change the configKeyCode */
	pEntry->aConfigKeyCode = pEntry->aDefaultKeyCode;
	
	/* update the list and the change area */
	
	KSplitListItem *sli = new KSplitListItem(
		 item(pEntry->aConfigKeyCode, pEntry->descr),
		 wList->getId(wList->currentItem())
	);
		
	//connect( wList, SIGNAL( newWidth( int ) ),
	//		 	sli, SLOT( setWidth( int ) ) );
				
	sli->setWidth( wList->width() );

	if ( bChange->editing == TRUE ) bChange->setEdit(FALSE);

	wList->changeItem( sli, wList->currentItem()  );
	toChange(wList->currentItem());
	emit keyChange();
}

void KKeyChooser::allDefault()
{
	// Change all configKeyCodes to default values
	
	//int idx = wList->currentItem();

	disconnect( wList, SIGNAL( highlighted( int ) ),
		this, SLOT( updateAction( int ) ) );
	wList->setAutoUpdate(FALSE);
	wList->clear();
	
	aIt->toFirst();
	int id = 0;
	while ( aIt->current() ) {
		if ( aIt->current()->bConfigurable )
			aIt->current()->aConfigKeyCode = aIt->current()->aDefaultKeyCode;
		
		KSplitListItem *sli = new KSplitListItem(
		 	item(aIt->current()->aConfigKeyCode, aIt->current()->descr),
			id);

		connect( wList, SIGNAL( newWidth( int ) ),
				 sli, SLOT( setWidth( int ) ) );
				
		sli->setWidth( wList->width() );
		
		wList->inSort( sli );
		
		++(*aIt);
		++id;
	}
	
	connect( wList, SIGNAL( highlighted( int ) ), SLOT( updateAction( int ) ) );
	wList->setAutoUpdate( true );
	wList->update();
	wList->setCurrentItem( 0 );
	emit keyChange();
}

void KKeyChooser::listSync()
{
	disconnect( wList, SIGNAL( highlighted( int ) ),
		this, SLOT( updateAction( int ) ) );
	wList->setAutoUpdate(FALSE);
	wList->clear();
	
	aIt->toFirst();
	int id = 0;
	while ( aIt->current() ) {
		
		KSplitListItem *sli = new KSplitListItem(
		 	item(aIt->current()->aCurrentKeyCode, aIt->current()->descr),
			id);

		connect( wList, SIGNAL( newWidth( int ) ),
				 sli, SLOT( setWidth( int ) ) );
				
		sli->setWidth( wList->width() );
		
		wList->inSort( sli );
		
		++(*aIt);
		++id;
	}
	
	connect( wList, SIGNAL( highlighted( int ) ), SLOT( updateAction( int ) ) );
	wList->setAutoUpdate( true );
	wList->update();
	wList->setCurrentItem( 0 );
}

#define MAX_FCTN_LENGTH 50

const QString KKeyChooser::item( uint keyCode, const QString& entryKey )
{
	QString str = entryKey;
	str = str.leftJustify(MAX_FCTN_LENGTH, ' ', TRUE);
	str += " : ";
	str += keyToString(keyCode, true);
	str = str.leftJustify( MAX_FCTN_LENGTH + 3 +
						   MAX_KEY_LENGTH+MAX_KEY_MODIFIER_LENGTH, ' ', TRUE );
	return str;
}

void KKeyChooser::shiftClicked()
{
  if (!pEntry)
    return;
	uint kSCode = pEntry->aConfigKeyCode & ~(SHIFT | CTRL | ALT);
	if ( kSCode != Key_Shift ) {
		if ( cShift->isOn() )
			pEntry->aConfigKeyCode |= SHIFT;
		else
			pEntry->aConfigKeyCode &= ~SHIFT;
			
		KSplitListItem *sli = new KSplitListItem(
		 	item(pEntry->aConfigKeyCode, pEntry->descr),
			wList->getId(wList->currentItem() )
		);
		
		connect( wList, SIGNAL( newWidth( int ) ),
				 sli, SLOT( setWidth( int ) ) );
				
					
		sli->setWidth( wList->width() );
		
		wList->changeItem( sli, wList->currentItem() );
	}
	toChange(wList->currentItem());
	emit keyChange();
}

void KKeyChooser::ctrlClicked()
{
  if (!pEntry)
    return;
	uint kSCode = pEntry->aConfigKeyCode & ~(SHIFT | CTRL | ALT);
	if ( kSCode != Key_Control ) {
		if ( cCtrl->isOn() )
			pEntry->aConfigKeyCode |= CTRL;
		else
			pEntry->aConfigKeyCode &= ~CTRL;
			
		KSplitListItem *sli = new KSplitListItem(
		 	item(pEntry->aConfigKeyCode, pEntry->descr),
			wList->getId(wList->currentItem() )
		);
		
		connect( wList, SIGNAL( newWidth( int ) ),
				 sli, SLOT( setWidth( int ) ) );
				
					
		sli->setWidth( wList->width() );
		
		wList->changeItem( sli, wList->currentItem() );
	}
	toChange(wList->currentItem());
	emit keyChange();
}

void KKeyChooser::altClicked()
{
  if (!pEntry)
    return;
	uint kSCode = pEntry->aConfigKeyCode & ~(SHIFT | CTRL | ALT);
	if ( kSCode != Key_Alt ) {
		if ( cAlt->isOn() )
			pEntry->aConfigKeyCode |= ALT;
		else
			pEntry->aConfigKeyCode &= ~ALT;
			
		KSplitListItem *sli = new KSplitListItem(
		 	item(pEntry->aConfigKeyCode, pEntry->descr),
			wList->getId(wList->currentItem() )
		);
		
		connect( wList, SIGNAL( newWidth( int ) ),
				 sli, SLOT( setWidth( int ) ) );
				
					
		sli->setWidth( wList->width() );
			
		wList->changeItem( sli, wList->currentItem() );
	}
	toChange(wList->currentItem());
	emit keyChange();
}

void KKeyChooser::changeKey()
{
	bChange->setEdit( TRUE );
	lInfo->setText( i18n("Press the wanted key") );
	lInfo->setEnabled( TRUE );
	/* give the focus to the widget */
	
	//eKey->setGeometry(bChange->x()+6, bChange->y()+4, bChange->width()-12,
		//bChange->height()-8);
	//eKey->show();
	//eKey->setEnabled(TRUE);
	setFocus();
	bKeyIntercept = TRUE;
}

void KKeyChooser::keyPressEvent( QKeyEvent *e )
{
	/* the keys are processed if the change button was pressed */
	if ( !bKeyIntercept )
		return;
	
	uint kCode = e->key() & ~(SHIFT | CTRL | ALT);
	/* check the given key :
	   if it is a non existent key (=0) : keep the old value and say
	   what happened. */
	if ( keyToString(kCode).isNull() ) {
		lInfo->setText( i18n("Undefined key") );
		return;
	}
	
	bKeyIntercept = FALSE;
	//eKey->hide();
	//eKey->setEnabled(FALSE);
	bChange->setEdit(FALSE);
	bChange->setFocus();
	setKey(kCode);
}

void KKeyChooser::setKey( uint kCode)
{
  if (!pEntry)
    return;
	// uint kOldCode = pEntry->aConfigKeyCode;
	
	/* add the current modifier to the key */
	if ( kCode!=Key_Shift ) kCode |= (pEntry->aConfigKeyCode & SHIFT);
	if ( kCode!=Key_Control ) kCode |= (pEntry->aConfigKeyCode & CTRL);
	if ( kCode!=Key_Alt ) kCode |= (pEntry->aConfigKeyCode & ALT);
	
	/* set the list and the change button */
	pEntry->aConfigKeyCode = kCode;
	
	if ( isKeyPresent() ) {
		lInfo->setText( i18n("Attention : key already used") );
		return;
	}
	
	KSplitListItem *sli = new KSplitListItem(
	 	item(pEntry->aConfigKeyCode, pEntry->descr),
		wList->getId(wList->currentItem() )
	);
		
	connect( wList, SIGNAL( newWidth( int ) ),
			 sli, SLOT( setWidth( int ) ) );
				
				
	sli->setWidth( wList->width() );
	
	wList->changeItem( sli, wList->currentItem() );
	toChange(wList->currentItem());
	emit keyChange();
}

void KKeyChooser::editKey()
{
	bChange->setEnabled( FALSE ); //eKey->setEnabled( TRUE );
	lInfo->setText( i18n("Return to end edition") );
}

void KKeyChooser::editEnd()
{
	debug("Called editEnd() which relies on eKey widget");
	
	//uint kCode = stringToKey(eKey->text());
	uint kCode = 0;
	if ( kCode==0 || (kCode & (SHIFT | CTRL | ALT)) ) {
		lInfo->setText( i18n("Incorrect key") );
		return;
	}
	setKey(kCode);
}

bool KKeyChooser::isKeyPresent()
{
  if (!pEntry->aConfigKeyCode)
    return false;
	// Search the global key codes to find if this keyCode is already used
	//  elsewhere
	
	QDictIterator<int> gIt( *globalDict );
	
	gIt.toFirst();
	while ( gIt.current() ) {
		//debug("current %s:%d code %d", gIt.currentKey(), *gIt.current(), pEntry->aConfigKeyCode);
		if ( (unsigned int)(*gIt.current()) == pEntry->aConfigKeyCode && *gIt.current() != 0 ) {
			QString actionName( gIt.currentKey() );
			actionName.stripWhiteSpace();

			QString keyName = keyToString( *gIt.current() );
			
			QString str;
			str.sprintf( i18n(
				"The %s key combination has already been allocated\nto the global %s action.\n\nPlease choose a unique key combination."),
				keyName.data(),
				actionName.data() );
				
			QMessageBox::warning( this, i18n("Global key conflict"), str.data() );
			
			return TRUE;
		}
		++gIt;
	}
	
	// Search the std key codes to find if this keyCode is already used
	//  elsewhere
	
	QDictIterator<int> sIt( *stdDict );

	sIt.toFirst();
	while ( sIt.current() ) {
		//debug("current %s:%d code %d", sIt.currentKey(), *sIt.current(), pEntry->aConfigKeyCode);
		if ( (unsigned int)(*sIt.current()) == pEntry->aConfigKeyCode && *sIt.current() != 0 ) {
			QString actionName( sIt.currentKey() );
			actionName.stripWhiteSpace();

			QString keyName = keyToString( *sIt.current() );
			
			QString str;
			str.sprintf( i18n(
				"The %s key combination has already been allocated\nto the standard %s action.\n\nPlease choose a unique key combination."),
				keyName.data(),
				actionName.data() );
				
			QMessageBox::warning( this, i18n("Standard key conflict"), str.data() );
			
			return TRUE;
		}
		++sIt;
	}

	// Search the aConfigKeyCodes to find if this keyCode is already used
	// elsewhere
	aIt->toFirst();
	while ( aIt->current() ) {
		if ( aIt->current() != pEntry
				&& aIt->current()->aConfigKeyCode == pEntry->aConfigKeyCode ) {
			QString actionName( aIt->currentKey() );
			actionName.stripWhiteSpace();

			QString keyName = keyToString( aIt->current()->aConfigKeyCode );
			
			QString str;
			str.sprintf( i18n(
				"The %s key combination has already been allocated\nto the %s action.\n\nPlease choose a unique key combination."),
				keyName.data(),
				actionName.data() );
				
			QMessageBox::warning( this, i18n("Key conflict"), str.data() );
			
			return TRUE;
		}
		++(*aIt);
	}
	
	//	emit keyChange();
	
	return FALSE;
}
#include "kkeydialog.moc"