Example #1
0
void AQWebApplication::finish()
{
  if (!initDone_ || finish_)
    return;

  finish_ = true;
  disconnect(guiSocket_, SIGNAL(readyRead()), this, SLOT(recvWebEvents()));
#ifndef AQ_USE_NOTIFY
  removeEventFilter(eventFilter_);
#endif

  sendGuiEvent("ds" + AQ_MSG_SEP + QString::number(AQ_WID(desktop_), 36));

  recvWebEvents();
  processEvents();

  processWebEvents();
  processAQEvents();

  QPtrDictIterator<AQWidgetInfo> it(createdWidgets_);
  AQWidgetInfo *wInfo;
  for (; it.current(); ++it) {
    wInfo = it.current();
    sendGuiEvent("ds" + AQ_MSG_SEP + wInfo->wid_);
    wInfo->clear();
    delete wInfo;
  }
  createdWidgets_.clear();

  closeConnection();
}
Example #2
0
//! set text markers
void CGUIEditBox::setTextMarkers(s32 begin, s32 end)
{
    if ( begin != MarkBegin || end != MarkEnd )
    {
        MarkBegin = begin;
        MarkEnd = end;
        sendGuiEvent(EGET_EDITBOX_MARKING_CHANGED);
    }
}
Example #3
0
void AQWebApplication::processAQEvents()
{
#ifdef AQ_VERBOSE
  qWarning("INI @@@@@@@@@@@@@@@@@@@@@@@@@@");
#endif

  AQWidgetInfo::lastAppendWidget_ = 0;
  AQWidgetInfo::lastConsumeWidget_ = 0;

  if (!AQWidgetInfo::dictDsMsgs_.isEmpty()) {
    QDictIterator<QString> it(AQWidgetInfo::dictDsMsgs_);
    for (; it.current(); ++it)
      sendGuiEvent(*(*it));
    AQWidgetInfo::dictDsMsgs_.setAutoDelete(true);
    AQWidgetInfo::dictDsMsgs_.clear();
  }

  AQEvent *ev;
  AQWidgetInfo *wInfo;
  while (!pendingWidgets_.isEmpty()) {
    wInfo = pendingWidgets_.take(0);
    while ((ev = wInfo->consumeEvent()) != 0) {
      if (!ev->ignore_)
        sendGuiEvent(ev->toMsg());
#ifdef AQ_VERBOSE
      else
        qWarning("**** " + ev->toMsg().left(100));
#endif
      delete ev;
    }
  }

#ifdef AQ_VERBOSE
  qWarning("FIN #############################");
#endif
}
Example #4
0
void CGUIEditBox::inputChar(wchar_t c)
{
    if (!isEnabled())
        return;

    if (c != 0)
    {
        if (Text.size() < Max || Max == 0)
        {
            core::stringw s;

            if (MarkBegin != MarkEnd)
            {
                // replace marked text
                const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
                const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;

                s = Text.subString(0, realmbgn);
                s.append(c);
                s.append( Text.subString(realmend, Text.size()-realmend) );
                Text = s;
                CursorPos = realmbgn+1;
            }
            else
            {
                // add new character
                s = Text.subString(0, CursorPos);
                s.append(c);
                s.append( Text.subString(CursorPos, Text.size()-CursorPos) );
                Text = s;
                ++CursorPos;
            }

            BlinkStartTime = getTime();
            setTextMarkers(0, 0);
        }
    }
    breakText();
    sendGuiEvent(EGET_EDITBOX_CHANGED);
    calculateScrollPos();
}
Example #5
0
bool CGUIEditBox::processKey(const SEvent& event)
{
    if (!event.KeyInput.PressedDown)
        return false;

    bool textChanged = false;
    s32 newMarkBegin = MarkBegin;
    s32 newMarkEnd = MarkEnd;

    // control shortcut handling

    if (event.KeyInput.Control)
    {
        // german backlash '\' entered with control + '?'
        if ( event.KeyInput.Char == '\\' )
        {
            inputChar(event.KeyInput.Char);
            return true;
        }

        switch(event.KeyInput.Key)
        {
        case KEY_KEY_A:
            // select all
            newMarkBegin = 0;
            newMarkEnd = Text.size();
            break;
        case KEY_KEY_C:
            // copy to clipboard
            if (!PasswordBox && Operator && MarkBegin != MarkEnd)
            {
                const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
                const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;

                core::stringw s;
                s = Text.subString(realmbgn, realmend - realmbgn).c_str();
#ifdef _IRR_COMPILE_WITH_WINDOWS_DEVICE_
                Operator->copyToClipboard(s.c_str());
#else
                Operator->copyToClipboard(StringUtils::wideToUtf8(s).c_str());
#endif
            }
            break;
        case KEY_KEY_X:
            // cut to the clipboard
            if (!PasswordBox && Operator && MarkBegin != MarkEnd)
            {
                const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
                const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;

                // copy
                core::stringw sc;
                sc = Text.subString(realmbgn, realmend - realmbgn).c_str();
#ifdef _IRR_COMPILE_WITH_WINDOWS_DEVICE_
                Operator->copyToClipboard(sc.c_str());
#else
                Operator->copyToClipboard(StringUtils::wideToUtf8(sc).c_str());
#endif

                if (isEnabled())
                {
                    // delete
                    core::stringw s;
                    s = Text.subString(0, realmbgn);
                    s.append( Text.subString(realmend, Text.size()-realmend) );
                    Text = s;

                    CursorPos = realmbgn;
                    newMarkBegin = 0;
                    newMarkEnd = 0;
                    textChanged = true;
                }
            }
            break;

        case KEY_KEY_V:
            if ( !isEnabled() )
                break;

            // paste from the clipboard
            if (Operator)
            {
                const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
                const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;

                // add new character
#ifdef _IRR_COMPILE_WITH_WINDOWS_DEVICE_
                const wchar_t* p = Operator->getTextFromClipboard();
#else
                const c8* p = Operator->getTextFromClipboard();
#endif
                if (p)
                {
                    if (MarkBegin == MarkEnd)
                    {
                        // insert text
                        core::stringw s = Text.subString(0, CursorPos);
#ifndef _IRR_COMPILE_WITH_WINDOWS_DEVICE_
                        s.append(StringUtils::utf8ToWide(p));
#else
                        s.append(p);
#endif
                        s.append( Text.subString(CursorPos, Text.size()-CursorPos) );

                        if (!Max || s.size()<=Max) // thx to Fish FH for fix
                        {
                            Text = s;
#ifndef _IRR_COMPILE_WITH_WINDOWS_DEVICE_
                            s = StringUtils::utf8ToWide(p);
#else
                            s = p;
#endif
                            CursorPos += s.size();
                        }
                    }
                    else
                    {
                        // replace text

                        core::stringw s = Text.subString(0, realmbgn);

#ifndef _IRR_COMPILE_WITH_WINDOWS_DEVICE_
                        s.append(StringUtils::utf8ToWide(p));
#else
                        s.append(p);
#endif
                        s.append( Text.subString(realmend, Text.size()-realmend) );

                        if (!Max || s.size()<=Max)  // thx to Fish FH for fix
                        {
                            Text = s;
#ifndef _IRR_COMPILE_WITH_WINDOWS_DEVICE_
                            s = StringUtils::utf8ToWide(p);
#else
                            s = p;
#endif
                            CursorPos = realmbgn + s.size();
                        }
                    }
                }

                newMarkBegin = 0;
                newMarkEnd = 0;
                textChanged = true;
            }
            break;
        case KEY_HOME:
            if (!m_rtl)
            {
                // move/highlight to start of text
                if (event.KeyInput.Shift)
                {
                    newMarkEnd = CursorPos;
                    newMarkBegin = 0;
                    CursorPos = 0;
                }
                else
                {
                    CursorPos = 0;
                    newMarkBegin = 0;
                    newMarkEnd = 0;
                }
            }
            break;
        case KEY_END:
            if (!m_rtl)
            {
                // move/highlight to end of text
                if (event.KeyInput.Shift)
                {
                    newMarkBegin = CursorPos;
                    newMarkEnd = Text.size();
                    CursorPos = 0;
                }
                else
                {
                    CursorPos = Text.size();
                    newMarkBegin = 0;
                    newMarkEnd = 0;
                }
            }
            break;
        default:
            return false;
        }
    }
    // default keyboard handling
    else
    switch(event.KeyInput.Key)
    {
            /*
        case KEY_KEY_Q:
            inputChar(L'\u05DC');
            textChanged = true;
            return true;
        case KEY_KEY_W:
            inputChar(L'\u05DB');
            textChanged = true;
            return true;
        case KEY_KEY_E:
            inputChar(L'\u05DA');
            textChanged = true;
            return true;
        case KEY_KEY_R:
            inputChar(L'\u05D9');
            textChanged = true;
            return true;
        case KEY_KEY_T:
            inputChar(L'\u05D8');
            textChanged = true;
            return true;
        case KEY_KEY_Y:
            inputChar(L'\u05D7');
            textChanged = true;
            return true;
            */

    case KEY_END:
        if (!m_rtl)
        {
            s32 p = Text.size();
            if (WordWrap || MultiLine)
            {
                p = getLineFromPos(CursorPos);
                p = BrokenTextPositions[p] + (s32)BrokenText[p].size();
                if (p > 0 && (Text[p-1] == L'\r' || Text[p-1] == L'\n' ))
                    p-=1;
            }

            if (event.KeyInput.Shift)
            {
                if (MarkBegin == MarkEnd)
                    newMarkBegin = CursorPos;

                newMarkEnd = p;
            }
            else
            {
                newMarkBegin = 0;
                newMarkEnd = 0;
            }
            CursorPos = p;
            BlinkStartTime = getTime();
        }
        break;
    case KEY_HOME:
        if (!m_rtl)
        {

            s32 p = 0;
            if (WordWrap || MultiLine)
            {
                p = getLineFromPos(CursorPos);
                p = BrokenTextPositions[p];
            }

            if (event.KeyInput.Shift)
            {
                if (MarkBegin == MarkEnd)
                    newMarkBegin = CursorPos;
                newMarkEnd = p;
            }
            else
            {
                newMarkBegin = 0;
                newMarkEnd = 0;
            }
            CursorPos = p;
            BlinkStartTime = getTime();
        }
        break;
    case KEY_RETURN:
        if (MultiLine)
        {
            inputChar(L'\n');
            return true;
        }
        else
        {
            sendGuiEvent( EGET_EDITBOX_ENTER );
        }
        break;
    case KEY_LEFT:
        if (!m_rtl)
        {
            if (event.KeyInput.Shift)
            {
                if (CursorPos > 0)
                {
                    if (MarkBegin == MarkEnd)
                        newMarkBegin = CursorPos;

                    newMarkEnd = CursorPos-1;
                }
            }
            else
            {
                newMarkBegin = 0;
                newMarkEnd = 0;
            }

            if (CursorPos > 0) CursorPos--;
            BlinkStartTime = getTime();
        }
        break;

    case KEY_RIGHT:
        if (!m_rtl)
        {
            if (event.KeyInput.Shift)
            {
                if (Text.size() > (u32)CursorPos)
                {
                    if (MarkBegin == MarkEnd)
                        newMarkBegin = CursorPos;

                    newMarkEnd = CursorPos+1;
                }
            }
            else
            {
                newMarkBegin = 0;
                newMarkEnd = 0;
            }

            if (Text.size() > (u32)CursorPos) CursorPos++;
            BlinkStartTime = getTime();
        }
        break;
    case KEY_UP:
        if (MultiLine || (WordWrap && BrokenText.size() > 1) )
        {
            s32 lineNo = getLineFromPos(CursorPos);
            s32 mb = (MarkBegin == MarkEnd) ? CursorPos : (MarkBegin > MarkEnd ? MarkBegin : MarkEnd);
            if (lineNo > 0)
            {
                s32 cp = CursorPos - BrokenTextPositions[lineNo];
                if ((s32)BrokenText[lineNo-1].size() < cp)
                    CursorPos = BrokenTextPositions[lineNo-1] + (s32)BrokenText[lineNo-1].size()-1;
                else
                    CursorPos = BrokenTextPositions[lineNo-1] + cp;
            }

            if (event.KeyInput.Shift)
            {
                newMarkBegin = mb;
                newMarkEnd = CursorPos;
            }
            else
            {
                newMarkBegin = 0;
                newMarkEnd = 0;
            }

        }
        else
        {
            return false;
        }
        break;
    case KEY_DOWN:
        if (MultiLine || (WordWrap && BrokenText.size() > 1) )
        {
            s32 lineNo = getLineFromPos(CursorPos);
            s32 mb = (MarkBegin == MarkEnd) ? CursorPos : (MarkBegin < MarkEnd ? MarkBegin : MarkEnd);
            if (lineNo < (s32)BrokenText.size()-1)
            {
                s32 cp = CursorPos - BrokenTextPositions[lineNo];
                if ((s32)BrokenText[lineNo+1].size() < cp)
                    CursorPos = BrokenTextPositions[lineNo+1] + BrokenText[lineNo+1].size()-1;
                else
                    CursorPos = BrokenTextPositions[lineNo+1] + cp;
            }

            if (event.KeyInput.Shift)
            {
                newMarkBegin = mb;
                newMarkEnd = CursorPos;
            }
            else
            {
                newMarkBegin = 0;
                newMarkEnd = 0;
            }

        }
        else
        {
            return false;
        }
        break;

    case KEY_BACK:
        if ( !isEnabled() )
            break;

        if (Text.size())
        {
            core::stringw s;

            if (MarkBegin != MarkEnd)
            {
                // delete marked text
                const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
                const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;

                s = Text.subString(0, realmbgn);
                s.append( Text.subString(realmend, Text.size()-realmend) );
                Text = s;

                CursorPos = realmbgn;
            }
            else
            {
                // delete text behind cursor
                if (CursorPos>0)
                    s = Text.subString(0, CursorPos-1);
                else
                    s = L"";
                s.append( Text.subString(CursorPos, Text.size()-CursorPos) );
                Text = s;
                --CursorPos;
            }

            if (CursorPos < 0)
                CursorPos = 0;
            BlinkStartTime = getTime();
            newMarkBegin = 0;
            newMarkEnd = 0;
            textChanged = true;
        }
        break;
    case KEY_DELETE:
        if ( !isEnabled() )
            break;

        if (Text.size() != 0)
        {
            core::stringw s;

            if (MarkBegin != MarkEnd)
            {
                // delete marked text
                const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
                const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;

                s = Text.subString(0, realmbgn);
                s.append( Text.subString(realmend, Text.size()-realmend) );
                Text = s;

                CursorPos = realmbgn;
            }
            else
            {
                // delete text before cursor
                s = Text.subString(0, CursorPos);
                s.append( Text.subString(CursorPos+1, Text.size()-CursorPos-1) );
                Text = s;
            }

            if (CursorPos > (s32)Text.size())
                CursorPos = (s32)Text.size();

            BlinkStartTime = getTime();
            newMarkBegin = 0;
            newMarkEnd = 0;
            textChanged = true;
        }
        break;

    case KEY_ESCAPE:
    case KEY_TAB:
    case KEY_SHIFT:
    case KEY_F1:
    case KEY_F2:
    case KEY_F3:
    case KEY_F4:
    case KEY_F5:
    case KEY_F6:
    case KEY_F7:
    case KEY_F8:
    case KEY_F9:
    case KEY_F10:
    case KEY_F11:
    case KEY_F12:
    case KEY_F13:
    case KEY_F14:
    case KEY_F15:
    case KEY_F16:
    case KEY_F17:
    case KEY_F18:
    case KEY_F19:
    case KEY_F20:
    case KEY_F21:
    case KEY_F22:
    case KEY_F23:
    case KEY_F24:
        // ignore these keys
        return false;

    default:
        inputChar(event.KeyInput.Char);
        return true;
    }

    // Set new text markers
    setTextMarkers( newMarkBegin, newMarkEnd );

    // break the text if it has changed
    if (textChanged)
    {
        breakText();
        sendGuiEvent(EGET_EDITBOX_CHANGED);
    }

    calculateScrollPos();

#if defined(_IRR_COMPILE_WITH_WINDOWS_DEVICE_)
    switch(event.KeyInput.Key)
    {
    // If cursor points the surrogate low, send KEY_LEFT event.
    case KEY_UP:
    case KEY_DOWN:
        if (MultiLine || (WordWrap && BrokenText.size() > 1) )
        {
            if (UTF16_IS_SURROGATE_LO(Text[CursorPos]))
            {
                SEvent leftEvent;
                leftEvent = event;
                leftEvent.KeyInput.Key = KEY_LEFT;
                Environment->postEventFromUser(leftEvent);
            }
        }
        break;
    // If cursor points the surrogate low, send a same event.
    case KEY_LEFT:
    case KEY_RIGHT:
    case KEY_DELETE:
        if (UTF16_IS_SURROGATE_LO(Text[CursorPos]))
            Environment->postEventFromUser(event);
        break;
    // If cursor points front of the surrogate high, send a same event.
    case KEY_BACK:
        if (CursorPos > 0)
        {
            if (UTF16_IS_SURROGATE_HI(Text[CursorPos-1]))
                Environment->postEventFromUser(event);
        }
        break;
    default:
        break;
    }
#endif
    return true;
}