diff --git a/kcms/keyboard/kcm_view_models.cpp b/kcms/keyboard/kcm_view_models.cpp
index 931a3ede2..a6584f026 100644
--- a/kcms/keyboard/kcm_view_models.cpp
+++ b/kcms/keyboard/kcm_view_models.cpp
@@ -1,521 +1,521 @@
 /*
  *  Copyright (C) 2010 Andriy Rysin (rysin@kde.org)
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 #include "kcm_view_models.h"
 
 #include <klocalizedstring.h>
 #include <kkeysequencewidget.h>
 
 #include <QTreeView>
 #include <QComboBox>
 #include <QLineEdit>
 #include <QPainter>
 #include <QKeySequence>
 
 #ifdef DRAG_ENABLED
 #include <QMimeData>
 #endif
 
 #include "keyboard_config.h"
 #include "xkb_rules.h"
 #include "flags.h"
 #include "x11_helper.h"
 #include "bindings.h"
 
 const int LayoutsTableModel::MAP_COLUMN = 0;
 const int LayoutsTableModel::LAYOUT_COLUMN = 1;
 const int LayoutsTableModel::VARIANT_COLUMN = 2;
 const int LayoutsTableModel::DISPLAY_NAME_COLUMN = 3;
 const int LayoutsTableModel::SHORTCUT_COLUMN = 4;
 static const int COLUMN_COUNT = 5;
 
 LayoutsTableModel::LayoutsTableModel(Rules* rules_, Flags *flags_, KeyboardConfig* keyboardConfig_, QObject* parent):
 	QAbstractTableModel(parent),
 	keyboardConfig(keyboardConfig_),
 	rules(rules_),
 	countryFlags(flags_)
 {
 }
 
 void LayoutsTableModel::refresh()
 {
 	beginResetModel();
 	endResetModel();
 
 	countryFlags->clearCache();
 }
 
 int LayoutsTableModel::rowCount(const QModelIndex &/*parent*/) const
 {
 	return keyboardConfig->layouts.count();
 }
 
 int LayoutsTableModel::columnCount(const QModelIndex&) const
 {
 	return COLUMN_COUNT;
 }
 
 Qt::ItemFlags LayoutsTableModel::flags(const QModelIndex &index) const
 {
 	if (!index.isValid())
 		return Qt::ItemFlags();
 
 	Qt::ItemFlags flags = QAbstractTableModel::flags(index);
 
 	if( index.column() == DISPLAY_NAME_COLUMN
 			|| index.column() == VARIANT_COLUMN
 			|| index.column() == SHORTCUT_COLUMN ) {
 		flags |= Qt::ItemIsEditable;
 	}
 
 #ifdef DRAG_ENABLED
 	flags |= Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
 #endif
 
 	return flags;
 }
 
 #ifdef DRAG_ENABLED
 QStringList LayoutsTableModel::mimeTypes() const
 {
     QStringList types;
     types << "application/keyboard-layout-item";
     return types;
 }
 
 QMimeData *LayoutsTableModel::mimeData(const QModelIndexList &indexes) const
  {
      QMimeData *mimeData = new QMimeData();
      QByteArray encodedData;
 
      QDataStream stream(&encodedData, QIODevice::WriteOnly);
 
      QSet<int> rows;
      foreach (const QModelIndex& index, indexes) {
     	 if (index.isValid()) {
     		 rows << index.row();
     	 }
      }
      foreach (int row, rows) {
     	 stream << row;
      }
 
      mimeData->setData("application/keyboard-layout-item", encodedData);
      return mimeData;
 }
 #endif
 
 QVariant LayoutsTableModel::data(const QModelIndex &index, int role) const
 {
      if (!index.isValid())
          return QVariant();
 
      if (index.row() >= keyboardConfig->layouts.size())
          return QVariant();
 
      const LayoutUnit& layoutUnit = keyboardConfig->layouts.at(index.row());
 
      if (role == Qt::DecorationRole) {
     	 switch( index.column() ) {
     	 case DISPLAY_NAME_COLUMN: {
 //    			if( keyboardConfig->isFlagShown() ) {
     				QIcon icon = countryFlags->getIconWithText(layoutUnit, *keyboardConfig);
     				return icon.isNull() ? countryFlags->getTransparentPixmap() : icon;
 //    			}
     	 }
 //TODO: show the cells are editable
 //    	 case VARIANT_COLUMN: {
 //    	 case DISPLAY_NAME_COLUMN: {
 //    		 int sz = 5;
 //    		 QPixmap pm = QPixmap(sz, sz+5);
 //    		 pm.fill(Qt::transparent);
 //    		 QPainter p(&pm);
 //    		 QPoint points[] = { QPoint(0, 0), QPoint(0, sz), QPoint(sz, 0) };
 //    		 p.drawPolygon(points, 3);
 //    		 return pm;
 //    	 }
     	 break;
     	 }
      }
      else
      if( role == Qt::BackgroundRole ) {
     	 if( keyboardConfig->layoutLoopCount != KeyboardConfig::NO_LOOPING
     			 && index.row() >= keyboardConfig->layoutLoopCount ) {
     		 return QBrush(Qt::lightGray);
     	 }
      }
      else
      if (role == Qt::DisplayRole) {
     	 switch( index.column() ) {
     	 case MAP_COLUMN:
     		 return layoutUnit.layout;
     	 break;
     	 case LAYOUT_COLUMN: {
     		 const LayoutInfo* layoutInfo = rules->getLayoutInfo(layoutUnit.layout);
              return layoutInfo != nullptr ? layoutInfo->description : layoutUnit.layout;
     	 }
     	 case VARIANT_COLUMN: {
     		 if( layoutUnit.variant.isEmpty() )
     			 return QVariant();
     		 const LayoutInfo* layoutInfo = rules->getLayoutInfo(layoutUnit.layout);
     		 if( layoutInfo == nullptr )
     			 return QVariant();
     		 const VariantInfo* variantInfo = layoutInfo->getVariantInfo(layoutUnit.variant);
     		 return variantInfo != nullptr ? variantInfo->description : layoutUnit.variant;
     	 }
          break;
     	 case DISPLAY_NAME_COLUMN:
 // 			if( keyboardConfig->indicatorType == KeyboardConfig::SHOW_LABEL ) {
 // 				return layoutUnit.getDisplayName();
 // 			}
     	 break;
     	 case SHORTCUT_COLUMN: {
     		return layoutUnit.getShortcut().toString();
     	 }
     	 break;
     	 }
      }
      else if (role==Qt::EditRole ) {
     	 switch( index.column() ) {
     	 case DISPLAY_NAME_COLUMN:
     		 return layoutUnit.getDisplayName();
     	 break;
     	 case VARIANT_COLUMN:
     		 return layoutUnit.variant;
     	 break;
     	 case SHORTCUT_COLUMN:
     		 return layoutUnit.getShortcut().toString();
     	 break;
     	 default:;
     	 }
      }
      else if( role == Qt::TextAlignmentRole ) {
     	 switch( index.column() ) {
     	 case MAP_COLUMN:
     	 case DISPLAY_NAME_COLUMN:
     	 case SHORTCUT_COLUMN:
     		 return Qt::AlignCenter;
     	 break;
     	 default:;
     	 }
      }
      return QVariant();
 }
 
 QVariant LayoutsTableModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
      if (role != Qt::DisplayRole)
          return QVariant();
 
      if (orientation == Qt::Horizontal) {
     	 const QString headers[] = {i18nc("layout map name", "Map"), i18n("Layout"), i18n("Variant"), i18n("Label"), i18n("Shortcut")};
          return headers[section];
      }
 
      return QVariant();
 }
 
 bool LayoutsTableModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
 	if (role != Qt::EditRole
 			|| (index.column() != DISPLAY_NAME_COLUMN && index.column() != VARIANT_COLUMN && index.column() != SHORTCUT_COLUMN) )
 		return false;
 
 	if (index.row() >= keyboardConfig->layouts.size() || index.data(role) == value)
 		return false;
 
 	LayoutUnit& layoutUnit = keyboardConfig->layouts[index.row()];
 
 	switch( index.column() ) {
 	case DISPLAY_NAME_COLUMN: {
 		QString displayText = value.toString().left(3);
 		layoutUnit.setDisplayName(displayText);
 		countryFlags->clearCache();	// regenerate the label
 	}
 	break;
 	case VARIANT_COLUMN: {
 		QString variant = value.toString();
 		layoutUnit.variant = variant;
 	}
 	break;
 	case SHORTCUT_COLUMN: {
 		QString shortcut = value.toString();
 		layoutUnit.setShortcut(QKeySequence(shortcut));
 	}
 	break;
 	}
 	emit dataChanged(index, index);
 
 	return true;
 }
 
 //
 // LabelEditDelegate
 //
 LabelEditDelegate::LabelEditDelegate(const KeyboardConfig* keyboardConfig_, QObject *parent):
 	QStyledItemDelegate(parent),
 	keyboardConfig(keyboardConfig_)
 {}
 
 QWidget *LabelEditDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem & option ,
 		const QModelIndex & index ) const
 {
 	if( keyboardConfig->indicatorType == KeyboardConfig::SHOW_FLAG )
 		return nullptr;
 
 	QWidget* widget = QStyledItemDelegate::createEditor(parent, option, index);
 	QLineEdit* lineEdit = static_cast<QLineEdit*>(widget);
 	if( lineEdit != nullptr ) {
 		lineEdit->setMaxLength(LayoutUnit::MAX_LABEL_LENGTH);
 		connect(lineEdit, &QLineEdit::textEdited, this, [this, lineEdit]() {
 			Q_EMIT const_cast<LabelEditDelegate*>(this)->commitData(lineEdit);
 		});
 	}
 	return widget;
 }
 
 void LabelEditDelegate::updateEditorGeometry(QWidget *editor,
 		const QStyleOptionViewItem &option, const QModelIndex &/* index */) const
 {
 	editor->setGeometry(option.rect);
 }
 
 //void LabelEditDelegate::paint( QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) const
 //{
 //	QStyleOptionViewItem option2(option);
 ////	option2.decorationPosition =  QStyleOptionViewItem::Right;
 //	option2.decorationAlignment = Qt::AlignHCenter | Qt::AlignVCenter;
 //	QStyledItemDelegate::paint(painter, option2, index);
 //}
 
 
 //
 // VariantComboDelegate
 //
 //TODO: reuse this function in kcm_add_layout_dialog.cpp
 static void populateComboWithVariants(QComboBox* combo, const QString& layout, const Rules* rules)
 {
 	combo->clear();
 	const LayoutInfo* layoutInfo = rules->getLayoutInfo(layout);
     foreach(const VariantInfo* variantInfo, layoutInfo->variantInfos) {
     	combo->addItem(variantInfo->description, variantInfo->name);
     }
     combo->model()->sort(0);
     combo->insertItem(0, i18nc("variant", "Default"), "");
     combo->setCurrentIndex(0);
 }
 
 VariantComboDelegate::VariantComboDelegate(const KeyboardConfig* keyboardConfig_, const Rules* rules_, QObject *parent):
 	QStyledItemDelegate(parent),
 	keyboardConfig(keyboardConfig_),
 	rules(rules_)
 {}
 
 QWidget *VariantComboDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &/* option */,
 		const QModelIndex & index ) const
 {
 	QComboBox *editor = new QComboBox(parent);
 	const LayoutUnit& layoutUnit = keyboardConfig->layouts[index.row()];
 	populateComboWithVariants(editor, layoutUnit.layout, rules);
 	connect(editor, &QComboBox::currentTextChanged, this, [this, editor]() {
 		Q_EMIT const_cast<VariantComboDelegate*>(this)->commitData(editor);
 	});
 	return editor;
 }
 
 void VariantComboDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
 {
 	QComboBox *combo = static_cast<QComboBox*>(editor);
 	QString variant = index.model()->data(index, Qt::EditRole).toString();
 	int itemIndex = combo->findData(variant);
 	if( itemIndex == -1 ) {
 		itemIndex = 0;
 	}
 	combo->setCurrentIndex(itemIndex);
 }
 
 void VariantComboDelegate::setModelData(QWidget *editor, QAbstractItemModel *model,
 		const QModelIndex &index) const
 {
 	QComboBox *combo = static_cast<QComboBox*>(editor);
 	QString variant = combo->itemData(combo->currentIndex()).toString();
 	model->setData(index, variant, Qt::EditRole);
 }
 
 void VariantComboDelegate::updateEditorGeometry(QWidget *editor,
 		const QStyleOptionViewItem &option, const QModelIndex &/* index */) const
 {
 	editor->setGeometry(option.rect);
 }
 
 //
 // KKeySequenceWidgetDelegate
 //
 KKeySequenceWidgetDelegate::KKeySequenceWidgetDelegate(const KeyboardConfig* keyboardConfig_, QObject *parent):
 	QStyledItemDelegate(parent),
 	keyboardConfig(keyboardConfig_)
 {}
 
 QWidget *KKeySequenceWidgetDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem & /*option*/,
 		const QModelIndex & index ) const
 {
 	itemsBeingEdited.insert(index);
 
 	KKeySequenceWidget *editor = new KKeySequenceWidget(parent);
     editor->setFocusPolicy(Qt::StrongFocus);
     editor->setModifierlessAllowed(false);
 
     const LayoutUnit& layoutUnit = keyboardConfig->layouts[index.row()];
 	editor->setKeySequence(layoutUnit.getShortcut());
 
 	editor->captureKeySequence();
 	connect(editor, &KKeySequenceWidget::keySequenceChanged, this, [this, editor]() {
 		Q_EMIT const_cast<KKeySequenceWidgetDelegate*>(this)->commitData(editor);
 	});
 
 	return editor;
 }
 
 //void KKeySequenceWidgetDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
 //{
 //	KKeySequenceWidget *kkeysequencewidget = static_cast<KKeySequenceWidget*>(editor);
 //	QString shortcut = index.model()->data(index, Qt::EditRole).toString();
 //	kkeysequencewidget->setKeySequence(QKeySequence(shortcut));
 //	kkeysequencewidget->captureKeySequence();
 //	qDebug() << "set editor data";
 //}
 
 void KKeySequenceWidgetDelegate::setModelData(QWidget *editor, QAbstractItemModel *model,
 		const QModelIndex &index) const
 {
 	KKeySequenceWidget *kkeysequencewidget = static_cast<KKeySequenceWidget*>(editor);
 	QString shortcut = kkeysequencewidget->keySequence().toString();
 	model->setData(index, shortcut, Qt::EditRole);
 	itemsBeingEdited.remove(index);
 }
 
 void KKeySequenceWidgetDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option,
                                     const QModelIndex& index) const
 {
       if (itemsBeingEdited.contains(index)) {
 //    	  StyledBackgroundPainter::drawBackground(painter,option,index);
       }
       else {
     	  QStyledItemDelegate::paint(painter,option,index);
       }
 }
 //
 // Xkb Options Tree View
 //
 
 int XkbOptionsTreeModel::rowCount(const QModelIndex& parent) const {
     if( ! parent.isValid() )
         return rules->optionGroupInfos.count();
     if( ! parent.parent().isValid() )
         return rules->optionGroupInfos[parent.row()]->optionInfos.count();
     return 0;
 }
 
 QVariant XkbOptionsTreeModel::data(const QModelIndex& index, int role) const
 {
     if (!index.isValid())
         return QVariant();
 
     int row = index.row();
 
     if (role == Qt::DisplayRole) {
         if( ! index.parent().isValid() ) {
             return rules->optionGroupInfos[row]->description;
         }
         else {
             int groupRow = index.parent().row();
             const OptionGroupInfo* xkbGroup = rules->optionGroupInfos[groupRow];
             return xkbGroup->optionInfos[row]->description;
         }
     }
     else if (role==Qt::CheckStateRole ) {
     	if( index.parent().isValid() ) {
     		int groupRow = index.parent().row();
     		const OptionGroupInfo* xkbGroup = rules->optionGroupInfos[groupRow];
     		const QString& xkbOptionName = xkbGroup->optionInfos[row]->name;
     		return keyboardConfig->xkbOptions.indexOf(xkbOptionName) == -1
     				? Qt::Unchecked : Qt::Checked;
     	}
     	else {
     		int groupRow = index.row();
     		const OptionGroupInfo* xkbGroup = rules->optionGroupInfos[groupRow];
     		foreach(const OptionInfo* optionInfo, xkbGroup->optionInfos) {
     			if( keyboardConfig->xkbOptions.indexOf(optionInfo->name) != -1 )
     				return Qt::PartiallyChecked;
     		}
 			return Qt::Unchecked;
     	}
     }
     return QVariant();
 }
 
 bool XkbOptionsTreeModel::setData(const QModelIndex & index, const QVariant & value, int role) {
     int groupRow = index.parent().row();
     if( groupRow < 0 ) return false;
 
     const OptionGroupInfo* xkbGroup = rules->optionGroupInfos[groupRow];
     const OptionInfo* option = xkbGroup->optionInfos[index.row()];
 
     if( value.toInt() == Qt::Checked ) {
         if( xkbGroup->exclusive ) {
             // clear if exclusive (TODO: radiobutton)
             int idx = keyboardConfig->xkbOptions.indexOf(QRegExp(xkbGroup->name + ".*"));
             if( idx >= 0 ) {
                 for(int i=0; i<xkbGroup->optionInfos.count(); i++)
                     if( xkbGroup->optionInfos[i]->name == keyboardConfig->xkbOptions[idx] ) {
-                        setData(createIndex(i, index.column(), (quint32)index.internalId()-index.row()+i), Qt::Unchecked, role);
+                        setData(createIndex(i, index.column(), static_cast<quint32>(index.internalId()) - index.row() + i), Qt::Unchecked, role);
                         break;
                     }
             //    m_kxkbConfig->m_options.removeAt(idx);
             //    idx = m_kxkbConfig->m_options.indexOf(QRegExp(xkbGroupNm+".*"));
             }
         }
         if( keyboardConfig->xkbOptions.indexOf(option->name) < 0 ) {
             keyboardConfig->xkbOptions.append(option->name);
         }
     }
     else {
         keyboardConfig->xkbOptions.removeAll(option->name);
     }
 
     emit dataChanged(index, index);
     emit dataChanged(index.parent(), index.parent());
     return true;
 }
 
 void XkbOptionsTreeModel::gotoGroup(const QString& groupName, QTreeView* view) {
 	const OptionGroupInfo* optionGroupInfo = rules->getOptionGroupInfo(groupName);
-    int index = rules->optionGroupInfos.indexOf((OptionGroupInfo*)optionGroupInfo);
+    int index = rules->optionGroupInfos.indexOf(const_cast<OptionGroupInfo*>(optionGroupInfo));
     if( index != -1 ) {
         QModelIndex modelIdx = createIndex(index,0);
 //            view->selectionModel()->setCurrentIndex(createIndex(index,0), QItemSelectionModel::NoUpdate);
         view->setExpanded(modelIdx, true);
         view->scrollTo(modelIdx, QAbstractItemView::PositionAtTop);
         view->selectionModel()->setCurrentIndex(modelIdx, QItemSelectionModel::Current);
         view->setFocus(Qt::OtherFocusReason);
     }
 //    else {
 //        qDebug() << "can't scroll to group" << group;
 //    }
 }
 
diff --git a/kcms/keyboard/x11_helper.cpp b/kcms/keyboard/x11_helper.cpp
index 1cd088a0c..bd60313b0 100644
--- a/kcms/keyboard/x11_helper.cpp
+++ b/kcms/keyboard/x11_helper.cpp
@@ -1,447 +1,447 @@
 /*
  *  Copyright (C) 2010 Andriy Rysin (rysin@kde.org)
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 #include "x11_helper.h"
 #include "debug.h"
 
 #include <QX11Info>
 #include <QCoreApplication>
 #include <QDebug>
 
 #include <X11/X.h>
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
 #include <X11/XKBlib.h>
 #include <X11/extensions/XKBrules.h>
 
 #include <fixx11h.h>
 
 // more information about the limit https://bugs.freedesktop.org/show_bug.cgi?id=19501
 const int X11Helper::MAX_GROUP_COUNT = 4;
 const int X11Helper::ARTIFICIAL_GROUP_LIMIT_COUNT = 8;
 
 const char X11Helper::LEFT_VARIANT_STR[] = "(";
 const char X11Helper::RIGHT_VARIANT_STR[] = ")";
 
 bool X11Helper::xkbSupported(int* xkbOpcode)
 {
     if (!QX11Info::isPlatformX11()) {
         return false;
     }
     // Verify the Xlib has matching XKB extension.
 
     int major = XkbMajorVersion;
     int minor = XkbMinorVersion;
 
     if (!XkbLibraryVersion(&major, &minor))
     {
         qCWarning(KCM_KEYBOARD) << "Xlib XKB extension " << major << '.' << minor <<
             " != " << XkbMajorVersion << '.' << XkbMinorVersion;
         return false;
     }
 
     // Verify the X server has matching XKB extension.
 
     int opcode_rtrn;
     int error_rtrn;
     int xkb_opcode;
     if( ! XkbQueryExtension(QX11Info::display(), &opcode_rtrn, &xkb_opcode, &error_rtrn, &major, &minor)) {
         qCWarning(KCM_KEYBOARD) << "X server XKB extension " << major << '.' << minor <<
             " != " << XkbMajorVersion << '.' << XkbMinorVersion;
         return false;
     }
 
     if( xkbOpcode != nullptr ) {
     	*xkbOpcode = xkb_opcode;
     }
 
     return true;
 }
 
 void X11Helper::switchToNextLayout()
 {
 	int size = getLayoutsList().size();	//TODO: could optimize a bit as we don't need the layouts - just count
 	int group = (X11Helper::getGroup() + 1) % size;
 	X11Helper::setGroup(group);
 }
 
 void X11Helper::scrollLayouts(int delta)
 {
 	int size = getLayoutsList().size();	//TODO: could optimize a bit as we don't need the layouts - just count
 	int group = X11Helper::getGroup() + delta;
 	group = group < 0 ? size - ((-group) % size) : group % size;
 
 	X11Helper::setGroup(group);
 }
 
 QStringList X11Helper::getLayoutsListAsString(const QList<LayoutUnit>& layoutsList)
 {
 	QStringList stringList;
 	foreach(const LayoutUnit& layoutUnit, layoutsList) {
 		stringList << layoutUnit.toString();
 	}
 	return stringList;
 }
 
 bool X11Helper::setLayout(const LayoutUnit& layout)
 {
 	QList<LayoutUnit> currentLayouts = getLayoutsList();
 	int idx = currentLayouts.indexOf(layout);
 	if( idx == -1 || idx >= X11Helper::MAX_GROUP_COUNT ) {
 		qCWarning(KCM_KEYBOARD) << "Layout" << layout.toString() << "is not found in current layout list"
 								<< getLayoutsListAsString(currentLayouts);
 		return false;
 	}
 
 	return X11Helper::setGroup((unsigned int)idx);
 }
 
 bool X11Helper::setDefaultLayout() {
 	return X11Helper::setGroup(0);
 }
 
 bool X11Helper::isDefaultLayout() {
 	return X11Helper::getGroup() == 0;
 }
 
 LayoutUnit X11Helper::getCurrentLayout()
 {
     if (!QX11Info::isPlatformX11()) {
         return LayoutUnit();
     }
     QList<LayoutUnit> currentLayouts = getLayoutsList();
     unsigned int group = X11Helper::getGroup();
-    if( group < (unsigned int)currentLayouts.size() )
-        return currentLayouts.at(group);
+    if( group < static_cast<unsigned int>(currentLayouts.size()) )
+        return currentLayouts.at(static_cast<int>(group));
 
     qCWarning(KCM_KEYBOARD) << "Current group number" << group << "is outside of current layout list" <<
                                getLayoutsListAsString(currentLayouts);
     return LayoutUnit();
 }
 
 LayoutSet X11Helper::getCurrentLayouts()
 {
 	LayoutSet layoutSet;
 
 	QList<LayoutUnit> currentLayouts = getLayoutsList();
 	layoutSet.layouts = currentLayouts;
 
 	unsigned int group = X11Helper::getGroup();
 	if( group < (unsigned int)currentLayouts.size() ) {
 		layoutSet.currentLayout = currentLayouts[group];
 	}
 	else {
 		qCWarning(KCM_KEYBOARD) << "Current group number" << group << "is outside of current layout list" << getLayoutsListAsString(currentLayouts);
 		layoutSet.currentLayout = LayoutUnit();
 	}
 
 	return layoutSet;
 }
 
 
 //static QString addNum(const QString& str, int n)
 //{
 //    QString format("%1%2");
 //    if( str.length() >= 3 ) return format.arg(str.left(2)).arg(n);
 //    return format.arg(str).arg(n);
 //}
 
 QList<LayoutUnit> X11Helper::getLayoutsList()
 {
     if (!QX11Info::isPlatformX11()) {
         return QList<LayoutUnit>();
     }
 	XkbConfig xkbConfig;
 	QList<LayoutUnit> layouts;
 	if( X11Helper::getGroupNames(QX11Info::display(), &xkbConfig, X11Helper::LAYOUTS_ONLY) ) {
 		for(int i=0; i<xkbConfig.layouts.size(); i++) {
 			QString layout(xkbConfig.layouts[i]);
 			QString variant;
 			if( i<xkbConfig.variants.size() && ! xkbConfig.variants[i].isEmpty() ) {
 				variant = xkbConfig.variants[i];
 			}
 			layouts << LayoutUnit(layout, variant);
 		}
 		// if there are layouts with same map name add numbers to display name
 //		for(int i=0; i<layouts.length(); i++) {
 //			int n=1;
 //			for(int j=i+1; j<layouts.length(); j++) {
 //				if( layouts[i].layout == layouts[j].layout && layouts[i].getRawDisplayName().isEmpty() ) {
 //					layouts[i].setDisplayName( addNum(layouts[i].layout, 1) );
 //					layouts[j].setDisplayName( addNum(layouts[j].layout, ++n) );
 //					qCDebug(KCM_KEYBOARD) << "Adding" << 1 << "to" << layouts[i].toString();
 //					qCDebug(KCM_KEYBOARD) << "Adding" << n << "to" << layouts[j].toString();
 //				}
 //			}
 //		}
 	}
 	else {
 		qCWarning(KCM_KEYBOARD) << "Failed to get layout groups from X server";
 	}
 	return layouts;
 }
 
 bool X11Helper::setGroup(unsigned int group)
 {
     qCDebug(KCM_KEYBOARD) << group;
     xcb_void_cookie_t cookie;
     cookie = xcb_xkb_latch_lock_state(QX11Info::connection(),
         XCB_XKB_ID_USE_CORE_KBD,
         0, 0,
         1,
         group,
         0, 0, 0
     );
     xcb_generic_error_t *error = nullptr;
     error = xcb_request_check(QX11Info::connection(), cookie);
     if (error) {
         qCDebug(KCM_KEYBOARD) << "Couldn't change the group" << error->error_code;
         return false;
     }
 
     return true;
 }
 
 unsigned int X11Helper::getGroup()
 {
 	XkbStateRec xkbState;
 	XkbGetState( QX11Info::display(), XkbUseCoreKbd, &xkbState );
 	return xkbState.group;
 }
 
 bool X11Helper::getGroupNames(Display* display, XkbConfig* xkbConfig, FetchType fetchType)
 {
 	static const char OPTIONS_SEPARATOR[] = ",";
 
 	Atom real_prop_type;
 	int fmt;
 	unsigned long nitems, extra_bytes;
 	char *prop_data = nullptr;
 	Status ret;
 
 	Atom rules_atom = XInternAtom(display, _XKB_RF_NAMES_PROP_ATOM, False);
 
 	/* no such atom! */
 	if (rules_atom == None) {       /* property cannot exist */
 		qCWarning(KCM_KEYBOARD) << "Failed to fetch layouts from server:" << "could not find the atom" << _XKB_RF_NAMES_PROP_ATOM;
 		return false;
 	}
 
 	ret = XGetWindowProperty(display,
 			DefaultRootWindow(display),
 			rules_atom, 0L, _XKB_RF_NAMES_PROP_MAXLEN,
 			False, XA_STRING, &real_prop_type, &fmt,
 			&nitems, &extra_bytes,
 			(unsigned char **) (void *) &prop_data);
 
 	/* property not found! */
 	if (ret != Success) {
 		qCWarning(KCM_KEYBOARD) << "Failed to fetch layouts from server:" << "Could not get the property";
 		return false;
 	}
 
 	/* has to be array of strings */
 	if ((extra_bytes > 0) || (real_prop_type != XA_STRING) || (fmt != 8)) {
 		if (prop_data)
 			XFree(prop_data);
 		qCWarning(KCM_KEYBOARD) << "Failed to fetch layouts from server:" << "Wrong property format";
 		return false;
 	}
 
 //	qCDebug(KCM_KEYBOARD) << "prop_data:" << nitems << prop_data;
 	QStringList names;
 	for(char* p=prop_data; p-prop_data < (long)nitems && p != nullptr; p += strlen(p)+1) {
 		names.append( p );
 //		qDebug() << " " << p;
 	}
 
 	if( names.count() < 4 ) { //{ rules, model, layouts, variants, options }
 		XFree(prop_data);
 		return false;
 	}
 
 	if( fetchType == ALL || fetchType == LAYOUTS_ONLY ) {
 		QStringList layouts = names[2].split(OPTIONS_SEPARATOR);
 		QStringList variants = names[3].split(OPTIONS_SEPARATOR);
 
 		for(int ii=0; ii<layouts.count(); ii++) {
 			xkbConfig->layouts << (layouts[ii] != nullptr ? layouts[ii] : QLatin1String(""));
 			xkbConfig->variants << (ii < variants.count() && variants[ii] != nullptr ? variants[ii] : QLatin1String(""));
 		}
 		qCDebug(KCM_KEYBOARD) << "Fetched layout groups from X server:"
 				<< "\tlayouts:" << xkbConfig->layouts
 				<< "\tvariants:" << xkbConfig->variants;
 	}
 
 	if( fetchType == ALL || fetchType == MODEL_ONLY ) {
 		xkbConfig->keyboardModel = (names[1] != nullptr ? names[1] : QLatin1String(""));
 		qCDebug(KCM_KEYBOARD) << "Fetched keyboard model from X server:" << xkbConfig->keyboardModel;
 	}
 
 	if( fetchType == ALL ) {
 		if( names.count() >= 5 ) {
 			QString options = (names[4] != nullptr ? names[4] : QLatin1String(""));
 			xkbConfig->options = options.split(OPTIONS_SEPARATOR);
 			qCDebug(KCM_KEYBOARD) << "Fetched xkbOptions from X server:" << options;
 		}
 	}
 
 	XFree(prop_data);
 	return true;
 }
 
 XEventNotifier::XEventNotifier():
 		xkbOpcode(-1)
 {
 	if( QCoreApplication::instance() == nullptr ) {
 		qCWarning(KCM_KEYBOARD) << "Layout Widget won't work properly without QCoreApplication instance";
 	}
 }
 
 void XEventNotifier::start()
 {
 	qCDebug(KCM_KEYBOARD) << "qCoreApp" << QCoreApplication::instance();
 	if( QCoreApplication::instance() != nullptr && X11Helper::xkbSupported(&xkbOpcode) ) {
 		registerForXkbEvents(QX11Info::display());
 
 		// start the event loop
 		QCoreApplication::instance()->installNativeEventFilter(this);
 	}
 }
 
 void XEventNotifier::stop()
 {
 	if( QCoreApplication::instance() != nullptr ) {
 		//TODO: unregister
 	//    XEventNotifier::unregisterForXkbEvents(QX11Info::display());
 
 		// stop the event loop
 		QCoreApplication::instance()->removeNativeEventFilter(this);
 	}
 }
 
 
 bool XEventNotifier::isXkbEvent(xcb_generic_event_t* event)
 {
 //	qDebug() << "event response type:" << (event->response_type & ~0x80) << xkbOpcode << ((event->response_type & ~0x80) == xkbOpcode + XkbEventCode);
     return (event->response_type & ~0x80) == xkbOpcode + XkbEventCode;
 }
 
 bool XEventNotifier::processOtherEvents(xcb_generic_event_t* /*event*/)
 {
 	return true;
 }
 
 bool XEventNotifier::processXkbEvents(xcb_generic_event_t* event)
 {
 	_xkb_event *xkbevt = reinterpret_cast<_xkb_event *>(event);
 	if( XEventNotifier::isGroupSwitchEvent(xkbevt) ) {
 //		qDebug() << "group switch event";
 		emit(layoutChanged());
 	}
 	else if( XEventNotifier::isLayoutSwitchEvent(xkbevt) ) {
 //		qDebug() << "layout switch event";
 		emit(layoutMapChanged());
 	}
 	return true;
 }
 
 bool XEventNotifier::nativeEventFilter(const QByteArray &eventType, void *message, long *)
 {
 //	qDebug() << "event type:" << eventType;
     if (eventType == "xcb_generic_event_t") {
         xcb_generic_event_t* ev = static_cast<xcb_generic_event_t *>(message);
         if( isXkbEvent(ev) ) {
     		processXkbEvents(ev);
     	}
     	else {
     		processOtherEvents(ev);
     	}
     }
     return false;
 }
 
 //bool XEventNotifier::x11Event(XEvent * event)
 //{
 //	//    qApp->x11ProcessEvent ( event );
 //	if( isXkbEvent(event) ) {
 //		processXkbEvents(event);
 //	}
 //	else {
 //		processOtherEvents(event);
 //	}
 //	return QWidget::x11Event(event);
 //}
 
 bool XEventNotifier::isGroupSwitchEvent(_xkb_event* xkbEvent)
 {
 //    XkbEvent *xkbEvent = (XkbEvent*) event;
 #define GROUP_CHANGE_MASK \
     ( XkbGroupStateMask | XkbGroupBaseMask | XkbGroupLatchMask | XkbGroupLockMask )
 
     return xkbEvent->any.xkbType == XkbStateNotify && (xkbEvent->state_notify.changed & GROUP_CHANGE_MASK);
 }
 
 bool XEventNotifier::isLayoutSwitchEvent(_xkb_event* xkbEvent)
 {
 //    XkbEvent *xkbEvent = (XkbEvent*) event;
 
     return //( (xkbEvent->any.xkb_type == XkbMapNotify) && (xkbEvent->map.changed & XkbKeySymsMask) ) ||
 /*    	  || ( (xkbEvent->any.xkb_type == XkbNamesNotify) && (xkbEvent->names.changed & XkbGroupNamesMask) || )*/
     	   (xkbEvent->any.xkbType == XkbNewKeyboardNotify);
 }
 
 int XEventNotifier::registerForXkbEvents(Display* display)
 {
     int eventMask = XkbNewKeyboardNotifyMask | XkbStateNotifyMask;
     if( ! XkbSelectEvents(display, XkbUseCoreKbd, eventMask, eventMask) ) {
     	qCWarning(KCM_KEYBOARD) << "Couldn't select desired XKB events";
     	return false;
     }
     return true;
 }
 
 
 static const char LAYOUT_VARIANT_SEPARATOR_PREFIX[] = "(";
 static const char LAYOUT_VARIANT_SEPARATOR_SUFFIX[] = ")";
 
 static QString& stripVariantName(QString& variant)
 {
 	if( variant.endsWith(LAYOUT_VARIANT_SEPARATOR_SUFFIX) ) {
 		int suffixLen = strlen(LAYOUT_VARIANT_SEPARATOR_SUFFIX);
 		return variant.remove(variant.length()-suffixLen, suffixLen);
 	}
 	return variant;
 }
 
 LayoutUnit::LayoutUnit(const QString& fullLayoutName)
 {
 	QStringList lv = fullLayoutName.split(LAYOUT_VARIANT_SEPARATOR_PREFIX);
 	layout = lv[0];
 	variant = lv.size() > 1 ? stripVariantName(lv[1]) : QLatin1String("");
 }
 
 QString LayoutUnit::toString() const
 {
 	if( variant.isEmpty() )
 		return layout;
 
 	return layout + LAYOUT_VARIANT_SEPARATOR_PREFIX+variant+LAYOUT_VARIANT_SEPARATOR_SUFFIX;
 }
 
 const int LayoutUnit::MAX_LABEL_LENGTH = 3;