Continues migration with DDS, Common

Lts/Common/LtsVirtualKeyboard/LtsVirtualKeyboard.cpp

@@ -0,0 +1,953 @@
+
+
+
+#include "LtsVirtualKeyboard.h"
+
+#include <LtsAppManager/lts_app_manager.h>
+
+#include <QApplication>
+#include <QClipboard>
+#include <QDesktopWidget>
+#include <QDoubleSpinBox>
+#include <QHBoxLayout>
+#include <QKeyEvent>
+#include <QLineEdit>
+#include <QPlainTextEdit>
+#include <QScreen>
+#include <QScrollArea>
+#include <QSpinBox>
+#include <QTextCursor>
+#include <QTimer>
+#include <QWindow>
+
+namespace LtsVirtualKeyboard
+{
+
+static LtsVirtualKeyboard *s_ltsVirtualKeyboard = nullptr;
+static bool lastState = false;
+LtsVirtualKeyboard::LtsVirtualKeyboard(LtsSession::LtsSession *session, QWidget *activeForm, bool onlyNumericPad, QWidget *parent)
+  : QWidget(parent)
+  
+  , m_te(nullptr)
+  , m_le(nullptr)
+  , m_nextInput(nullptr)
+  , m_activeWindow(activeForm)
+  , m_echoMode(false)
+  , m_enablePasswordEcho(false)
+  , m_numericPad(onlyNumericPad)
+  , m_isAlt(false)
+  , m_isCap(false)
+  , m_enableEnter(true)
+  , m_ready(false)
+  , m_height(0)
+  , m_clipboard(QApplication::clipboard())
+  , m_session(session)
+{
+  setWindowFlags(Qt::CustomizeWindowHint | Qt::WindowTitleHint | Qt::WindowStaysOnTopHint | Qt::Dialog);
+  setFocusPolicy(Qt::NoFocus);
+  
+  setWindowTitle(QString());
+  connect(m_activeWindow, &QWidget::destroyed,
+          this, [this](QObject *obj)
+  {
+    if (static_cast<QObject *>(m_activeWindow) == obj)
+      m_activeWindow = nullptr;
+  });
+}
+
+LtsVirtualKeyboard::~LtsVirtualKeyboard()
+{
+}
+
+LtsVirtualKeyboard *LtsVirtualKeyboard::getInstance(LtsSession::LtsSession *session, QWidget *activeForm, bool onlyNumericPad, QWidget *parent)
+{
+  onlyNumericPad = false;
+
+  
+  
+  if (s_ltsVirtualKeyboard && onlyNumericPad == lastState )
+  {
+    
+    if (activeForm)
+      s_ltsVirtualKeyboard->setActiveWindw(activeForm);
+    if (parent)
+      s_ltsVirtualKeyboard->setParent(parent);
+    s_ltsVirtualKeyboard->setSession(session);
+
+    return s_ltsVirtualKeyboard;
+  }
+  cleanupLtsVirtualKeyboard();
+  lastState = onlyNumericPad;
+  s_ltsVirtualKeyboard = new LtsVirtualKeyboard(session, activeForm, onlyNumericPad, parent);
+  s_ltsVirtualKeyboard->createKeyboard();
+  qAddPostRoutine(&cleanupLtsVirtualKeyboard);
+
+  return s_ltsVirtualKeyboard;
+}
+
+void LtsVirtualKeyboard::cleanupLtsVirtualKeyboard()
+{
+  delete s_ltsVirtualKeyboard;
+  s_ltsVirtualKeyboard = nullptr;
+}
+
+void LtsVirtualKeyboard::enableSwitchingEcho(bool status)
+{
+  m_enablePasswordEcho = status;
+}
+
+bool LtsVirtualKeyboard::isEnabledSwitchingEcho() const
+{
+  return (m_enablePasswordEcho);
+}
+
+LtsKeyPushButton *LtsVirtualKeyboard::createNewKey(const QString &keyValue, const QString &notTranslatedValue, const QString &notTranslatedValueAlt)
+{
+  QString altText = notTranslatedValueAlt;
+  if (altText.isEmpty())
+    altText = notTranslatedValue;
+  LtsKeyPushButton *tmp = new LtsKeyPushButton(notTranslatedValue, altText, this);
+  QString        style = QStringLiteral(DEFAULT_STYLE_BUTTON) + QStringLiteral(DEFAULT_BACKGROUND_BUTTON);
+  QSize          imageDim;
+  int            width = 0, height = 0;
+
+  imageDim.setWidth(32);
+  imageDim.setHeight(32);
+
+  if (IS_PASSWORD(keyValue) == true)
+  {
+    tmp->setIconSize(imageDim);
+    tmp->setIcon(QPixmap(QStringLiteral(":/TastieraVirtuale/normalEcho")));
+  }
+  else if (IS_PASTE(keyValue) == true)
+  {
+    tmp->setIconSize(imageDim);
+    tmp->setEnabled(false);
+    tmp->setIcon(QPixmap(QStringLiteral("icon:edit-paste.svg")));
+    tmp->setToolButtonStyle(Qt::ToolButtonIconOnly);
+  }
+  else if (IS_COPY(keyValue) == true)
+  {
+    tmp->setIconSize(imageDim);
+    tmp->setIcon(QPixmap(QStringLiteral("icon:edit-copy.svg")));
+    tmp->setToolButtonStyle(Qt::ToolButtonIconOnly);
+  }
+
+  else if (IS_CUT_LEFT(keyValue) == true)
+  {
+    tmp->setIconSize(imageDim);
+    tmp->setIcon(QPixmap(QStringLiteral("icon:edit-cut.svg")));
+    tmp->setToolButtonStyle(Qt::ToolButtonIconOnly);
+  }
+
+  else if (IS_CAPS(keyValue) == true)
+  {
+    tmp->setIconSize(imageDim);
+    tmp->setIcon(QPixmap(QStringLiteral("icon:shift_capslook.svg")));
+    tmp->setToolButtonStyle(Qt::ToolButtonIconOnly);
+  }
+
+  else if (IS_RETURN(keyValue) == true)
+  {
+    tmp->setIconSize(imageDim);
+    tmp->setIcon(QPixmap(QStringLiteral("icon:carriage_return.svg")));
+    tmp->setToolButtonStyle(Qt::ToolButtonIconOnly);
+  }
+
+  tmp->setStyleSheet(style);
+
+
+  width = 54;
+  height = 40;
+#ifdef TABLET_MODE
+  width = width * 2.0;
+  height = height * 2.0;
+#endif
+
+  tmp->setMinimumSize(width, height);
+  tmp->setMaximumSize(width, height);
+
+  if (IS_SPACE(keyValue) == true)
+  {
+    tmp->setMinimumSize(width * 20, height);
+    tmp->setMaximumSize(width * 20, height);
+  }
+
+  if (IS_FIN(keyValue) == true)
+  {
+    tmp->setStyleSheet(style + QStringLiteral(CHANGED_BACKGROUND_BUTTON));
+  }
+  tmp->setText(keyValue);
+  tmp->setCapsMode(m_isCap);
+
+
+  tmp->setObjectName(keyValue);
+
+  return tmp;
+}
+
+void LtsVirtualKeyboard::controlKeyEcho(QWidget *control)
+{
+  Q_UNUSED(control); 
+  QString         textToSearch;
+  LtsKeyPushButton  *echoControlKey;
+  QString         tmpStyle;
+  QPushButton     *pasteButton = findChild<QPushButton *>(KEY_PASTE);
+  QPushButton     *cutButton = findChild<QPushButton *>(KEY_CUT_LEFT);
+  QPushButton     *copyButton = findChild<QPushButton *>(KEY_COPY);
+
+  textToSearch = KEY_HIDECHAR;
+
+  if (pasteButton != nullptr && copyButton != nullptr)
+  {
+    cutButton->setEnabled(true);
+    copyButton->setEnabled(true);
+    if (m_clipboard->text().length() > 0)
+      pasteButton->setEnabled(true);
+    else
+      pasteButton->setEnabled(false);
+  }
+
+  echoControlKey = findChild<LtsKeyPushButton *>(textToSearch);
+  if (echoControlKey != nullptr)
+  {
+    echoControlKey->setStyleSheet(QStringLiteral(DEFAULT_STYLE_BUTTON) + QStringLiteral(DEFAULT_BACKGROUND_BUTTON) +  tmpStyle); 
+    echoControlKey->setIcon(QPixmap(QStringLiteral(":/TastieraVirtuale/normalEcho")));
+
+    echoControlKey->repaint();
+    QApplication::processEvents();
+  }
+}
+
+void LtsVirtualKeyboard::setTextToCurrentWidget(const QString &text)
+{
+
+
+  if (m_nextInput->inherits("QLineEdit"))
+    qobject_cast<QLineEdit *>(m_nextInput)->setText(text);
+
+  if (m_nextInput->inherits("QTextEdit"))
+    qobject_cast<QTextEdit *>(m_nextInput)->setText(text);
+
+  if (m_nextInput->inherits("QPlainTextEdit"))
+    qobject_cast<QPlainTextEdit *>(m_nextInput)->setPlainText(text);
+
+  if (m_nextInput->inherits("QSpinBox"))
+    qobject_cast<QSpinBox *>(m_nextInput)->setValue(text.toInt());
+
+  if (m_nextInput->inherits("QDoubleSpinBox"))
+    qobject_cast<QDoubleSpinBox *>(m_nextInput)->setValue(text.toDouble());
+}
+
+QString LtsVirtualKeyboard::getTextFromCurrentWidget()
+{
+  if (qobject_cast<QLineEdit *>(m_nextInput))
+    return qobject_cast<QLineEdit *>(m_nextInput)->text();
+
+  if (qobject_cast<QTextEdit *>(m_nextInput))
+    return qobject_cast<QTextEdit *>(m_nextInput)->toPlainText();
+  if (qobject_cast<QPlainTextEdit *>(m_nextInput))
+    return qobject_cast<QPlainTextEdit *>(m_nextInput)->toPlainText();
+  if (qobject_cast<QSpinBox *>(m_nextInput))
+    return QString::number(qobject_cast<QSpinBox *>(m_nextInput)->value());
+  if (qobject_cast<QDoubleSpinBox *>(m_nextInput))
+    return QString::number(qobject_cast<QDoubleSpinBox *>(m_nextInput)->value());
+  return QString();
+
+}
+
+QString LtsVirtualKeyboard::getCurretText() const
+{
+  if (m_te->isVisible())
+    return m_te->toPlainText();
+  return m_le->text();
+}
+
+void LtsVirtualKeyboard::setCurrentText(const QString &text)
+{
+  if(m_te->isVisible())
+    m_te->setText(text);
+  else
+    m_le->setText(text);
+}
+
+int LtsVirtualKeyboard::getCurrentTextCursorPosition()
+{
+  if(m_te->isVisible())
+    return m_te->textCursor().position();
+  return m_le->cursorPosition();
+}
+
+void LtsVirtualKeyboard::setCurrentTextCursorPosition(int cursor)
+{
+  if(m_te->isVisible())
+  {
+    QTextCursor cur = m_te->textCursor();
+    cur.setPosition(cursor);
+    m_te->setTextCursor(cur);
+  }else
+  {
+    m_le->setCursorPosition(cursor);
+  }
+
+}
+
+bool LtsVirtualKeyboard::hasSelection() const
+{
+  if(m_te->isVisible())
+    return m_te->textCursor().hasSelection();
+  return m_le->hasSelectedText();
+}
+
+QString LtsVirtualKeyboard::getSelectedText() const
+{
+  if (m_te->isVisible())
+    return m_te->textCursor().selectedText();
+  return m_le->selectedText();
+}
+
+int LtsVirtualKeyboard::getSelectionStart() const
+{
+  if (m_te->isVisible())
+    return m_te->textCursor().selectionStart();
+  return m_le->selectionStart();
+
+}
+
+void LtsVirtualKeyboard::reinit()
+{
+  qDeleteAll(findChildren<LtsKeyPushButton*>());
+  m_te->deleteLater();
+  m_le->deleteLater();
+  delete layout();
+  createKeyboard();
+}
+
+
+void LtsVirtualKeyboard::receiptChildKey(QWidget *focusThisControl, QKeyEvent *event, bool reset)
+{
+
+  if (!m_ready)
+    return;
+
+  if (reset == true)
+  {
+    m_nextInput = getNextTextbox(focusThisControl, true);
+    return;
+  }
+  if (m_nextInput == nullptr || !event)
+  {
+    return;
+  }
+  
+
+  QString newKey = event->text();
+  QString tmpReceiptString = getCurretText();
+  int     tmpPos = getCurrentTextCursorPosition();
+  if (isNumericPad())
+    newKey = newKey.trimmed();
+  if (NO_SPECIAL_KEY(newKey) == false)
+  {
+
+    if (IS_RETURN(newKey) == true)
+    {
+      tmpReceiptString = tmpReceiptString.insert(tmpPos, QChar(13));
+
+      setTextToCurrentWidget(tmpReceiptString);
+      setCurrentText(tmpReceiptString);
+      setCurrentTextCursorPosition(tmpPos+1);
+    }
+    else if (IS_FIN(newKey) == true)
+    {
+
+      hide(true);
+
+      
+      if (!qobject_cast<QTextEdit *>(m_nextInput) && !qobject_cast<QPlainTextEdit *>(m_nextInput))
+      {
+        QKeyEvent event(QEvent::KeyPress, Qt::Key_Enter, Qt::NoModifier);
+        QApplication::sendEvent(m_nextInput, &event);
+      }
+      m_nextInput->clearFocus();
+      m_nextInput = nullptr;
+
+      return;
+    }
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    else if (IS_BACK(newKey) == true)
+    {
+      if (!hasSelection())
+      {
+        tmpReceiptString = tmpReceiptString.remove(tmpPos - 1, 1);
+        setTextToCurrentWidget(tmpReceiptString);
+        setCurrentText(tmpReceiptString);
+        setCurrentTextCursorPosition(tmpPos-1);
+      }
+      else
+      {
+        if (tmpPos - 1 >= 0)
+        {
+          int selectionStart = getSelectionStart();
+          tmpReceiptString = tmpReceiptString.remove(selectionStart, getSelectedText().size());
+          setCurrentText(tmpReceiptString);
+          setCurrentTextCursorPosition(selectionStart);
+          setTextToCurrentWidget(tmpReceiptString);
+        }
+      }
+
+    }
+    else if (IS_CANC(newKey) == true)
+    {
+      tmpReceiptString = tmpReceiptString.remove(tmpPos, 1);
+      setTextToCurrentWidget(tmpReceiptString);
+      setCurrentText(tmpReceiptString);
+      setCurrentTextCursorPosition(tmpPos);
+    }
+    else if (IS_COPY(newKey) == true || IS_CUT_LEFT(newKey) == true)
+    {
+      LtsKeyPushButton *button = findChild<LtsKeyPushButton *>(KEY_PASTE);
+
+      if (button != nullptr)
+      {
+        if (hasSelection())
+        {
+          m_clipboard->setText(getSelectedText());
+
+          if (IS_CUT_LEFT(newKey) == true)
+          {
+            int selectionStart =getSelectionStart();
+            tmpReceiptString = tmpReceiptString.remove(selectionStart, getSelectedText().size());
+            setCurrentText(tmpReceiptString);
+
+            setCurrentTextCursorPosition(selectionStart);
+
+            setTextToCurrentWidget(tmpReceiptString);
+          }
+          button->setEnabled(true);
+        }
+        else
+          button->setEnabled(false);
+      }
+    }
+    else if (IS_PASTE(newKey) == true)
+    {
+      tmpReceiptString.insert(tmpPos, m_clipboard->text());
+      setTextToCurrentWidget(tmpReceiptString);
+      setCurrentText(tmpReceiptString);
+      setCurrentTextCursorPosition(tmpPos + m_clipboard->text().length());
+    }
+    else if (IS_ALT(newKey) == true || IS_ALT2(newKey) == true)
+    {
+      QList<LtsKeyPushButton *> kList = findChildren<LtsKeyPushButton *>();
+      m_isAlt = !m_isAlt;
+
+      auto i = kList.begin();
+
+      for (; i != kList.end(); ++i)
+      {
+        LtsKeyPushButton *tw = *i;
+        tw->setAltMode(m_isAlt);
+      }
+    }
+    else if (IS_CAPS(newKey) == true)
+    {
+      QList<LtsKeyPushButton *> kList = findChildren<LtsKeyPushButton *>();
+      m_isCap = !m_isCap;
+
+      auto i = kList.begin();
+
+      for (; i != kList.end(); ++i)
+      {
+        LtsKeyPushButton *tw = *i;
+        tw->setCapsMode(m_isCap);
+      }
+    }
+  }
+  else
+  {
+    if (getSelectedText().size())
+    {
+      tmpPos = getSelectionStart();
+      tmpReceiptString = tmpReceiptString.remove(tmpPos, getSelectedText().size());
+    }
+
+    tmpReceiptString = tmpReceiptString.insert(tmpPos, newKey);
+    setTextToCurrentWidget(tmpReceiptString);
+    setCurrentText(tmpReceiptString);
+    setCurrentTextCursorPosition(tmpPos + 1);
+  }
+}
+
+
+void LtsVirtualKeyboard::switchKeyEchoMode(QWidget *control)
+{
+  setStatusEchoMode(!statusEchoMode());
+  controlKeyEcho(control);
+}
+
+
+QWidget *LtsVirtualKeyboard::getNextTextbox(QWidget *thisControl, bool reset)
+{
+  QWidget *tmpInputFound = nullptr;
+  m_echoMode = false;
+  if (m_activeWindow == nullptr)
+  {
+    m_nextInput = nullptr;
+    return (nullptr);
+  }
+  if (thisControl != nullptr)
+  {
+    if (m_activeWindow->findChild<QLineEdit *>(thisControl->objectName()) == 0 &&
+        m_activeWindow->findChild<QTextEdit *>(thisControl->objectName()) == 0 &&
+        m_activeWindow->findChild<QPlainTextEdit *>(thisControl->objectName()) == 0 &&
+        m_activeWindow->findChild<QSpinBox *>(thisControl->objectName()) == 0 &&
+        m_activeWindow->findChild<QDoubleSpinBox *>(thisControl->objectName()) == 0)  
+    {
+      return (nullptr);
+    }
+    else 
+    {
+      return setCurrentTextStyle(thisControl);
+    }
+  }
+  if (m_nextInput == nullptr || reset == true)
+    m_nextInput = m_activeWindow->nextInFocusChain();
+  else
+    m_nextInput = m_nextInput->nextInFocusChain();
+  do
+  {
+    if (m_nextInput->inherits("QLineEdit") == true)
+    {
+      tmpInputFound = qobject_cast<QLineEdit *>(m_nextInput);
+      return setCurrentTextStyle(tmpInputFound);
+    }
+    if (m_nextInput->inherits("QTextEdit") == true)
+    {
+      tmpInputFound = qobject_cast<QTextEdit *>(m_nextInput);
+      return setCurrentTextStyle(tmpInputFound);
+    }
+    if (m_nextInput->inherits("QPlainTextEdit") == true)
+    {
+      tmpInputFound = qobject_cast<QPlainTextEdit *>(m_nextInput);
+      return setCurrentTextStyle(tmpInputFound);
+    }
+    if (m_nextInput->inherits("QSpinBox") == true)
+    {
+      tmpInputFound = qobject_cast<QSpinBox *>(m_nextInput);
+      return setCurrentTextStyle(tmpInputFound);
+    }
+    if (m_nextInput->inherits("QDoubleSpinBox") == true)
+    {
+      tmpInputFound = qobject_cast<QDoubleSpinBox *>(m_nextInput);
+      return setCurrentTextStyle(tmpInputFound);
+    }
+    m_nextInput = m_nextInput->nextInFocusChain();
+  }
+  while (m_nextInput != nullptr);
+  return nullptr;
+}
+
+
+QWidget *LtsVirtualKeyboard::setCurrentTextStyle(QWidget *control)
+{
+  m_nextInput = control;
+  control->setStyleSheet(QStringLiteral(STYLE_FOCUS_TEXT));
+  return (control);
+}
+
+QWidget *LtsVirtualKeyboard::setDefaultTextStyle(QWidget *control)
+{
+  if (!m_nextInput)
+    return nullptr;
+  QLineEdit le;
+  control->setStyleSheet(le.styleSheet());
+  return (control);
+}
+
+QSize LtsVirtualKeyboard::availableDesktopSize() const
+{
+#if QT_VERSION < QT_VERSION_CHECK(5, 12, 0)
+  return QApplication::desktop()->availableGeometry().size();
+#else
+  const QWindow *win = window()->windowHandle();
+  const QScreen *scr = (win && win->screen()) ? win->screen() : QGuiApplication::primaryScreen();
+  return scr ? scr->availableSize() : QSize(1280, 1024);
+#endif
+}
+
+void LtsVirtualKeyboard::init_keyboard(QWidget *focusThisControl)
+{
+  m_nextInput = focusThisControl;
+  checkInput();
+  
+  receiptChildKey(focusThisControl, nullptr, true);
+}
+
+void LtsVirtualKeyboard::show(QWidget *first, bool frameless)
+{
+  Q_UNUSED(frameless);
+  init_keyboard(first);
+
+  if (windowState() == Qt::WindowMinimized)
+    setWindowState(Qt::WindowNoState);
+  setStatusEchoMode(false);
+  setVisible(true);
+
+  const auto availSize = availableDesktopSize();
+  move((availSize.width() - width()) / 2,
+       (availSize.height() - height()) - 10);
+  QTimer::singleShot(300, this, [this]() { m_ready = true; });
+}
+
+
+void LtsVirtualKeyboard::borderFrame(bool visible)
+{
+  if (visible == true)
+    setWindowFlags(Qt::Dialog | Qt::WindowStaysOnTopHint | Qt::MSWindowsFixedSizeDialogHint);
+  else
+    setWindowFlags(Qt::Window | Qt::FramelessWindowHint);
+}
+
+void LtsVirtualKeyboard::checkInput()
+{
+  m_enableEnter = false;
+  m_echoMode = false;
+
+  m_le->setVisible(true);
+  m_te->setVisible(false);
+  if (qobject_cast<QLineEdit *>(m_nextInput))
+  {
+    QLineEdit *le = qobject_cast<QLineEdit *>(m_nextInput);
+    m_le->setEchoMode(le->echoMode());
+  }
+  if (qobject_cast<QTextEdit *>(m_nextInput) || qobject_cast<QPlainTextEdit *>(m_nextInput))
+  {
+    m_le->setVisible(false);
+    m_te->setVisible(true);
+    m_enableEnter = true;
+  }
+
+  LtsKeyPushButton *crButton = findChild<LtsKeyPushButton *>(KEY_RETURN);
+  if (crButton)
+  {
+    crButton->setEnabled(m_enableEnter);
+  }
+
+  if (m_te->isVisible())
+    setMaximumHeight(m_height+m_te->height());
+  else
+    setMaximumHeight(m_height+m_le->height());
+
+}
+
+bool LtsVirtualKeyboard::isNumericPad() const
+{
+  return (m_numericPad);
+}
+
+void LtsVirtualKeyboard::focusThis(QWidget *control, bool numpad)
+{
+  m_ready = false;
+  if (m_activeWindow != nullptr)
+  {
+    if (m_numericPad != numpad)
+    {
+      m_numericPad = numpad;
+      reinit();
+    }
+
+    if (m_nextInput != nullptr)
+      m_nextInput = setDefaultTextStyle(m_nextInput);
+    init_keyboard(control);
+    controlKeyEcho(control);
+
+    setCurrentText(getTextFromCurrentWidget());
+    if(m_te->isVisible())
+      m_te->moveCursor(QTextCursor::Start);
+    else
+      m_le->end(false);
+    if (m_nextInput)
+      setWindowTitle(m_nextInput->toolTip());
+  }
+  QTimer::singleShot(300, this, [this]() { m_ready = true; });
+  const auto availSize = availableDesktopSize();
+  if (isNumericPad())
+    move((availSize.width() - width()) / 2,
+         (availSize.height() - height()) - 10);
+  else
+    move(10, availSize.height() - height() - 10);
+}
+
+void LtsVirtualKeyboard::closeEvent(QCloseEvent *event)
+{
+  event->ignore();
+}
+
+void LtsVirtualKeyboard::hide(bool changeColor)
+{
+
+  m_ready = false;
+  try
+  {
+    if (changeColor == true)
+    {
+      if (m_activeWindow != nullptr)
+        setDefaultTextStyle(m_nextInput);
+    }
+    if (!parent())
+      setVisible(false);
+
+  }
+  catch (...)
+  {
+  }
+}
+
+
+void LtsVirtualKeyboard::createKeyboard()
+{
+  LtsKeyPushButton  *tmp = nullptr;
+  QVBoxLayout     *tmpVLayout = new QVBoxLayout;
+  QHBoxLayout     *tmpLayout = new QHBoxLayout;
+  QString         tmpStyle;
+  QString         backspace;
+  m_ready = false;
+  
+  m_te = new QTextEdit(this);
+  m_te->setMaximumHeight(210);
+  m_te->setMinimumHeight(210);
+
+  m_te->setObjectName(QStringLiteral("internalLE"));
+  
+  tmpVLayout->addWidget(m_te);
+  
+  m_te->hide();
+
+  
+  m_le = new QLineEdit(this);
+  m_le->setObjectName(QStringLiteral("internalLE"));
+  
+  tmpVLayout->addWidget(m_le);
+
+
+  if (isNumericPad() == true)
+  {
+    QGridLayout *gridLayout = new QGridLayout(this);
+    gridLayout->addLayout(tmpVLayout,0,0);
+    for (short i = 49; i <= 51; i++)
+      tmpLayout->addWidget(createNewKey(QChar(i), QString::number(i - 48),  QString::number(i - 48)));
+    gridLayout->addLayout(tmpLayout, 3, 0);
+    tmpLayout = new QHBoxLayout(this);
+    for (short i = 52; i <= 54; i++)
+      tmpLayout->addWidget(createNewKey(QChar(i), QString::number(i - 48),  QString::number(i - 48)));
+    gridLayout->addLayout(tmpLayout, 2, 0);
+    tmpLayout = new QHBoxLayout(this);
+    for (short i = 55; i <= 57; i++)
+      tmpLayout->addWidget(createNewKey(QChar(i), QString::number(i - 48),   QString::number(i - 48)));
+    gridLayout->addLayout(tmpLayout, 1, 0);
+    tmpLayout = new QHBoxLayout(this);
+    tmp = createNewKey(QStringLiteral("0"), QStringLiteral("0"), QStringLiteral("0"));
+    tmp->setMinimumSize(tmp->minimumSize().width() * 2, tmp->minimumSize().height());
+    tmpLayout->addWidget(tmp);
+    tmpLayout->addWidget(createNewKey(QStringLiteral("."), QStringLiteral(" . "), QStringLiteral(" . "))); 
+    gridLayout->addLayout(tmpLayout, 4, 0);
+    tmpLayout = new QHBoxLayout(this);
+    tmpLayout->addWidget(createNewKey(QStringLiteral(","), QStringLiteral(" , "), QStringLiteral(" , "))); 
+    backspace = QStringLiteral("BACKSPACE");
+    tmpStyle = (KEY_BACKSPACE);
+
+    tmp = createNewKey(tmpStyle, backspace);
+    tmp->setMaximumWidth(tmp->maximumWidth() * 1.5);
+    tmp->setMinimumWidth(tmp->minimumWidth() * 1.5);
+    tmpLayout->addWidget(tmp);
+
+    tmp = createNewKey(KEY_FIN,KEY_FIN);
+    tmp->setMaximumWidth(tmp->maximumWidth() * 1.5);
+    tmp->setMinimumWidth(tmp->minimumWidth() * 1.5);
+    tmpLayout->addWidget(tmp);
+    gridLayout->addLayout(tmpLayout, 5, 0);
+
+    
+    
+    setLayout(gridLayout);
+    setMaximumWidth(tmp->width()*3);
+    m_height= tmp->height()*5;
+  }
+  else
+  {
+    
+
+    
+    tmpLayout->addWidget(createNewKey(QStringLiteral("^"), QStringLiteral("^"), QStringLiteral("^")));
+    
+    tmpLayout->addWidget(createNewKey(QStringLiteral("1"), QStringLiteral("1"), QStringLiteral("!")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("2"), QStringLiteral("2"), QStringLiteral("\"")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("3"), QStringLiteral("3"), QChar(207)));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("4"), QStringLiteral("4"), QStringLiteral("$")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("5"), QStringLiteral("5"), QStringLiteral("%")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("6"), QStringLiteral("6"), QStringLiteral("&&")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("7"), QStringLiteral("7"), QStringLiteral("/")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("8"), QStringLiteral("8"), QStringLiteral("(")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("9"), QStringLiteral("9"), QStringLiteral(")")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("0"), QStringLiteral("0"), QStringLiteral("=")));
+    tmpLayout->addWidget(createNewKey(QChar(223), QChar(223), QStringLiteral("?"))); 
+    tmpLayout->addWidget(createNewKey(QStringLiteral("`"), QChar(180), QStringLiteral("`")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("["), QStringLiteral("["), QStringLiteral("{")));
+    backspace = QStringLiteral("<----");
+    tmpStyle = KEY_BACKSPACE;
+    tmp = createNewKey(tmpStyle, backspace);
+    tmp->setMaximumWidth(tmp->maximumWidth() * 1.2);
+    tmp->setMinimumWidth(tmp->maximumWidth() * 1.2);
+    tmpLayout->addWidget(tmp);
+    tmpLayout->insertStretch(-1, 1);
+    tmpVLayout->addLayout(tmpLayout);
+
+
+    
+    tmpLayout = new QHBoxLayout();
+
+    QVBoxLayout *layoutReturn = new QVBoxLayout();
+    tmp = createNewKey(KEY_ALT, KEY_ALT, KEY_ALT2);
+    tmp->setMaximumWidth(tmp->maximumWidth());
+    tmp->setMinimumWidth(tmp->minimumWidth());
+    tmpLayout->addWidget(tmp);
+
+    tmpLayout->addWidget(createNewKey(QStringLiteral("Q"), QStringLiteral("Q"), QStringLiteral("@")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("W"), QStringLiteral("W")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("E"), QStringLiteral("E"), QChar(8364)));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("R"), QStringLiteral("R")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("T"), QStringLiteral("T")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("Z"), QStringLiteral("Z")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("U"), QStringLiteral("U")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("I"), QStringLiteral("I")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("O"), QStringLiteral("O")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("P"), QStringLiteral("P")));
+    tmpLayout->addWidget(createNewKey(QChar(220), QChar(220)));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("+"), QStringLiteral("+"), QStringLiteral("*")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("]"), QStringLiteral("]"), QStringLiteral("}")));
+    tmpStyle = KEY_CANC;
+    tmp = createNewKey(tmpStyle, QStringLiteral("->"));
+    tmp->setMaximumWidth(tmp->maximumWidth());
+    tmp->setMinimumWidth(tmp->minimumWidth());
+    tmpLayout->addWidget(tmp);
+    tmpLayout->insertStretch(-1, 1);
+    
+    
+
+
+    layoutReturn->addLayout(tmpLayout, 1);
+
+    
+    tmpLayout = new QHBoxLayout();
+    tmp = createNewKey(KEY_CAPS, KEY_CAPS);
+    tmp->setMinimumWidth(tmp->minimumWidth() * 1.5 + 5);
+    tmpLayout->addWidget(tmp);
+    tmpLayout->addWidget(createNewKey(QStringLiteral("A"), QStringLiteral("A")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("S"), QStringLiteral("S")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("D"), QStringLiteral("D")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("F"), QStringLiteral("F")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("G"), QStringLiteral("G")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("H"), QStringLiteral("H")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("J"), QStringLiteral("J")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("K"), QStringLiteral("K")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("L"), QStringLiteral("L")));
+    tmpLayout->addWidget(createNewKey(QChar(214), QChar(214))); 
+    tmpLayout->addWidget(createNewKey(QChar(196), QChar(196))); 
+    tmpLayout->addWidget(createNewKey(QStringLiteral("'"), QStringLiteral("'"), QStringLiteral("#")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("|"), QStringLiteral("|"), QStringLiteral("\\")));
+    tmpLayout->insertStretch(-1, 1);
+
+    layoutReturn->setSpacing(5);
+    layoutReturn->addLayout(tmpLayout, 1);
+    
+    tmpLayout = new QHBoxLayout();
+    tmpLayout->addLayout(layoutReturn, 1);
+    
+
+    tmp = createNewKey(KEY_RETURN, QStringLiteral("RETURN"));
+    tmp->setEnabled(m_enableEnter);
+    tmp->setMaximumWidth(tmp->maximumWidth() * 1.4);
+    tmp->setMinimumWidth(tmp->minimumWidth() * 1.4);
+    tmp->setMinimumHeight(tmp->minimumHeight() * 1.4);
+    
+    tmpLayout->addWidget(tmp, 2);
+
+    
+    tmpVLayout->addLayout(tmpLayout);
+
+
+    
+    tmpLayout = new QHBoxLayout();
+    tmp = createNewKey(KEY_CUT_LEFT, KEY_CUT_LEFT);
+    tmp->setMaximumWidth(tmp->maximumWidth() * 1.2);
+    tmp->setMinimumWidth(tmp->minimumWidth() * 1.2);
+    tmpLayout->addWidget(tmp);
+    tmpLayout->addWidget(createNewKey(QStringLiteral("<"), QStringLiteral("<"), QStringLiteral(">")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("Y"), QStringLiteral("Y")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("X"), QStringLiteral("X")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("C"), QStringLiteral("C")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("V"), QStringLiteral("V")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("B"), QStringLiteral("B")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("N"), QStringLiteral("N")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("M"), QStringLiteral("M")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral(","), QStringLiteral(","), QStringLiteral(";")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("."), QStringLiteral("."), QStringLiteral(":")));
+    tmpLayout->addWidget(createNewKey(QStringLiteral("-"), QStringLiteral("-"), QStringLiteral("_")));
+    tmpLayout->insertStretch(-1, 1);
+
+    
+    tmpVLayout->addLayout(tmpLayout);
+    tmpLayout = new QHBoxLayout();
+
+    tmp = createNewKey(KEY_COPY, KEY_COPY);
+    tmp->setMaximumWidth(tmp->maximumWidth());
+    tmp->setMinimumWidth(tmp->maximumWidth());
+    tmpLayout->addWidget(tmp);
+
+    tmp = createNewKey(KEY_PASTE, KEY_PASTE);
+    tmp->setMaximumWidth(tmp->maximumWidth());
+    tmp->setMinimumWidth(tmp->maximumWidth());
+    tmpLayout->addWidget(tmp);
+
+    QWidget *empty = new QWidget(this);
+    empty->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
+    tmpLayout->addWidget(empty);
+
+    tmp = createNewKey(QStringLiteral(KEY_SPACE), QStringLiteral(" "));
+    tmp->setMinimumWidth(300);
+    tmp->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+    tmpLayout->addWidget(tmp, 3);
+
+    empty = new QWidget(this);
+    empty->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
+    tmpLayout->addWidget(empty);
+
+    tmp = createNewKey(KEY_FIN, KEY_FIN);
+    tmp->setMaximumWidth(tmp->maximumWidth() * 1.5);
+    tmp->setMinimumWidth(tmp->minimumWidth() * 1.5);
+    tmpLayout->addWidget(tmp);
+
+    tmpVLayout->addLayout(tmpLayout);
+    setLayout(tmpVLayout);
+
+    m_height = tmp->height()*5+10;
+    setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
+  }
+
+  setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
+}
+
+}