void Setup_Input::apply()
{
keyUnresolved();
InputActionT key1;
InputActionT key2;
if (inputManager.hasConflicts(key1, key2))
{
const std::string str1 = keyToString(key1);
const std::string str2 = keyToString(key2);
CREATEWIDGET(OkDialog,
// TRANSLATORS: input settings error header
_("Key Conflict(s) Detected."),
// TRANSLATORS: input settings error
strprintf(_("Conflict \"%s\" and \"%s\" keys. "
"Resolve them, or gameplay may result in strange behaviour."),
gettext(str1.c_str()), gettext(str2.c_str())),
// TRANSLATORS: ok dialog button
_("OK"),
DialogType::ERROR,
Modal_true,
ShowCenter_true,
nullptr,
260);
}
keyboard.setEnabled(true);
inputManager.store();
}
bool KKeyChooser::isKeyPresent()
{
// 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 ( *gIt.current() == pEntry->aConfigKeyCode && *gIt.current() != 0 ) {
QString actionName( gIt.currentKey() );
actionName.stripWhiteSpace();
QString keyName = keyToString( *gIt.current() );
QString str;
str.sprintf(
"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, "Global key conflict", str.data() );
return TRUE;
}
++gIt;
}
// 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(
"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, "Key conflict", str.data() );
return TRUE;
}
++(*aIt);
}
emit keyChange();
return FALSE;
}
QString Keyboard::comboKeyToString(Keyboard::ComboKey key)
{
Keyboard::KeyboardModifiers modifiers = keyToModifiers(key.key);
modifiers = key.modifiers & (~modifiers);
QString result;
bool firstModifier = true;
if (modifiers & Win)
{
result += firstModifier ? QString("WIN") : QString("+WIN");
firstModifier = false;
}
if (modifiers & Ctrl)
{
result += firstModifier ? QString("CTRL") : QString("+CTRL");
firstModifier = false;
}
if (modifiers & Shift)
{
result += firstModifier ? QString("SHIFT") : QString("+SHIFT");
firstModifier = false;
}
if (modifiers & Alt)
{
result += firstModifier ? QString("ALT") : QString("+Alt");
firstModifier = false;
}
result += QString("+") + getKeyFullZhName(keyToString(key.key));
return result;
}
void KAccel::changeMenuAccel ( QPopupMenu *menu, int id,
const char *action )
{
QString s = menu->text( id );
if ( !s ) return;
if (!action) return;
int i = s.find('\t');
QString k = keyToString( currentKey( action), true );
if( !k ) return;
if ( i >= 0 )
s.replace( i+1, s.length()-i, k );
else {
s += '\t';
s += k;
}
QPixmap *pp = menu->pixmap(id);
if(pp && !pp->isNull())
menu->changeItem( *pp, s, id );
else
menu->changeItem( s, id );
}
//---------------------------------------------------------
// LMasterKeyEventItem
//! Initializes a LMasterKeyEventItem with a KeyEvent
//---------------------------------------------------------
LMasterKeyEventItem::LMasterKeyEventItem(QTreeWidget* parent, const MusECore::KeyEvent& ev)
: LMasterLViewItem(parent)
{
keyEvent = ev;
unsigned t = ev.tick;
int bar, beat;
unsigned tick;
MusEGlobal::sigmap.tickValues(t, &bar, &beat, &tick);
c1 = QString("%1.%2.%3")
.arg(bar + 1, 4, 10, QLatin1Char('0'))
.arg(beat + 1, 2, 10, QLatin1Char('0'))
.arg(tick, 3, 10, QLatin1Char('0'));
double time = double(MusEGlobal::tempomap.tick2frame(t)) / double(MusEGlobal::sampleRate);
int min = int(time) / 60;
int sec = int(time) % 60;
int msec = int((time - (min*60 + sec)) * 1000.0);
c2 = QString("%1:%2:%3")
.arg(min, 3, 10, QLatin1Char('0'))
.arg(sec, 2, 10, QLatin1Char('0'))
.arg(msec, 3, 10, QLatin1Char('0'));
c3 = "Key";
c4 = keyToString(ev.key);
setText(0, c1);
setText(1, c2);
setText(2, c3);
setText(3, c4);
}
void MainMenuState::updateKeysButtonsFromSettings()
{
for(int i = 0; i < 4; i++)
{
KeySettings::PlayerKeys& playerKeys = m_settingsManager.getKeySettings().getPlayerKeys(i);
strncpy(m_playersKeys[i][0], keyToString(playerKeys.leftKey).data(), 31);
m_playersKeys[i][0][31] = '\0';
strncpy(m_playersKeys[i][1], keyToString(playerKeys.rightKey).data(), 31);
m_playersKeys[i][1][31] = '\0';
strncpy(m_playersKeys[i][2], keyToString(playerKeys.jumpKey).data(), 31);
m_playersKeys[i][2][31] = '\0';
}
}
bool GnomeGrabber::Impl::removeAction(unsigned int action_id)
{
auto i = std::find(action_ids_.begin(), action_ids_.end(), action_id);
if (i != action_ids_.end())
{
auto j = actions_.begin() + (i - action_ids_.begin());
auto k = actions_by_action_id_.find(action_id);
LOG_DEBUG(logger) << "removeAction (" << action_id << " \"" << j->keyToString() << "\")";
if (screen_)
screen_->removeAction(&(*j));
if (k != actions_by_action_id_.end())
{
action_ids_by_action_.erase(k->second);
actions_by_action_id_.erase(k);
}
action_ids_.erase(i);
actions_.erase(j);
return true;
}
return false;
}
void KeyboardControllerLua::keyPressed(KeyAction action, Key key, KeyModifier modifier) {
lua_State* s = luaL_newstate();
luaL_openlibs(s);
int status = luaL_loadfile(s, absPath("${SCRIPTS}/default_keybinding.lua").c_str());
if (status != LUA_OK) {
LERROR("Error loading script: '" << lua_tostring(s, -1) << "'");
return;
}
if (lua_pcall(s, 0, LUA_MULTRET, 0)) {
LERROR("Error executing script: " << lua_tostring(s, -1));
return;
}
auto start = std::chrono::high_resolution_clock::now();
lua_getfield(s, -1, keyToString(key, modifier).c_str());
if (!lua_isnil(s, -1))
lua_pcall(s, 0, 0, 0);
else
LINFO("Key not found");
auto end = std::chrono::high_resolution_clock::now();
LINFO("Keyboard timing: " << std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count() << "ns");
}
bool ShortcutGetter::event(QEvent *e)
{
if (!capture) return QDialog::event(e);
QString key;
QStringList mods;
QKeyEvent *k = static_cast<QKeyEvent*>(e);
switch ( e->type() )
{
case QEvent::KeyPress :
if ( bStop )
{
lKeys.clear();
bStop = false;
}
key = keyToString(k->key());
mods = modToString(k->modifiers());
//qDebug("event: key.count: %d, mods.count: %d", key.count(), mods.count());
if ( key.count() || mods.count() )
{
if ( key.count() && !lKeys.contains(key) )
lKeys << key;
foreach ( key, mods )
if ( !lKeys.contains(key) )
lKeys << key;
} else {
key = k->text();
if ( !lKeys.contains(key) )
lKeys << key;
}
setText();
break;
case QEvent::KeyRelease :
bStop = true;
break;
/*
case QEvent::ShortcutOverride :
leKey->setText("Shortcut override");
break;
*/
default:
return QDialog::event(e);
break;
}
void cShortcut::updateVisibleName()
{
QString cmd = d->command;
if (cmd.isEmpty() && (!strVal ("script").isEmpty())) cmd = "(script)";
if (cmd.isEmpty())
cListObject::updateVisibleName();
setVisibleName (keyToString (d->key, d->modifiers) + " -> " + cmd);
}
bool InputManager::handleEvent(QEvent* event)
{
if (event->type() != QEvent::KeyPress && event->type() != QEvent::KeyRelease)
return false;
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
Qt::Key key = static_cast<Qt::Key>(keyEvent->key());
const char* keyCategory = NULL;
// NOTE: We can potentially get key presses on the device before
// com.palm.keys comes up, and these won't be broadcast to subscribers
// However, we assume that we wouldn't want them to receive a collection
// of queued up key presses
// Each subset of keys must not overlap in the current handling
if (isAudioKey(key)) {
keyCategory = CATEGORY_AUDIO;
} else if (isMediaKey(key)) {
keyCategory = CATEGORY_MEDIA;
} else if (isSwitch(key)) {
keyCategory = CATEGORY_SWITCHES;
} else if (isHeadsetKey(key)) {
if (!(key == KEYS::Key_Headset || key == KEYS::Key_HeadsetMic)) {
// state machine time -- headset button
headsetStateMachine(keyEvent);
}
keyCategory = CATEGORY_HEADSET;
} else if (isBluetoothKey(key)) {
handleBluetoothKey(keyEvent);
return true;
} else {
// Not a key that we care about, so we indicate we didn't handle it
return false;
}
// first event that comes in sets the sticky state, no matter
// whether it is a real action that a user did or a generated
// "InitialState"
static int switchInitCount = 0;
if (setKeyState(key, event->type())) {
if (NULL == m_publicService && (++switchInitCount == HostBase::instance()->getNumberOfSwitches() )) {
startService();
}
}
// We don't post the "InitialState" key because it is internally
// generated in order to get initial state of a key
if (!(keyEvent->nativeModifiers() & SysMgrNativeKeyboardModifier_InitialState)) {
const char* keyString = NULL;
keyToString(key, &keyString);
(void)postKeyToSubscribers(keyEvent, keyCategory, keyString, NULL);
}
return true;
}
const QString KKeyChooser::item( uint keyCode, const QString& entryKey )
{
QString str = entryKey;
str = str.leftJustify(MAX_FCTN_LENGTH, ' ', TRUE);
str += " : ";
str += keyToString(keyCode);
str = str.leftJustify( MAX_FCTN_LENGTH + 3 +
MAX_KEY_LENGTH+MAX_KEY_MODIFIER_LENGTH, ' ', TRUE );
return str;
}
void KGlobalAccel::writeSettings()
{
KConfig *pConfig = kapp->getConfig();
pConfig->setGroup( aGroup.data() );
QDictIterator<KKeyEntry> aKeyIt( aKeyDict );
aKeyIt.toFirst();
while ( aKeyIt.current() ) {
if ( aKeyIt.current()->bConfigurable )
if ( bGlobal )
pConfig->writeEntry( aKeyIt.currentKey(),
keyToString( aKeyIt.current()->aCurrentKeyCode ),
true, true );
else
pConfig->writeEntry( aKeyIt.currentKey(),
keyToString( aKeyIt.current()->aCurrentKeyCode ) );
++aKeyIt;
}
}
QDomElement SxeRecordEdit::xml(QDomDocument &doc) const {
QDomElement edit = doc.createElementNS(SXENS, "set");
edit.setAttribute("rid", rid_);
edit.setAttribute("version", version_);
foreach(Key key, changes_.keys())
edit.setAttribute(keyToString(key), changes_[key]);
return edit;
}
virtual void remove(const std::string& key)
{
DBT keyDBT;
keyDBT.data = (void*)key.c_str();
keyDBT.size = key.size();
if (db_->del(db_, &keyDBT, 0) == -1) {
RAISE_BENCHMARK_EXCEPTION("db_->del failed (%s): error=%u", keyToString(key), errno);
}
}
QVariant Settings::printerValue(const QString &printerId, Settings::Key key, const QVariant &defaultValue) const
{
QString keyStr = QString("Printer_%1/%2").arg(printerId, keyToString(key));
if (key == Printer_DuplexType)
{
QString s = value(keyStr, duplexTypetoStr(static_cast<DuplexType>(defaultValue.toInt()))).toString();
return strToDuplexType(s);
}
return value(keyStr, defaultValue);
}
void Settings::setPrinterValue(const QString &printerId, Key key, const QVariant &value)
{
QVariant v;
if (key == Printer_DuplexType)
{
v = duplexTypetoStr(static_cast<DuplexType>(value.toInt()));
}
else
v = value;
setValue(QString("Printer_%1/%2").arg(printerId, keyToString(key)), v);
}
uint keyToXSym( uint keyCode )
{
debug("keyToXSym");
char *toks[4], *next_tok;
int nb_toks = 0;
char sKey[200];
uint keysym = 0;
QString s = keyToString( keyCode );
s= s.lower();
strncpy(sKey, (const char *)s.data(), 200);
debug("Find key %s", sKey );
if ( s.isEmpty() ) return keysym;
next_tok = strtok( sKey, "+" );
if ( next_tok == NULL ) return 0;
do {
toks[nb_toks] = next_tok;
nb_toks++;
if ( nb_toks == 5 ) return 0;
next_tok = strtok( NULL, "+" );
} while ( next_tok != NULL );
// Test for exactly one key (other tokens are accelerators)
// Fill the keycode with infos
bool keyFound = FALSE;
for ( int i=0; i<nb_toks; i++ ) {
debug("%d", i);
if ( strcmp( toks[i], "shift" ) != 0 &&
strcmp( toks[i], "ctrl" ) != 0 &&
strcmp( toks[i], "alt" ) != 0 ) {
if ( keyFound ) return 0;
keyFound = TRUE;
keysym = XStringToKeysym( toks[i] );
debug("Key = %s, sym = %d", toks[i], keysym );
if ( keysym == NoSymbol ) {
debug("Keysym no symbol (%d)", NoSymbol);
return 0;
}
}
}
//debug("Return %d", keysym);
return keysym;
}
QString KeySequence::toString() const
{
QString result;
for (int i = 0; i < m_Sequence.size(); i++)
{
result += keyToString(m_Sequence[i]);
if (i != m_Sequence.size() - 1)
result += "+";
}
return result;
}
void MainMenuState::processEvent(sf::Event event, sf::RenderTarget &target)
{
if(event.type == sf::Event::MouseButtonPressed)
{
if(!m_draggingPlayer)
{
sf::Vector2f realCoords = target.mapPixelToCoords(
sf::Vector2i(event.mouseButton.x, event.mouseButton.y)
);
sf::FloatRect playerRect(
m_playerSprite.getPosition().x,
m_playerSprite.getPosition().y,
m_playerSprite.getScale().x,
m_playerSprite.getScale().y
);
if(playerRect.contains(realCoords))
{
m_draggingPlayer = true;
m_offsetToPlayer = sf::Vector2f(
realCoords.x - playerRect.left,
realCoords.y - playerRect.top
);
m_playerSprite.setCurrentAnimation("jump");
}
}
}
else if(event.type == sf::Event::MouseButtonReleased)
{
m_draggingPlayer = false;
}
else if(event.type == sf::Event::KeyPressed)
{
if(m_selectedKeyButton != nullptr)
{
if(event.key.code != sf::Keyboard::Escape)
{
strncpy(m_selectedKeyButton, keyToString(event.key.code).data(), 31);
m_selectedKeyButton[31] = '\0';
}
m_selectedKeyButton = nullptr;
updateSettingsFromKeysButtons();
updateKeysButtonsFromSettings();
}
}
}
virtual void checkedFetch(size_type number, const std::string& key, const std::string& expectedValue)
{
DBT keyDBT;
keyDBT.data = (void*)key.c_str();
keyDBT.size = key.size();
DBT retrievedValueDBT;
if (db_->get(db_, &keyDBT, &retrievedValueDBT, 0) == -1) {
RAISE_BENCHMARK_EXCEPTION("db_->get failed (number=%u, %s): error=%u", number, keyToString(key), errno);
}
boost::string_ref actualValue(static_cast<char*>(retrievedValueDBT.data), retrievedValueDBT.size);
if (expectedValue != actualValue) {
RAISE_BENCHMARK_EXCEPTION("unexpected value for key number %u", number);
}
}
void InputBox::setData(const unsigned id, const int value) {
data.id = id;
data.value = value;
if (value == KBD_VALUE) {
setText(keyToString(id));
} else if (value == NULL_VALUE) {
setText("");
} else {
QString str(SDL_JoystickName(data.dev_num));
str.append(' ');
switch (data.type) {
case SDL_JOYAXISMOTION:
str.append("Axis ");
str.append(QString::number(data.num));
str.append(' ');
str.append(data.value == AXIS_POSITIVE ? '+' : '-');
break;
case SDL_JOYHATMOTION:
str.append("Hat ");
str.append(QString::number(data.num));
str.append(' ');
if (data.value & SDL_HAT_UP)
str.append("Up");
if (data.value & SDL_HAT_DOWN)
str.append("Down");
if (data.value & SDL_HAT_LEFT)
str.append("Left");
if (data.value & SDL_HAT_RIGHT)
str.append("Right");
break;
case SDL_JOYBUTTONCHANGE:
str.append("Button ");
str.append(QString::number(data.num));
break;
}
setText(str);
}
}
std::string Boton::getRosalilaInputs()
{
if(usando_joystick)
{
if(joystick>=0)
return convertInt(joystick);
if(joystick==-8)
return std::string("up");
if(joystick==-2)
return std::string("down");
if(joystick==-4)
return std::string("left");
if(joystick==-6)
return std::string("right");
return std::string("d");
}else
{
return std::string(keyToString());
}
}
std::string Button::getRosalilaInputs()
{
if(uses_joystick)
{
if(joystick_button>=0)
return rosalila()->utility->toString(joystick_button);
if(joystick_button==-8)
return std::string("up");
if(joystick_button==-2)
return std::string("down");
if(joystick_button==-4)
return std::string("left");
if(joystick_button==-6)
return std::string("right");
return std::string("d");
}else
{
return std::string(keyToString());
}
}
stringw Boton::getInput()
{
if(usando_joystick)
{
if(joystick>=0)
return stringw(joystick);
if(joystick==-8)
return stringw("up");
if(joystick==-2)
return stringw("down");
if(joystick==-4)
return stringw("left");
if(joystick==-6)
return stringw("right");
return stringw("d");
}else
{
return stringw(keyToString());
}
}
void KeyboardNode::inputsUpdated( qint64 pTimeStamp )
{
Q_UNUSED( pTimeStamp )
fugio::KeyboardInterface *Keyboard = input<fugio::KeyboardInterface *>( mPinKeyboard );
if( !Keyboard )
{
return;
}
for( fugio::KeyboardEvent KeyEvt : Keyboard->keyboardEvents() )
{
const QString S = KeyEvt.mText;
const QString K = S.isEmpty() || KeyEvt.mCode == Qt::Key_Space ? keyToString( KeyEvt.mCode ) : S.toUpper();
QSharedPointer<fugio::PinInterface> P = mNode->findOutputPinByName( K );
if( P && P->hasControl() )
{
fugio::VariantInterface *V = qobject_cast<fugio::VariantInterface *>( P->control()->qobject() );
if( V )
{
V->setVariant( KeyEvt.mType == fugio::KeyboardEvent::PRESS );
pinUpdated( P );
}
}
else if( mListening )
{
QSharedPointer<fugio::PinInterface> NewPin;
mNode->createPin( K, PIN_OUTPUT, QUuid::createUuid(), NewPin, PID_BOOL );
mListening = false;
emit listening( false );
}
}
}
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);
}
//------------------------------------------------------------------------------
bool
WTextInput::handleKeyEvent(KEY key, bool state)
{
if(!hasFocus() || !state) return false;
if(this->cursor > this->text.size()) this->cursor = this->text.size();
if(key == KEY_BACKSPACE && this->cursor > 0)
{
this->text.erase(this->cursor-1, 1);
this->cursor--;
}
else if(key == KEY_DELETE && this->cursor < this->text.size())
{
this->text.erase(this->cursor, 1);
}
else if(key == KEY_LEFT && this->cursor > 0)
this->cursor--;
else if(key == KEY_RIGHT && this->cursor < this->text.size())
this->cursor++;
else if(key == KEY_END)
this->cursor = this->text.size();
else if(key == KEY_HOME)
this->cursor = 0;
else if(isReadable(key))
{
string t = keyToString(key);
if(kernel->inputMgr->isShiftOrCapsPressed())
boost::to_upper(t);
this->text.insert(this->cursor, t);
this->cursor += t.size();
}
this->render();
return true;
};
bool KeySequence::appendKey(int key, int modifiers)
{
if (m_Sequence.size() == 4)
return true;
switch(key)
{
case Qt::Key_AltGr:
return false;
case Qt::Key_Control:
case Qt::Key_Alt:
case Qt::Key_Shift:
case Qt::Key_Meta:
case Qt::Key_Menu:
{
int mod = modifiers & (~m_Modifiers);
if (mod)
{
m_Sequence.append(mod);
m_Modifiers |= mod;
}
}
break;
default:
// see if we can handle this key, if not, don't accept it
if (keyToString(key).isEmpty())
break;
m_Sequence.append(key);
setValid(true);
return true;
}
return false;
}
void KKeyChooser::toChange( int index )
{
bKeyIntercept = FALSE;
/* get the entry */
aIt->toFirst();
(*aIt) += 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( true );
((QRadioButton *)kbGroup->find(CustomKey))->setEnabled( true );
}
}
