Esempio n. 1
0
LONG TextViewBase::OnLButtonDblClick(UINT nFlags, int mx, int my)
{
	// remove any existing selection
	InvalidateRange(m_nSelectionStart, m_nSelectionEnd);


	ULONG lineno, fileoff;
	int   xpos;

	// map the mouse-coordinates to a real file-offset-coordinate
	MouseCoordToFilePos(mx, my, &lineno, &fileoff, &xpos);
	//m_nAnchorPosX = m_nCaretPosX;

	// move selection-start to start of word
	MoveWordStart();
	m_nSelectionStart = m_nSelectionEnd;// m_nCursorOffset;

	// move selection-end to end of word
	MoveWordEnd();
	//m_nSelectionEnd = m_nCursorOffset;

	// update caret position
	InvalidateRange(m_nSelectionStart, m_nSelectionEnd);
	//UpdateCaretOffset(m_nCursorOffset, TRUE, &m_nCaretPosX, &m_nCurrentLine);
	//m_nAnchorPosX = m_nCaretPosX;
	RepositionCaret();

	NotifyParent(TVN_CURSOR_CHANGE);
	NotifyParent(TVN_SELECTION_CHANGED);

	return 0;
}
Esempio n. 2
0
    bool Do(const KEY_EVENT_RECORD& ker, Screen& screen, const EditScheme& scheme)
    {
        bool cont = true;
        if (ker.bKeyDown)
        {
            const bool readOnly = fileInfo.isreadonly();

            switch (ker.wVirtualKeyCode)
            {
            case VK_F1:
                {
                    wchar_t* pWData = nullptr;
                    {
                        HMODULE hModule = NULL;
                        Memory mem = GetResource(hModule, IDR_TEXT);
                        const char* pData = static_cast<const char*>(mem.data);

                        pWData = new wchar_t[mem.size + 1];
                        for (DWORD i = 0; i < mem.size; ++i)
                        {
                            switch (pData[i])
                            {
                            case '\r':
                                pWData[i] = L' ';
                                break;
                            case '\n':
                                pWData[i] = L'\0';
                                break;
                            default:
                                pWData[i] = pData[i];
                                break;
                            }
                        }
                        pWData[mem.size] = L'\0';
                    }

                    ModeInfoBox mmb(this, _COORD(4, 4), pWData);
                    DoMode(mmb, screen, scheme);

                    delete[] pWData;
                    me.invalid = true;
                }
                break;

            case VK_F3:
                switch (ker.dwControlKeyState & 0x1F)
                {
                case RIGHT_CTRL_PRESSED:
                case LEFT_CTRL_PRESSED:
                    if (me.Selection().empty())
                    {
                        size_t p = MoveWordBegin(me.Chars(), me.Selection().end);

                        if (iswblank(me.Chars()[p])) // TODO Use locale?
                            break;  // Don't search

                        me.MoveCursor(p, false);
                        me.MoveCursor(MoveWordEnd(me.Chars(), me.Selection().end), true);
                    }

                    if (!me.Selection().empty())
                    {
                        mf.setFind(me.GetSelectedText());
                        mf.visible = true;
                        me.invalid = true;
                    }
                    Find(true, true);
                    break;

                case 0:
                    Find(true, true);
                    break;

                case SHIFT_PRESSED:
                    Find(false, true);
                    break;
                }
                break;

            case 'F':
                switch (ker.dwControlKeyState & 0x1F)
                {
                case RIGHT_CTRL_PRESSED:
                case LEFT_CTRL_PRESSED:
                    // TODO Set focus to find window to edit search text
                    mf.visible = true;
                    DoMode(mf, screen, scheme);
                    me.invalid = true;
                    break;
                }
                break;

            case 'G':
                switch (ker.dwControlKeyState & 0x1F)
                {
                case RIGHT_CTRL_PRESSED:
                case LEFT_CTRL_PRESSED:
                    {
                        ModePromptInteger mpi(this, ms.buffer, ms.pos, L"Goto line?");
                        DoMode(mpi, screen, scheme);
                        int line = mpi.Ret();
                        if (line > 0)
                        {
                            me.MoveCursor(GetLineOffset(me.Chars(), line), false);
                        }
                        me.invalid = true;
                    }
                    break;
                }
                break;

            case 'I':
                switch (ker.dwControlKeyState & 0x1F)
                {
                case RIGHT_CTRL_PRESSED:
                case LEFT_CTRL_PRESSED:
                    mf.ToggleCaseSensitive();
                    Find(true, false);
                    break;
                }
                break;

            case 'R':
                switch (ker.dwControlKeyState & 0x1F)
                {
                case RIGHT_CTRL_PRESSED:
                case LEFT_CTRL_PRESSED:
                    me.Revert(fileInfo, l);
                    break;
                }
                break;

            case 'S':
                switch (ker.dwControlKeyState & 0x1F)
                {
                case RIGHT_CTRL_PRESSED:
                case LEFT_CTRL_PRESSED:
                    if (!readOnly)
                    {
                        try
                        {
                            me.Save(fileInfo, l);
                            ms.message = L"Saved";
                        }
                        catch (const std::exception& e)
                        {
                            ms.error = convert(e.what(), l);
                            me.invalid = true;
                        }
                    }
                    else
                        Beep();
                    break;
                }
                break;

            case 'X':
                switch (ker.dwControlKeyState & 0x1F)
                {
                case RIGHT_ALT_PRESSED:
                case LEFT_ALT_PRESSED:
                    {
                        if (me.isEdited())
                        {
                            ModePromptYesNo mpyn(this, ms.buffer, ms.pos, L"Save?");
                            DoMode(mpyn, screen, scheme);
                            WORD key = mpyn.Ret();
                            me.invalid = true;
                            if (key == L'Y')
                                me.Save(fileInfo, l);
                            if (key != 0)
                                cont = false;
                        }
                        else
                            cont = false;

                    }
                    break;
                }
                break;
            }
        }

        if (cont)
            cont = me.Do(ker, screen, scheme);

        return cont;
    }