mirror of
https://github.com/reactos/reactos.git
synced 2024-10-29 19:13:58 +00:00
2167 lines
62 KiB
C++
2167 lines
62 KiB
C++
/*
|
|
* AutoComplete interfaces implementation.
|
|
*
|
|
* Copyright 2004 Maxime Bellengé <maxime.bellenge@laposte.net>
|
|
* Copyright 2009 Andrew Hill
|
|
* Copyright 2020-2021 Katayama Hirofumi MZ <katayama.hirofumi.mz@gmail.com>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include "precomp.h"
|
|
#include <process.h> // _beginthreadex
|
|
|
|
/*
|
|
TODO:
|
|
- implement ACO_SEARCH style
|
|
- implement ACO_FILTERPREFIXES style
|
|
- implement ACO_RTLREADING style
|
|
*/
|
|
|
|
#define CX_LIST 30160 // width of m_hwndList (very wide but alright)
|
|
#define CY_LIST 288 // maximum height of drop-down window
|
|
#define CY_ITEM 18 // default height of listview item
|
|
#define MAX_ITEM_COUNT 1000 // the maximum number of items
|
|
#define WATCH_TIMER_ID 0xFEEDBEEF // timer ID to watch m_rcEdit
|
|
#define WATCH_INTERVAL 300 // in milliseconds
|
|
|
|
static HHOOK s_hMouseHook = NULL; // hook handle
|
|
static HWND s_hWatchWnd = NULL; // the window handle to watch
|
|
|
|
struct PREFIX_INFO
|
|
{
|
|
LPCWSTR psz;
|
|
INT cch;
|
|
};
|
|
static const PREFIX_INFO s_prefixes[] =
|
|
{
|
|
{ L"https://", 8 },
|
|
{ L"http://www.", 11 },
|
|
{ L"http://", 7 },
|
|
{ L"www.", 4 },
|
|
};
|
|
|
|
static BOOL DropPrefix(const CStringW& str, CStringW& strBody)
|
|
{
|
|
for (size_t iPrefix = 0; iPrefix < _countof(s_prefixes); ++iPrefix)
|
|
{
|
|
LPCWSTR psz = s_prefixes[iPrefix].psz;
|
|
INT cch = s_prefixes[iPrefix].cch;
|
|
if (::StrCmpNIW(str, psz, cch) == 0)
|
|
{
|
|
strBody = str.Mid(cch);
|
|
return TRUE;
|
|
}
|
|
}
|
|
strBody = str;
|
|
return FALSE;
|
|
}
|
|
|
|
static BOOL DoesMatch(const CStringW& strTarget, const CStringW& strText)
|
|
{
|
|
CStringW strBody;
|
|
if (DropPrefix(strTarget, strBody))
|
|
{
|
|
if (::StrCmpNIW(strBody, strText, strText.GetLength()) == 0)
|
|
return TRUE;
|
|
}
|
|
else if (::StrCmpNIW(strTarget, strText, strText.GetLength()) == 0)
|
|
{
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
// mouse hook procedure to watch the mouse click
|
|
// https://docs.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms644988(v=vs.85)
|
|
static LRESULT CALLBACK MouseProc(INT nCode, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if (s_hMouseHook == NULL)
|
|
return 0; // do default
|
|
// if the user clicked the outside of s_hWatchWnd, then hide the drop-down window
|
|
if (nCode == HC_ACTION && // an action?
|
|
s_hWatchWnd && ::IsWindow(s_hWatchWnd) && // s_hWatchWnd is valid?
|
|
::GetCapture() == NULL) // no capture? (dragging something?)
|
|
{
|
|
RECT rc;
|
|
MOUSEHOOKSTRUCT *pMouseHook = reinterpret_cast<MOUSEHOOKSTRUCT *>(lParam);
|
|
switch (wParam)
|
|
{
|
|
case WM_LBUTTONDOWN: case WM_LBUTTONUP:
|
|
case WM_RBUTTONDOWN: case WM_RBUTTONUP:
|
|
case WM_MBUTTONDOWN: case WM_MBUTTONUP:
|
|
case WM_NCLBUTTONDOWN: case WM_NCLBUTTONUP:
|
|
case WM_NCRBUTTONDOWN: case WM_NCRBUTTONUP:
|
|
case WM_NCMBUTTONDOWN: case WM_NCMBUTTONUP:
|
|
{
|
|
::GetWindowRect(s_hWatchWnd, &rc);
|
|
if (!::PtInRect(&rc, pMouseHook->pt)) // outside of s_hWatchWnd?
|
|
{
|
|
::ShowWindowAsync(s_hWatchWnd, SW_HIDE); // hide it
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return ::CallNextHookEx(s_hMouseHook, nCode, wParam, lParam); // go next hook
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// sorting algorithm
|
|
// http://www.ics.kagoshima-u.ac.jp/~fuchida/edu/algorithm/sort-algorithm/
|
|
|
|
typedef CSimpleArray<CStringW> list_t;
|
|
|
|
static inline INT compare1(const CStringW& str1, const CStringW& str2)
|
|
{
|
|
CStringW s1, s2;
|
|
DropPrefix(str1, s1);
|
|
DropPrefix(str2, s2);
|
|
return s1.CompareNoCase(s2);
|
|
}
|
|
|
|
static inline INT pivot(list_t& list, INT i, INT j)
|
|
{
|
|
INT k = i + 1;
|
|
while (k <= j && compare1(list[i], list[k]) == 0)
|
|
k++;
|
|
if (k > j)
|
|
return -1;
|
|
if (compare1(list[i], list[k]) >= 0)
|
|
return i;
|
|
return k;
|
|
}
|
|
|
|
static inline INT partition(list_t& list, INT i, INT j, const CStringW& x)
|
|
{
|
|
INT left = i, right = j;
|
|
while (left <= right)
|
|
{
|
|
while (left <= j && compare1(list[left], x) < 0)
|
|
left++;
|
|
while (right >= i && compare1(list[right], x) >= 0)
|
|
right--;
|
|
if (left > right)
|
|
break;
|
|
|
|
CStringW tmp = list[left];
|
|
list[left] = list[right];
|
|
list[right] = tmp;
|
|
|
|
left++;
|
|
right--;
|
|
}
|
|
return left;
|
|
}
|
|
|
|
static void quicksort(list_t& list, INT i, INT j)
|
|
{
|
|
if (i == j)
|
|
return;
|
|
INT p = pivot(list, i, j);
|
|
if (p == -1)
|
|
return;
|
|
INT k = partition(list, i, j, list[p]);
|
|
quicksort(list, i, k - 1);
|
|
quicksort(list, k, j);
|
|
}
|
|
|
|
static inline void DoSort(list_t& list)
|
|
{
|
|
if (list.GetSize() <= 1) // sanity check
|
|
return;
|
|
quicksort(list, 0, list.GetSize() - 1); // quick sort
|
|
}
|
|
|
|
// std::unique
|
|
static INT DoUnique(list_t& list)
|
|
{
|
|
INT first = 0, last = list.GetSize();
|
|
if (first == last)
|
|
return last;
|
|
INT result = first;
|
|
while (++first != last)
|
|
{
|
|
if (compare1(list[result], list[first]) != 0)
|
|
list[++result] = list[first];
|
|
}
|
|
return ++result;
|
|
}
|
|
|
|
static inline void DoUniqueAndTrim(list_t& list)
|
|
{
|
|
INT last = DoUnique(list);
|
|
while (list.GetSize() > last)
|
|
{
|
|
list.RemoveAt(last);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
// range of WCHAR (inclusive)
|
|
struct RANGE
|
|
{
|
|
WCHAR from, to;
|
|
};
|
|
|
|
// a callback function for bsearch: comparison of two ranges
|
|
static inline int RangeCompare(const void *x, const void *y)
|
|
{
|
|
const RANGE *a = reinterpret_cast<const RANGE *>(x);
|
|
const RANGE *b = reinterpret_cast<const RANGE *>(y);
|
|
if (a->to < b->from)
|
|
return -1;
|
|
if (b->to < a->from)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
// is the WCHAR a word break?
|
|
static inline BOOL IsWordBreak(WCHAR ch)
|
|
{
|
|
// the ranges of word break characters
|
|
static const RANGE s_ranges[] =
|
|
{
|
|
{ 0x0009, 0x0009 }, { 0x0020, 0x002f }, { 0x003a, 0x0040 }, { 0x005b, 0x0060 },
|
|
{ 0x007b, 0x007e }, { 0x00ab, 0x00ab }, { 0x00ad, 0x00ad }, { 0x00bb, 0x00bb },
|
|
{ 0x02c7, 0x02c7 }, { 0x02c9, 0x02c9 }, { 0x055d, 0x055d }, { 0x060c, 0x060c },
|
|
{ 0x2002, 0x200b }, { 0x2013, 0x2014 }, { 0x2016, 0x2016 }, { 0x2018, 0x2018 },
|
|
{ 0x201c, 0x201d }, { 0x2022, 0x2022 }, { 0x2025, 0x2027 }, { 0x2039, 0x203a },
|
|
{ 0x2045, 0x2046 }, { 0x207d, 0x207e }, { 0x208d, 0x208e }, { 0x226a, 0x226b },
|
|
{ 0x2574, 0x2574 }, { 0x3001, 0x3003 }, { 0x3005, 0x3005 }, { 0x3008, 0x3011 },
|
|
{ 0x3014, 0x301b }, { 0x301d, 0x301e }, { 0x3041, 0x3041 }, { 0x3043, 0x3043 },
|
|
{ 0x3045, 0x3045 }, { 0x3047, 0x3047 }, { 0x3049, 0x3049 }, { 0x3063, 0x3063 },
|
|
{ 0x3083, 0x3083 }, { 0x3085, 0x3085 }, { 0x3087, 0x3087 }, { 0x308e, 0x308e },
|
|
{ 0x309b, 0x309e }, { 0x30a1, 0x30a1 }, { 0x30a3, 0x30a3 }, { 0x30a5, 0x30a5 },
|
|
{ 0x30a7, 0x30a7 }, { 0x30a9, 0x30a9 }, { 0x30c3, 0x30c3 }, { 0x30e3, 0x30e3 },
|
|
{ 0x30e5, 0x30e5 }, { 0x30e7, 0x30e7 }, { 0x30ee, 0x30ee }, { 0x30f5, 0x30f6 },
|
|
{ 0x30fc, 0x30fe }, { 0xfd3e, 0xfd3f }, { 0xfe30, 0xfe31 }, { 0xfe33, 0xfe44 },
|
|
{ 0xfe4f, 0xfe51 }, { 0xfe59, 0xfe5e }, { 0xff08, 0xff09 }, { 0xff0c, 0xff0c },
|
|
{ 0xff0e, 0xff0e }, { 0xff1c, 0xff1c }, { 0xff1e, 0xff1e }, { 0xff3b, 0xff3b },
|
|
{ 0xff3d, 0xff3d }, { 0xff40, 0xff40 }, { 0xff5b, 0xff5e }, { 0xff61, 0xff64 },
|
|
{ 0xff67, 0xff70 }, { 0xff9e, 0xff9f }, { 0xffe9, 0xffe9 }, { 0xffeb, 0xffeb },
|
|
};
|
|
// binary search
|
|
RANGE range = { ch, ch };
|
|
return !!bsearch(&range, s_ranges, _countof(s_ranges), sizeof(RANGE), RangeCompare);
|
|
}
|
|
|
|
// This function is an application-defined callback function.
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/winuser/nc-winuser-editwordbreakprocw
|
|
static INT CALLBACK
|
|
EditWordBreakProcW(LPWSTR lpch, INT index, INT count, INT code)
|
|
{
|
|
switch (code)
|
|
{
|
|
case WB_ISDELIMITER:
|
|
return IsWordBreak(lpch[index]);
|
|
case WB_LEFT:
|
|
{
|
|
if (index)
|
|
--index;
|
|
while (index && !IsWordBreak(lpch[index]))
|
|
--index;
|
|
return index;
|
|
}
|
|
case WB_RIGHT:
|
|
{
|
|
if (!count)
|
|
break;
|
|
while (index < count && lpch[index] && !IsWordBreak(lpch[index]))
|
|
++index;
|
|
return index;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static LRESULT CALLBACK
|
|
EditSubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam,
|
|
UINT_PTR uSubclassID, DWORD_PTR dwData)
|
|
{
|
|
CAutoComplete *pThis = reinterpret_cast<CAutoComplete *>(dwData);
|
|
return pThis->EditWndProc(hwnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
LRESULT CAutoComplete::EditWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
LRESULT ret;
|
|
HWND hwndGotFocus;
|
|
switch (uMsg)
|
|
{
|
|
case WM_CHAR:
|
|
return OnEditChar(wParam, lParam);
|
|
case WM_CUT: case WM_PASTE: case WM_CLEAR:
|
|
ret = ::DefSubclassProc(hwnd, uMsg, wParam, lParam); // do default
|
|
StartCompletion(TRUE);
|
|
return ret;
|
|
case WM_GETDLGCODE:
|
|
ret = ::DefSubclassProc(hwnd, uMsg, wParam, lParam); // do default
|
|
// some special keys need default processing. we handle them here
|
|
switch (wParam)
|
|
{
|
|
case VK_RETURN:
|
|
if (IsWindowVisible() || ::GetKeyState(VK_CONTROL) < 0)
|
|
OnEditKeyDown(VK_RETURN, 0);
|
|
break;
|
|
case VK_TAB:
|
|
if (IsWindowVisible() && UseTab())
|
|
ret |= DLGC_WANTALLKEYS; // we want all keys to manipulate the list
|
|
break;
|
|
case VK_ESCAPE:
|
|
if (IsWindowVisible())
|
|
ret |= DLGC_WANTALLKEYS; // we want all keys to manipulate the list
|
|
break;
|
|
default:
|
|
{
|
|
ret |= DLGC_WANTALLKEYS; // we want all keys to manipulate the list
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
case WM_KEYDOWN:
|
|
if (OnEditKeyDown(wParam, lParam))
|
|
return TRUE; // eat
|
|
break;
|
|
case WM_SETFOCUS:
|
|
break;
|
|
case WM_KILLFOCUS:
|
|
// hide the list if lost focus
|
|
hwndGotFocus = (HWND)wParam;
|
|
if (hwndGotFocus != m_hwndEdit && hwndGotFocus != m_hWnd)
|
|
HideDropDown();
|
|
break;
|
|
case WM_SETTEXT:
|
|
if (!m_bInSetText)
|
|
HideDropDown(); // it's mechanical WM_SETTEXT
|
|
break;
|
|
case WM_DESTROY:
|
|
{
|
|
if (m_fnOldWordBreakProc)
|
|
{
|
|
::SendMessageW(hwnd, EM_SETWORDBREAKPROC, 0, reinterpret_cast<LPARAM>(m_fnOldWordBreakProc));
|
|
m_fnOldWordBreakProc = NULL;
|
|
}
|
|
::RemoveWindowSubclass(hwnd, EditSubclassProc, 0);
|
|
if (::IsWindow(m_hWnd))
|
|
PostMessageW(WM_CLOSE, 0, 0);
|
|
// remove reference to m_hwndEdit
|
|
Release();
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ::DefSubclassProc(hwnd, uMsg, wParam, lParam); // do default
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// CACListView
|
|
|
|
CACListView::CACListView() : m_pDropDown(NULL), m_cyItem(CY_ITEM)
|
|
{
|
|
}
|
|
|
|
HWND CACListView::Create(HWND hwndParent)
|
|
{
|
|
ATLASSERT(m_hWnd == NULL);
|
|
DWORD dwStyle = WS_CHILD | /*WS_VISIBLE |*/ WS_CLIPSIBLINGS | LVS_NOCOLUMNHEADER |
|
|
LVS_OWNERDATA | LVS_OWNERDRAWFIXED | LVS_SINGLESEL | LVS_REPORT;
|
|
HWND hWnd = ::CreateWindowExW(0, GetWndClassName(), L"Internet Explorer", dwStyle,
|
|
0, 0, 0, 0, hwndParent, NULL,
|
|
_AtlBaseModule.GetModuleInstance(), NULL);
|
|
SubclassWindow(hWnd); // do subclass to handle messages
|
|
// set extended listview style
|
|
DWORD exstyle = LVS_EX_ONECLICKACTIVATE | LVS_EX_FULLROWSELECT | LVS_EX_TRACKSELECT;
|
|
SetExtendedListViewStyle(exstyle, exstyle);
|
|
// insert one column (needed to insert items)
|
|
LV_COLUMNW column = { LVCF_FMT | LVCF_WIDTH };
|
|
column.fmt = LVCFMT_LEFT;
|
|
column.cx = CX_LIST - ::GetSystemMetrics(SM_CXVSCROLL);
|
|
InsertColumn(0, &column);
|
|
return m_hWnd;
|
|
}
|
|
|
|
// set font handle
|
|
VOID CACListView::SetFont(HFONT hFont)
|
|
{
|
|
SendMessageW(WM_SETFONT, (WPARAM)hFont, TRUE); // set font
|
|
|
|
// get listview item height
|
|
m_cyItem = CY_ITEM;
|
|
HDC hDC = GetDC();
|
|
if (hDC)
|
|
{
|
|
HGDIOBJ hFontOld = ::SelectObject(hDC, hFont);
|
|
TEXTMETRICW tm;
|
|
if (::GetTextMetricsW(hDC, &tm))
|
|
{
|
|
m_cyItem = (tm.tmHeight * 3) / 2; // 3/2 of text height
|
|
}
|
|
::SelectObject(hDC, hFontOld);
|
|
ReleaseDC(hDC);
|
|
}
|
|
}
|
|
|
|
// get the number of visible items
|
|
INT CACListView::GetVisibleCount()
|
|
{
|
|
if (m_cyItem <= 0) // avoid "division by zero"
|
|
return 0;
|
|
CRect rc;
|
|
GetClientRect(&rc);
|
|
return rc.Height() / m_cyItem;
|
|
}
|
|
|
|
// get the text of an item
|
|
CStringW CACListView::GetItemText(INT iItem)
|
|
{
|
|
// NOTE: LVS_OWNERDATA doesn't support LVM_GETITEMTEXT.
|
|
ATLASSERT(m_pDropDown);
|
|
ATLASSERT(GetStyle() & LVS_OWNERDATA);
|
|
return m_pDropDown->GetItemText(iItem);
|
|
}
|
|
|
|
// get the item index from position
|
|
INT CACListView::ItemFromPoint(INT x, INT y)
|
|
{
|
|
LV_HITTESTINFO hittest;
|
|
hittest.pt.x = x;
|
|
hittest.pt.y = y;
|
|
return HitTest(&hittest);
|
|
}
|
|
|
|
// get current selection
|
|
INT CACListView::GetCurSel()
|
|
{
|
|
return GetNextItem(-1, LVNI_ALL | LVNI_SELECTED);
|
|
}
|
|
|
|
// set current selection
|
|
VOID CACListView::SetCurSel(INT iItem)
|
|
{
|
|
if (iItem == -1)
|
|
SetItemState(-1, 0, LVIS_SELECTED); // select none
|
|
else
|
|
SetItemState(iItem, LVIS_SELECTED, LVIS_SELECTED);
|
|
}
|
|
|
|
// select the specific position (in client coordinates)
|
|
VOID CACListView::SelectHere(INT x, INT y)
|
|
{
|
|
SetCurSel(ItemFromPoint(x, y));
|
|
}
|
|
|
|
// WM_LBUTTONUP / WM_MBUTTONUP / WM_RBUTTONUP @implemented
|
|
LRESULT CACListView::OnButtonUp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
TRACE("CACListView::OnButtonUp(%p)\n", this);
|
|
return 0; // eat
|
|
}
|
|
|
|
// WM_LBUTTONDOWN @implemented
|
|
// This message is posted when the user pressed the left mouse button while the cursor is inside.
|
|
LRESULT CACListView::OnLButtonDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
TRACE("CACListView::OnLButtonDown(%p)\n", this);
|
|
ATLASSERT(m_pDropDown);
|
|
INT iItem = ItemFromPoint(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
|
|
if (iItem != -1)
|
|
{
|
|
m_pDropDown->SelectItem(iItem); // select the item
|
|
CStringW strText = GetItemText(iItem); // get text of item
|
|
m_pDropDown->SetEditText(strText); // set text
|
|
m_pDropDown->SetEditSel(0, strText.GetLength()); // select all
|
|
m_pDropDown->HideDropDown(); // hide
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// WM_MBUTTONDOWN / WM_RBUTTONDOWN @implemented
|
|
LRESULT CACListView::OnMRButtonDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
TRACE("CACListView::OnMRButtonDown(%p)\n", this);
|
|
return 0; // eat
|
|
}
|
|
|
|
// WM_MOUSEWHEEL @implemented
|
|
LRESULT CACListView::OnMouseWheel(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
TRACE("CACListView::OnMouseWheel(%p)\n", this);
|
|
ATLASSERT(m_pDropDown);
|
|
LRESULT ret = DefWindowProcW(uMsg, wParam, lParam); // do default
|
|
m_pDropDown->UpdateScrollBar();
|
|
return ret;
|
|
}
|
|
|
|
// WM_NCHITTEST
|
|
LRESULT CACListView::OnNCHitTest(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
TRACE("CACListView::OnNCHitTest(%p)\n", this);
|
|
ATLASSERT(m_pDropDown);
|
|
POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) }; // in screen coordinates
|
|
ScreenToClient(&pt); // into client coordinates
|
|
HWND hwndTarget = m_pDropDown->ChildWindowFromPoint(pt);
|
|
if (hwndTarget != m_hWnd)
|
|
return HTTRANSPARENT; // pass through (for resizing the drop-down window)
|
|
bHandled = FALSE; // do default
|
|
return 0;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// CACScrollBar
|
|
|
|
HWND CACScrollBar::Create(HWND hwndParent)
|
|
{
|
|
ATLASSERT(m_hWnd == NULL);
|
|
DWORD dwStyle = WS_CHILD | /*WS_VISIBLE |*/ SBS_BOTTOMALIGN | SBS_VERT;
|
|
m_hWnd = ::CreateWindowExW(0, GetWndClassName(), NULL, dwStyle,
|
|
0, 0, 0, 0, hwndParent, NULL,
|
|
_AtlBaseModule.GetModuleInstance(), NULL);
|
|
// we don't subclass because no message handling is needed
|
|
return m_hWnd;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// CACSizeBox
|
|
|
|
HWND CACSizeBox::Create(HWND hwndParent)
|
|
{
|
|
ATLASSERT(m_hWnd == NULL);
|
|
DWORD dwStyle = WS_CHILD | /*WS_VISIBLE |*/ SBS_SIZEBOX;
|
|
HWND hWnd = ::CreateWindowExW(0, GetWndClassName(), NULL, dwStyle,
|
|
0, 0, 0, 0, hwndParent, NULL,
|
|
_AtlBaseModule.GetModuleInstance(), NULL);
|
|
SubclassWindow(hWnd); // do subclass to handle message
|
|
return m_hWnd;
|
|
}
|
|
|
|
VOID CACSizeBox::SetStatus(BOOL bDowner, BOOL bLongList)
|
|
{
|
|
// set flags
|
|
m_bDowner = bDowner;
|
|
m_bLongList = bLongList;
|
|
|
|
if (bLongList)
|
|
{
|
|
SetWindowRgn(NULL, TRUE); // reset window region
|
|
return;
|
|
}
|
|
|
|
RECT rc;
|
|
GetWindowRect(&rc); // get size-box size
|
|
::OffsetRect(&rc, -rc.left, -rc.top); // window regions use special coordinates
|
|
ATLASSERT(rc.left == 0 && rc.top == 0);
|
|
|
|
// create a trianglar region
|
|
HDC hDC = ::CreateCompatibleDC(NULL);
|
|
::BeginPath(hDC);
|
|
if (m_bDowner)
|
|
{
|
|
::MoveToEx(hDC, rc.right, 0, NULL);
|
|
::LineTo(hDC, rc.right, rc.bottom);
|
|
::LineTo(hDC, 0, rc.bottom);
|
|
::LineTo(hDC, rc.right, 0);
|
|
}
|
|
else
|
|
{
|
|
::MoveToEx(hDC, rc.right, rc.bottom, NULL);
|
|
::LineTo(hDC, rc.right, 0);
|
|
::LineTo(hDC, 0, 0);
|
|
::LineTo(hDC, rc.right, rc.bottom);
|
|
}
|
|
::EndPath(hDC);
|
|
HRGN hRgn = ::PathToRegion(hDC);
|
|
::DeleteDC(hDC);
|
|
|
|
SetWindowRgn(hRgn, TRUE); // set the trianglar region
|
|
}
|
|
|
|
// WM_ERASEBKGND
|
|
LRESULT CACSizeBox::OnEraseBkGnd(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
return TRUE; // do nothing (for quick drawing)
|
|
}
|
|
|
|
// WM_NCHITTEST
|
|
LRESULT CACSizeBox::OnNCHitTest(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
return HTTRANSPARENT; // pass through
|
|
}
|
|
|
|
// WM_PAINT
|
|
LRESULT CACSizeBox::OnPaint(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
CRect rc;
|
|
GetClientRect(&rc);
|
|
|
|
PAINTSTRUCT ps;
|
|
HDC hDC = BeginPaint(&ps);
|
|
if (!hDC)
|
|
return 0;
|
|
|
|
// fill background
|
|
::FillRect(hDC, &rc, ::GetSysColorBrush(COLOR_3DFACE));
|
|
|
|
// draw size-box
|
|
INT cxy = rc.Width();
|
|
for (INT shift = 0; shift < 2; ++shift)
|
|
{
|
|
// choose pen color
|
|
INT iColor = ((shift == 0) ? COLOR_HIGHLIGHTTEXT : COLOR_3DSHADOW);
|
|
HPEN hPen = ::CreatePen(PS_SOLID, 1, ::GetSysColor(iColor));
|
|
HGDIOBJ hPenOld = ::SelectObject(hDC, hPen);
|
|
// do loop to draw the slanted lines
|
|
for (INT delta = cxy / 4; delta < cxy; delta += cxy / 4)
|
|
{
|
|
// draw a grip line
|
|
if (m_bDowner)
|
|
{
|
|
::MoveToEx(hDC, rc.right, rc.top + delta + shift, NULL);
|
|
::LineTo(hDC, rc.left + delta + shift, rc.bottom);
|
|
}
|
|
else
|
|
{
|
|
::MoveToEx(hDC, rc.left + delta + shift, rc.top, NULL);
|
|
::LineTo(hDC, rc.right, rc.bottom - delta - shift);
|
|
}
|
|
}
|
|
// delete pen
|
|
::SelectObject(hDC, hPenOld);
|
|
::DeleteObject(hPen);
|
|
}
|
|
|
|
EndPaint(&ps);
|
|
return 0;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// CAutoComplete public methods
|
|
|
|
CAutoComplete::CAutoComplete()
|
|
: m_bInSetText(FALSE), m_bInSelectItem(FALSE)
|
|
, m_bDowner(TRUE), m_dwOptions(ACO_AUTOAPPEND | ACO_AUTOSUGGEST)
|
|
, m_bEnabled(TRUE), m_hwndCombo(NULL), m_hFont(NULL), m_bResized(FALSE)
|
|
, m_hwndEdit(NULL), m_fnOldEditProc(NULL), m_fnOldWordBreakProc(NULL)
|
|
, m_hThread(NULL), m_pThread(NULL)
|
|
{
|
|
}
|
|
|
|
HWND CAutoComplete::CreateDropDown()
|
|
{
|
|
ATLASSERT(m_hWnd == NULL);
|
|
DWORD dwStyle = WS_POPUP | /*WS_VISIBLE |*/ WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_BORDER;
|
|
DWORD dwExStyle = WS_EX_TOOLWINDOW | WS_EX_TOPMOST | WS_EX_NOPARENTNOTIFY;
|
|
Create(NULL, NULL, NULL, dwStyle, dwExStyle);
|
|
TRACE("CAutoComplete::CreateDropDown(%p): m_hWnd=%p, m_hwndEdit=%p\n",
|
|
this, m_hWnd, m_hwndEdit);
|
|
return m_hWnd;
|
|
}
|
|
|
|
CAutoComplete::~CAutoComplete()
|
|
{
|
|
TRACE("CAutoComplete::~CAutoComplete(%p)\n", this);
|
|
if (m_hThread)
|
|
{
|
|
CloseHandle(m_hThread);
|
|
m_hThread = NULL;
|
|
}
|
|
if (m_hFont)
|
|
{
|
|
::DeleteObject(m_hFont);
|
|
m_hFont = NULL;
|
|
}
|
|
// quit holding them
|
|
m_pEnum.Release();
|
|
m_pACList.Release();
|
|
}
|
|
|
|
inline BOOL CAutoComplete::CanAutoSuggest() const
|
|
{
|
|
return !!(m_dwOptions & ACO_AUTOSUGGEST) && m_bEnabled;
|
|
}
|
|
|
|
inline BOOL CAutoComplete::CanAutoAppend() const
|
|
{
|
|
return !!(m_dwOptions & ACO_AUTOAPPEND) && m_bEnabled;
|
|
}
|
|
|
|
inline BOOL CAutoComplete::UseTab() const
|
|
{
|
|
return !!(m_dwOptions & ACO_USETAB) && m_bEnabled;
|
|
}
|
|
|
|
inline BOOL CAutoComplete::IsComboBoxDropped() const
|
|
{
|
|
if (!::IsWindow(m_hwndCombo))
|
|
return FALSE;
|
|
return (BOOL)::SendMessageW(m_hwndCombo, CB_GETDROPPEDSTATE, 0, 0);
|
|
}
|
|
|
|
inline BOOL CAutoComplete::FilterPrefixes() const
|
|
{
|
|
return !!(m_dwOptions & ACO_FILTERPREFIXES) && m_bEnabled;
|
|
}
|
|
|
|
inline INT CAutoComplete::GetItemCount() const
|
|
{
|
|
return m_outerList.GetSize();
|
|
}
|
|
|
|
CStringW CAutoComplete::GetItemText(INT iItem) const
|
|
{
|
|
if (iItem < 0 || m_outerList.GetSize() <= iItem)
|
|
return L"";
|
|
return m_outerList[iItem];
|
|
}
|
|
|
|
inline CStringW CAutoComplete::GetEditText() const
|
|
{
|
|
WCHAR szText[L_MAX_URL_LENGTH];
|
|
if (::GetWindowTextW(m_hwndEdit, szText, _countof(szText)))
|
|
return szText;
|
|
return L"";
|
|
}
|
|
|
|
VOID CAutoComplete::SetEditText(LPCWSTR pszText)
|
|
{
|
|
m_bInSetText = TRUE; // don't hide drop-down
|
|
::CallWindowProcW(m_fnOldEditProc, m_hwndEdit, WM_SETTEXT, 0, reinterpret_cast<LPARAM>(pszText));
|
|
m_bInSetText = FALSE;
|
|
}
|
|
|
|
inline CStringW CAutoComplete::GetStemText(const CStringW& strText) const
|
|
{
|
|
INT ich = strText.ReverseFind(L'\\');
|
|
if (ich == -1)
|
|
return L""; // no stem
|
|
return strText.Left(ich + 1);
|
|
}
|
|
|
|
VOID CAutoComplete::SetEditSel(INT ich0, INT ich1)
|
|
{
|
|
::CallWindowProcW(m_fnOldEditProc, m_hwndEdit, EM_SETSEL, ich0, ich1);
|
|
}
|
|
|
|
VOID CAutoComplete::ShowDropDown()
|
|
{
|
|
if (!m_hWnd || !CanAutoSuggest())
|
|
return;
|
|
|
|
INT cItems = GetItemCount();
|
|
if (cItems == 0 || ::GetFocus() != m_hwndEdit || IsComboBoxDropped())
|
|
{
|
|
// hide the drop-down if necessary
|
|
HideDropDown();
|
|
return;
|
|
}
|
|
|
|
RepositionDropDown();
|
|
}
|
|
|
|
VOID CAutoComplete::HideDropDown()
|
|
{
|
|
ShowWindow(SW_HIDE);
|
|
}
|
|
|
|
VOID CAutoComplete::SelectItem(INT iItem)
|
|
{
|
|
m_hwndList.SetCurSel(iItem);
|
|
if (iItem != -1)
|
|
m_hwndList.EnsureVisible(iItem, FALSE);
|
|
}
|
|
|
|
VOID CAutoComplete::DoAutoAppend(PAC_THREAD pThread)
|
|
{
|
|
if (!CanAutoAppend()) // can we auto-append?
|
|
return; // don't append
|
|
|
|
CStringW strText = GetEditText(); // get the text
|
|
if (strText.IsEmpty())
|
|
return; // don't append
|
|
|
|
INT cItems = m_outerList.GetSize(); // get the number of items
|
|
if (cItems == 0)
|
|
return; // don't append
|
|
|
|
// get the common string
|
|
CStringW strCommon;
|
|
BOOL bFound = FALSE;
|
|
for (INT iItem = 0; iItem < cItems; ++iItem)
|
|
{
|
|
const CStringW& strItem = m_outerList[iItem]; // get the text of the item
|
|
|
|
CStringW strBody;
|
|
if (DropPrefix(strItem, strBody) &&
|
|
::StrCmpNIW(strBody, strText, strText.GetLength()) == 0)
|
|
{
|
|
if (!bFound)
|
|
{
|
|
bFound = TRUE;
|
|
strCommon = strBody;
|
|
continue;
|
|
}
|
|
for (INT ich = 0; ich < strBody.GetLength(); ++ich)
|
|
{
|
|
if (strCommon.GetLength() <= ich)
|
|
break;
|
|
if (ChrCmpIW(strCommon[ich], strBody[ich]) != 0)
|
|
{
|
|
strCommon = strCommon.Left(ich);
|
|
break;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (::StrCmpNIW(strItem, strText, strText.GetLength()) == 0)
|
|
{
|
|
if (!bFound)
|
|
{
|
|
bFound = TRUE;
|
|
strCommon = strItem;
|
|
continue;
|
|
}
|
|
|
|
for (INT ich = 0; ich < strItem.GetLength(); ++ich)
|
|
{
|
|
if (strCommon.GetLength() <= ich)
|
|
break;
|
|
if (ChrCmpIW(strCommon[ich], strItem[ich]) != 0)
|
|
{
|
|
strCommon = strCommon.Left(ich);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (strCommon.IsEmpty() || strCommon.GetLength() <= strText.GetLength())
|
|
return; // no suggestion
|
|
|
|
// append suggestion
|
|
SetEditText(strCommon);
|
|
|
|
// select the appended suggestion
|
|
SetEditSel(strText.GetLength(), strCommon.GetLength());
|
|
}
|
|
|
|
// go back a word ([Ctrl]+[Backspace])
|
|
VOID CAutoComplete::DoBackWord()
|
|
{
|
|
// get current selection
|
|
INT ich0, ich1;
|
|
::CallWindowProcW(m_fnOldEditProc, m_hwndEdit, EM_GETSEL,
|
|
reinterpret_cast<WPARAM>(&ich0), reinterpret_cast<LPARAM>(&ich1));
|
|
if (ich0 <= 0 || ich0 != ich1) // there is selection or left-side end
|
|
return; // don't do anything
|
|
// get text
|
|
CStringW str = GetEditText();
|
|
// extend the range
|
|
while (ich0 > 0 && IsWordBreak(str[ich0 - 1]))
|
|
--ich0;
|
|
while (ich0 > 0 && !IsWordBreak(str[ich0 - 1]))
|
|
--ich0;
|
|
// select range
|
|
SetEditSel(ich0, ich1);
|
|
// replace selection with empty text (this is actually deletion)
|
|
::CallWindowProcW(m_fnOldEditProc, m_hwndEdit, EM_REPLACESEL, TRUE, (LPARAM)L"");
|
|
}
|
|
|
|
VOID CAutoComplete::UpdateScrollBar()
|
|
{
|
|
// copy scroll info from m_hwndList to m_hwndScrollBar
|
|
SCROLLINFO si = { sizeof(si), SIF_ALL };
|
|
m_hwndList.GetScrollInfo(SB_VERT, &si);
|
|
m_hwndScrollBar.SetScrollInfo(SB_CTL, &si, FALSE);
|
|
|
|
// show/hide scroll bar
|
|
INT cVisibles = m_hwndList.GetVisibleCount();
|
|
INT cItems = m_hwndList.GetItemCount();
|
|
BOOL bShowScroll = (cItems > cVisibles);
|
|
m_hwndScrollBar.ShowWindow(bShowScroll ? SW_SHOWNOACTIVATE : SW_HIDE);
|
|
if (bShowScroll)
|
|
m_hwndScrollBar.InvalidateRect(NULL, FALSE); // redraw
|
|
}
|
|
|
|
BOOL CAutoComplete::OnEditKeyDown(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
TRACE("CAutoComplete::OnEditKeyDown(%p, %p)\n", this, wParam);
|
|
|
|
UINT vk = (UINT)wParam; // virtual key
|
|
switch (vk)
|
|
{
|
|
case VK_UP: case VK_DOWN:
|
|
case VK_PRIOR: case VK_NEXT:
|
|
// is suggestion available?
|
|
if (!CanAutoSuggest())
|
|
return FALSE; // do default
|
|
if (IsWindowVisible())
|
|
return OnListUpDown(vk);
|
|
break;
|
|
case VK_ESCAPE:
|
|
{
|
|
// is suggestion available?
|
|
if (!CanAutoSuggest())
|
|
return FALSE; // do default
|
|
if (IsWindowVisible())
|
|
{
|
|
SetEditText(m_strText); // revert the edit text
|
|
// select the end
|
|
INT cch = m_strText.GetLength();
|
|
SetEditSel(cch, cch);
|
|
HideDropDown(); // hide
|
|
return TRUE; // eat
|
|
}
|
|
break;
|
|
}
|
|
case VK_RETURN:
|
|
{
|
|
if (::GetKeyState(VK_CONTROL) < 0)
|
|
{
|
|
// quick edit
|
|
CStringW strText = GetEditText();
|
|
SetEditText(GetQuickEdit(strText));
|
|
}
|
|
else
|
|
{
|
|
// if item is selected, then update the edit text
|
|
INT iItem = m_hwndList.GetCurSel();
|
|
if (iItem != -1)
|
|
{
|
|
CStringW strText = GetItemText(iItem);
|
|
SetEditText(strText);
|
|
}
|
|
}
|
|
// select all
|
|
INT cch = ::CallWindowProcW(m_fnOldEditProc, m_hwndEdit, WM_GETTEXTLENGTH, 0, 0);
|
|
SetEditSel(0, cch);
|
|
// hide
|
|
HideDropDown();
|
|
break;
|
|
}
|
|
case VK_TAB:
|
|
{
|
|
// ACO_USETAB
|
|
if (IsWindowVisible() && UseTab())
|
|
{
|
|
if (GetKeyState(VK_SHIFT) < 0)
|
|
return OnListUpDown(VK_UP);
|
|
else
|
|
return OnListUpDown(VK_DOWN);
|
|
}
|
|
break;
|
|
}
|
|
case VK_DELETE:
|
|
{
|
|
// is suggestion available?
|
|
if (!CanAutoSuggest())
|
|
return FALSE; // do default
|
|
::DefSubclassProc(m_hwndEdit, WM_KEYDOWN, VK_DELETE, 0); // do default
|
|
StartCompletion(FALSE);
|
|
return TRUE; // eat
|
|
}
|
|
case VK_BACK:
|
|
{
|
|
if (::GetKeyState(VK_CONTROL) < 0)
|
|
{
|
|
DoBackWord();
|
|
return TRUE; // eat
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return FALSE; // default
|
|
}
|
|
|
|
LRESULT CAutoComplete::OnEditChar(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
TRACE("CACEditCtrl::OnEditChar(%p, %p)\n", this, wParam);
|
|
if (wParam == L'\n' || wParam == L'\t')
|
|
return 0; // eat
|
|
LRESULT ret = ::DefSubclassProc(m_hwndEdit, WM_CHAR, wParam, lParam); // do default
|
|
if (CanAutoSuggest() || CanAutoAppend())
|
|
StartCompletion(wParam != VK_BACK);
|
|
return ret;
|
|
}
|
|
|
|
VOID CAutoComplete::OnListSelChange()
|
|
{
|
|
// update EDIT text
|
|
INT iItem = m_hwndList.GetCurSel();
|
|
CStringW text = ((iItem != -1) ? GetItemText(iItem) : m_strText);
|
|
SetEditText(text);
|
|
// ensure the item visible
|
|
m_hwndList.EnsureVisible(iItem, FALSE);
|
|
// select the end
|
|
INT cch = text.GetLength();
|
|
SetEditSel(cch, cch);
|
|
}
|
|
|
|
BOOL CAutoComplete::OnListUpDown(UINT vk)
|
|
{
|
|
if (!CanAutoSuggest())
|
|
return FALSE; // default
|
|
|
|
if ((m_dwOptions & ACO_UPDOWNKEYDROPSLIST) && !IsWindowVisible())
|
|
{
|
|
ShowDropDown();
|
|
return TRUE; // eat
|
|
}
|
|
|
|
INT iItem = m_hwndList.GetCurSel(); // current selection
|
|
INT cItems = m_hwndList.GetItemCount(); // the number of items
|
|
switch (vk)
|
|
{
|
|
case VK_UP:
|
|
if (iItem == -1)
|
|
iItem = cItems - 1;
|
|
else if (iItem == 0)
|
|
iItem = -1;
|
|
else
|
|
--iItem;
|
|
m_hwndList.SetCurSel(iItem);
|
|
break;
|
|
case VK_DOWN:
|
|
if (iItem == -1)
|
|
iItem = 0;
|
|
else if (iItem == cItems - 1)
|
|
iItem = -1;
|
|
else
|
|
++iItem;
|
|
m_hwndList.SetCurSel(iItem);
|
|
break;
|
|
case VK_PRIOR:
|
|
if (iItem == -1)
|
|
{
|
|
iItem = cItems - 1;
|
|
}
|
|
else if (iItem == 0)
|
|
{
|
|
iItem = -1;
|
|
}
|
|
else
|
|
{
|
|
iItem -= m_hwndList.GetVisibleCount() - 1;
|
|
if (iItem < 0)
|
|
iItem = 0;
|
|
}
|
|
m_hwndList.SetCurSel(iItem);
|
|
break;
|
|
case VK_NEXT:
|
|
if (iItem == -1)
|
|
{
|
|
iItem = 0;
|
|
}
|
|
else if (iItem == cItems - 1)
|
|
{
|
|
iItem = -1;
|
|
}
|
|
else
|
|
{
|
|
iItem += m_hwndList.GetVisibleCount() - 1;
|
|
if (iItem > cItems)
|
|
iItem = cItems - 1;
|
|
}
|
|
m_hwndList.SetCurSel(iItem);
|
|
break;
|
|
default:
|
|
{
|
|
ATLASSERT(FALSE);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return TRUE; // eat
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// CAutoComplete IAutoComplete methods
|
|
|
|
// @implemented
|
|
STDMETHODIMP CAutoComplete::Enable(BOOL fEnable)
|
|
{
|
|
TRACE("(%p)->Enable(%d)\n", this, fEnable);
|
|
m_bEnabled = fEnable;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CAutoComplete::Init(HWND hwndEdit, IUnknown *punkACL,
|
|
LPCOLESTR pwszRegKeyPath, LPCOLESTR pwszQuickComplete)
|
|
{
|
|
TRACE("(%p)->Init(0x%08lx, %p, %s, %s)\n",
|
|
this, hwndEdit, punkACL, debugstr_w(pwszRegKeyPath), debugstr_w(pwszQuickComplete));
|
|
// sanity check
|
|
if (m_hwndEdit || !punkACL)
|
|
return E_FAIL;
|
|
if (!hwndEdit)
|
|
return E_INVALIDARG;
|
|
// do subclass textbox to watch messages
|
|
m_fnOldEditProc = reinterpret_cast<WNDPROC>(::GetWindowLongPtrW(hwndEdit, GWLP_WNDPROC));
|
|
if (!m_fnOldEditProc)
|
|
return E_FAIL;
|
|
if (!::SetWindowSubclass(hwndEdit, EditSubclassProc, 0, reinterpret_cast<DWORD_PTR>(this)))
|
|
return E_FAIL;
|
|
m_hwndEdit = hwndEdit;
|
|
// add reference to m_hwndEdit
|
|
AddRef();
|
|
// set word break procedure
|
|
m_fnOldWordBreakProc = reinterpret_cast<EDITWORDBREAKPROCW>(
|
|
::SendMessageW(m_hwndEdit, EM_SETWORDBREAKPROC, 0,
|
|
reinterpret_cast<LPARAM>(EditWordBreakProcW)));
|
|
// save position
|
|
::GetWindowRect(m_hwndEdit, &m_rcEdit);
|
|
|
|
// get an IEnumString
|
|
punkACL->QueryInterface(IID_IEnumString, (VOID **)&m_pEnum);
|
|
TRACE("m_pEnum: %p\n", static_cast<void *>(m_pEnum));
|
|
|
|
// get an IACList
|
|
punkACL->QueryInterface(IID_IACList, (VOID **)&m_pACList);
|
|
TRACE("m_pACList: %p\n", static_cast<void *>(m_pACList));
|
|
|
|
UpdateDropDownState(); // create/hide the drop-down window if necessary
|
|
|
|
// load quick completion info
|
|
LoadQuickComplete(pwszRegKeyPath, pwszQuickComplete);
|
|
|
|
// any combobox for m_hwndEdit?
|
|
m_hwndCombo = NULL;
|
|
HWND hwndParent = ::GetParent(m_hwndEdit);
|
|
WCHAR szClass[16];
|
|
if (::GetClassNameW(hwndParent, szClass, _countof(szClass)))
|
|
{
|
|
if (::StrCmpIW(szClass, WC_COMBOBOXW) == 0 ||
|
|
::StrCmpIW(szClass, WC_COMBOBOXEXW) == 0)
|
|
{
|
|
m_hwndCombo = hwndParent; // get combobox
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// CAutoComplete IAutoComplete2 methods
|
|
|
|
// @implemented
|
|
STDMETHODIMP CAutoComplete::GetOptions(DWORD *pdwFlag)
|
|
{
|
|
TRACE("(%p) -> (%p)\n", this, pdwFlag);
|
|
if (pdwFlag)
|
|
{
|
|
*pdwFlag = m_dwOptions;
|
|
return S_OK;
|
|
}
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
// @implemented
|
|
STDMETHODIMP CAutoComplete::SetOptions(DWORD dwFlag)
|
|
{
|
|
TRACE("(%p) -> (0x%x)\n", this, dwFlag);
|
|
m_dwOptions = dwFlag;
|
|
|
|
if (m_dwOptions & ACO_SEARCH)
|
|
FIXME(" ACO_SEARCH not supported\n");
|
|
if (m_dwOptions & ACO_FILTERPREFIXES)
|
|
FIXME(" ACO_FILTERPREFIXES not supported\n");
|
|
if (m_dwOptions & ACO_RTLREADING)
|
|
FIXME(" ACO_RTLREADING not supported\n");
|
|
|
|
UpdateDropDownState(); // create/hide the drop-down window if necessary
|
|
return S_OK;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// CAutoComplete IAutoCompleteDropDown methods
|
|
|
|
// @implemented
|
|
STDMETHODIMP CAutoComplete::GetDropDownStatus(DWORD *pdwFlags, LPWSTR *ppwszString)
|
|
{
|
|
BOOL dropped = m_hwndList.IsWindowVisible();
|
|
|
|
if (pdwFlags)
|
|
*pdwFlags = (dropped ? ACDD_VISIBLE : 0);
|
|
|
|
if (ppwszString)
|
|
{
|
|
*ppwszString = NULL;
|
|
|
|
if (dropped)
|
|
{
|
|
// get selected item
|
|
INT iItem = m_hwndList.GetCurSel();
|
|
if (iItem >= 0)
|
|
{
|
|
// get the text of item
|
|
CStringW strText = m_hwndList.GetItemText(iItem);
|
|
|
|
// store to *ppwszString
|
|
SHStrDupW(strText, ppwszString);
|
|
if (*ppwszString == NULL)
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CAutoComplete::ResetEnumerator()
|
|
{
|
|
FIXME("(%p): stub\n", this);
|
|
|
|
Reset();
|
|
m_hwndList.SendMessageW(LVM_SETITEMCOUNT, 0, 0);
|
|
m_outerList.RemoveAll();
|
|
return S_OK;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// CAutoComplete IEnumString methods
|
|
|
|
// @implemented
|
|
STDMETHODIMP CAutoComplete::Next(ULONG celt, LPOLESTR *rgelt, ULONG *pceltFetched)
|
|
{
|
|
TRACE("(%p, %d, %p, %p)\n", this, celt, rgelt, pceltFetched);
|
|
if (rgelt)
|
|
*rgelt = NULL;
|
|
if (*pceltFetched)
|
|
*pceltFetched = 0;
|
|
if (celt != 1 || !rgelt || !pceltFetched || !m_pEnum)
|
|
return E_INVALIDARG;
|
|
|
|
LPWSTR pszText = NULL;
|
|
HRESULT hr = m_pEnum->Next(1, &pszText, pceltFetched);
|
|
if (hr == S_OK)
|
|
*rgelt = pszText;
|
|
else
|
|
::CoTaskMemFree(pszText);
|
|
return hr;
|
|
}
|
|
|
|
// @implemented
|
|
STDMETHODIMP CAutoComplete::Skip(ULONG celt)
|
|
{
|
|
TRACE("(%p, %d)\n", this, celt);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
// @implemented
|
|
STDMETHODIMP CAutoComplete::Reset()
|
|
{
|
|
TRACE("(%p)\n", this);
|
|
if (m_pEnum)
|
|
return m_pEnum->Reset();
|
|
return E_FAIL;
|
|
}
|
|
|
|
// @implemented
|
|
STDMETHODIMP CAutoComplete::Clone(IEnumString **ppOut)
|
|
{
|
|
TRACE("(%p, %p)\n", this, ppOut);
|
|
if (ppOut)
|
|
*ppOut = NULL;
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// CAutoComplete protected methods
|
|
|
|
VOID CAutoComplete::UpdateDropDownState()
|
|
{
|
|
if (CanAutoSuggest())
|
|
{
|
|
// create the drop-down window if not existed
|
|
if (!m_hWnd)
|
|
CreateDropDown();
|
|
}
|
|
else
|
|
{
|
|
// hide if existed
|
|
if (m_hWnd)
|
|
ShowWindow(SW_HIDE);
|
|
}
|
|
}
|
|
|
|
// calculate the positions of the controls
|
|
VOID CAutoComplete::CalcRects(BOOL bDowner, RECT& rcList, RECT& rcScrollBar, RECT& rcSizeBox) const
|
|
{
|
|
// get the client rectangle
|
|
RECT rcClient;
|
|
GetClientRect(&rcClient);
|
|
|
|
// the list
|
|
rcList = rcClient;
|
|
rcList.right = rcList.left + CX_LIST;
|
|
|
|
// the scroll bar
|
|
rcScrollBar = rcClient;
|
|
rcScrollBar.left = rcClient.right - GetSystemMetrics(SM_CXVSCROLL);
|
|
if (bDowner)
|
|
{
|
|
rcScrollBar.top = 0;
|
|
rcScrollBar.bottom = rcClient.bottom - GetSystemMetrics(SM_CYHSCROLL);
|
|
}
|
|
else
|
|
{
|
|
rcScrollBar.top = GetSystemMetrics(SM_CYHSCROLL);
|
|
}
|
|
|
|
// the size box
|
|
rcSizeBox = rcClient;
|
|
rcSizeBox.left = rcClient.right - GetSystemMetrics(SM_CXVSCROLL);
|
|
if (bDowner)
|
|
{
|
|
rcSizeBox.top = rcClient.bottom - GetSystemMetrics(SM_CYHSCROLL);
|
|
}
|
|
else
|
|
{
|
|
rcSizeBox.top = 0;
|
|
rcSizeBox.bottom = rcClient.top + GetSystemMetrics(SM_CYHSCROLL);
|
|
}
|
|
}
|
|
|
|
VOID CAutoComplete::LoadQuickComplete(LPCWSTR pwszRegKeyPath, LPCWSTR pwszQuickComplete)
|
|
{
|
|
m_strQuickComplete.Empty();
|
|
|
|
if (pwszRegKeyPath)
|
|
{
|
|
CStringW strPath = pwszRegKeyPath;
|
|
INT ichSep = strPath.ReverseFind(L'\\'); // find separator
|
|
if (ichSep != -1) // found the last separator
|
|
{
|
|
// split by the separator
|
|
CStringW strKey = strPath.Left(ichSep);
|
|
CStringW strName = strPath.Mid(ichSep + 1);
|
|
|
|
// load from registry
|
|
WCHAR szValue[MAX_PATH] = L"";
|
|
DWORD cbValue = sizeof(szValue), dwType = REG_NONE;
|
|
SHRegGetUSValueW(pwszRegKeyPath, strName, &dwType,
|
|
szValue, &cbValue, FALSE, NULL, 0);
|
|
if (szValue[0] != 0 && cbValue != 0 &&
|
|
(dwType == REG_SZ || dwType == REG_EXPAND_SZ))
|
|
{
|
|
m_strQuickComplete = szValue;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pwszQuickComplete && m_strQuickComplete.IsEmpty())
|
|
{
|
|
m_strQuickComplete = pwszQuickComplete;
|
|
}
|
|
}
|
|
|
|
CStringW CAutoComplete::GetQuickEdit(LPCWSTR pszText) const
|
|
{
|
|
if (pszText[0] == 0 || m_strQuickComplete.IsEmpty())
|
|
return pszText;
|
|
|
|
// m_strQuickComplete will be "www.%s.com" etc.
|
|
CStringW ret;
|
|
ret.Format(m_strQuickComplete, pszText);
|
|
return ret;
|
|
}
|
|
|
|
VOID CAutoComplete::RepositionDropDown()
|
|
{
|
|
// get nearest monitor from m_hwndEdit
|
|
HMONITOR hMon = ::MonitorFromWindow(m_hwndEdit, MONITOR_DEFAULTTONEAREST);
|
|
ATLASSERT(hMon != NULL);
|
|
if (hMon == NULL)
|
|
return;
|
|
|
|
// get nearest monitor info
|
|
MONITORINFO mi = { sizeof(mi) };
|
|
if (!::GetMonitorInfo(hMon, &mi))
|
|
{
|
|
ATLASSERT(FALSE);
|
|
return;
|
|
}
|
|
|
|
// get count and item height
|
|
INT cItems = GetItemCount();
|
|
INT cyItem = m_hwndList.m_cyItem;
|
|
ATLASSERT(cyItem > 0);
|
|
|
|
// get m_hwndEdit position
|
|
RECT rcEdit;
|
|
::GetWindowRect(m_hwndEdit, &rcEdit);
|
|
INT x = rcEdit.left, y = rcEdit.bottom;
|
|
|
|
// get list extent
|
|
RECT rcMon = mi.rcMonitor;
|
|
INT cx = rcEdit.right - rcEdit.left, cy = cItems * cyItem;
|
|
BOOL bLongList = FALSE;
|
|
if (cy > CY_LIST)
|
|
{
|
|
cy = INT(CY_LIST / cyItem) * cyItem;
|
|
bLongList = TRUE;
|
|
}
|
|
|
|
// convert rectangle for frame
|
|
RECT rc = { 0, 0, cx, cy };
|
|
AdjustWindowRectEx(&rc, GetStyle(), FALSE, GetExStyle());
|
|
cy = rc.bottom - rc.top;
|
|
|
|
if (!m_bResized)
|
|
{
|
|
// is the drop-down window a 'downer' or 'upper'?
|
|
// NOTE: 'downer' is below the EDIT control. 'upper' is above the EDIT control.
|
|
m_bDowner = (rcEdit.bottom + cy < rcMon.bottom);
|
|
}
|
|
|
|
// adjust y and cy
|
|
if (m_bDowner)
|
|
{
|
|
if (rcMon.bottom < y + cy)
|
|
{
|
|
cy = ((rcMon.bottom - y) / cyItem) * cyItem;
|
|
bLongList = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (rcEdit.top < rcMon.top + cy)
|
|
{
|
|
cy = ((rcEdit.top - rcMon.top) / cyItem) * cyItem;
|
|
bLongList = TRUE;
|
|
}
|
|
y = rcEdit.top - cy;
|
|
}
|
|
|
|
// set status
|
|
m_hwndSizeBox.SetStatus(m_bDowner, bLongList);
|
|
|
|
if (m_bResized) // already resized?
|
|
PostMessageW(WM_SIZE, 0, 0); // re-layout
|
|
else
|
|
MoveWindow(x, y, cx, cy); // move
|
|
|
|
// show without activation
|
|
ShowWindow(SW_SHOWNOACTIVATE);
|
|
}
|
|
|
|
VOID
|
|
CAutoComplete::ExtractInnerList(CSimpleArray<CStringW>& outerList,
|
|
const CSimpleArray<CStringW>& innerList,
|
|
const CString& strText)
|
|
{
|
|
for (INT iItem = 0; iItem < innerList.GetSize(); ++iItem)
|
|
{
|
|
if (m_pThread || !m_hThread)
|
|
break;
|
|
|
|
const CStringW& strTarget = innerList[iItem];
|
|
if (DoesMatch(strTarget, strText))
|
|
{
|
|
outerList.Add(strTarget);
|
|
|
|
if (outerList.GetSize() >= MAX_ITEM_COUNT)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID CAutoComplete::ReLoadInnerList(PAC_THREAD pThread)
|
|
{
|
|
pThread->m_innerList.RemoveAll(); // clear contents
|
|
|
|
if (!m_pEnum || pThread->m_strText.IsEmpty())
|
|
return;
|
|
|
|
// reload the items
|
|
LPWSTR pszItem;
|
|
ULONG cGot;
|
|
HRESULT hr;
|
|
CSimpleArray<CStringW>& innerList = pThread->m_innerList;
|
|
while (!m_pThread && m_hThread)
|
|
{
|
|
// get next item
|
|
hr = m_pEnum->Next(1, &pszItem, &cGot);
|
|
if (hr != S_OK)
|
|
break;
|
|
|
|
innerList.Add(pszItem); // append item to innerList
|
|
::CoTaskMemFree(pszItem); // free
|
|
}
|
|
}
|
|
|
|
VOID CAutoComplete::StartCompletion(BOOL bAppendOK)
|
|
{
|
|
TRACE("CAutoComplete::StartCompletion(%p, %d)\n", this, bAppendOK);
|
|
|
|
if (!m_pEnum || (!CanAutoSuggest() && !CanAutoAppend()))
|
|
return;
|
|
|
|
::SendMessageW(m_hWnd, AUTOCOMP_START, bAppendOK, 0);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// CAutoComplete message handlers
|
|
|
|
// WM_CREATE
|
|
// This message is sent when the window is about to be created after WM_NCCREATE.
|
|
// The return value is -1 (failure) or zero (success).
|
|
LRESULT CAutoComplete::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
TRACE("CAutoComplete::OnCreate(%p)\n", this);
|
|
|
|
// set the pointer of CAutoComplete
|
|
m_hwndList.m_pDropDown = this;
|
|
m_hwndScrollBar.m_pDropDown = this;
|
|
m_hwndSizeBox.m_pDropDown = this;
|
|
|
|
// create the children
|
|
m_hwndList.Create(m_hWnd);
|
|
if (!m_hwndList)
|
|
return -1; // failure
|
|
m_hwndSizeBox.Create(m_hWnd);
|
|
if (!m_hwndSizeBox)
|
|
return -1; // failure
|
|
m_hwndScrollBar.Create(m_hWnd);
|
|
if (!m_hwndScrollBar)
|
|
return -1; // failure
|
|
|
|
// show the controls
|
|
m_hwndList.ShowWindow(SW_SHOWNOACTIVATE);
|
|
m_hwndSizeBox.ShowWindow(SW_SHOWNOACTIVATE);
|
|
m_hwndScrollBar.ShowWindow(SW_SHOWNOACTIVATE);
|
|
|
|
// set the list font
|
|
m_hFont = reinterpret_cast<HFONT>(::GetStockObject(DEFAULT_GUI_FONT));
|
|
m_hwndList.SetFont(m_hFont);
|
|
|
|
// add reference so we won't be deleted during message processing
|
|
AddRef();
|
|
return 0; // success
|
|
}
|
|
|
|
// WM_NCDESTROY
|
|
LRESULT CAutoComplete::OnNCDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
TRACE("CAutoComplete::OnNCDestroy(%p)\n", this);
|
|
|
|
// hide
|
|
if (IsWindowVisible())
|
|
HideDropDown();
|
|
|
|
// clear CAutoComplete pointers
|
|
m_hwndList.m_pDropDown = NULL;
|
|
m_hwndScrollBar.m_pDropDown = NULL;
|
|
m_hwndSizeBox.m_pDropDown = NULL;
|
|
|
|
// destroy controls
|
|
m_hwndList.DestroyWindow();
|
|
m_hwndScrollBar.DestroyWindow();
|
|
m_hwndSizeBox.DestroyWindow();
|
|
|
|
// clean up
|
|
m_hwndCombo = NULL;
|
|
|
|
// Tell ATL to clean up
|
|
bHandled = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
VOID CAutoComplete::OnFinalMessage(HWND)
|
|
{
|
|
// The message loop is finished, now we can safely destruct!
|
|
Release();
|
|
}
|
|
|
|
// WM_EXITSIZEMOVE
|
|
// This message is sent once to a window after it has exited the moving or sizing mode.
|
|
LRESULT CAutoComplete::OnExitSizeMove(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
TRACE("CAutoComplete::OnExitSizeMove(%p)\n", this);
|
|
m_bResized = TRUE; // remember resized
|
|
|
|
ModifyStyle(WS_THICKFRAME, 0); // remove thick frame to resize
|
|
// frame changed
|
|
UINT uSWP_ = SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOACTIVATE;
|
|
SetWindowPos(NULL, 0, 0, 0, 0, uSWP_);
|
|
|
|
::SetFocus(m_hwndEdit); // restore focus
|
|
return 0;
|
|
}
|
|
|
|
// WM_DRAWITEM @implemented
|
|
// This message is sent to the owner window to draw m_hwndList.
|
|
LRESULT CAutoComplete::OnDrawItem(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
LPDRAWITEMSTRUCT pDraw = reinterpret_cast<LPDRAWITEMSTRUCT>(lParam);
|
|
ATLASSERT(pDraw != NULL);
|
|
ATLASSERT(m_hwndList.GetStyle() & LVS_OWNERDRAWFIXED);
|
|
|
|
// sanity check
|
|
if (pDraw->CtlType != ODT_LISTVIEW || pDraw->hwndItem != m_hwndList)
|
|
return FALSE;
|
|
|
|
// item rectangle
|
|
RECT rcItem = pDraw->rcItem;
|
|
|
|
// get info
|
|
UINT iItem = pDraw->itemID; // the index of item
|
|
CStringW strItem = m_hwndList.GetItemText(iItem); // get text of item
|
|
|
|
// draw background and set text color
|
|
HDC hDC = pDraw->hDC;
|
|
BOOL bSelected = (pDraw->itemState & ODS_SELECTED);
|
|
if (bSelected)
|
|
{
|
|
::FillRect(hDC, &rcItem, ::GetSysColorBrush(COLOR_HIGHLIGHT));
|
|
::SetTextColor(hDC, ::GetSysColor(COLOR_HIGHLIGHTTEXT));
|
|
}
|
|
else
|
|
{
|
|
::FillRect(hDC, &rcItem, ::GetSysColorBrush(COLOR_WINDOW));
|
|
::SetTextColor(hDC, ::GetSysColor(COLOR_WINDOWTEXT));
|
|
}
|
|
|
|
// draw text
|
|
rcItem.left += ::GetSystemMetrics(SM_CXBORDER);
|
|
HGDIOBJ hFontOld = ::SelectObject(hDC, m_hFont);
|
|
const UINT uDT_ = DT_LEFT | DT_NOPREFIX | DT_SINGLELINE | DT_VCENTER;
|
|
::SetBkMode(hDC, TRANSPARENT);
|
|
::DrawTextW(hDC, strItem, -1, &rcItem, uDT_);
|
|
::SelectObject(hDC, hFontOld);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// WM_GETMINMAXINFO @implemented
|
|
// This message is sent to a window when the size or position of the window is about to change.
|
|
LRESULT CAutoComplete::OnGetMinMaxInfo(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
// restrict minimum size
|
|
LPMINMAXINFO pInfo = reinterpret_cast<LPMINMAXINFO>(lParam);
|
|
pInfo->ptMinTrackSize.x = ::GetSystemMetrics(SM_CXVSCROLL);
|
|
pInfo->ptMinTrackSize.y = ::GetSystemMetrics(SM_CYHSCROLL);
|
|
return 0;
|
|
}
|
|
|
|
// WM_MEASUREITEM @implemented
|
|
// This message is sent to the owner window to get the item extent of m_hwndList.
|
|
LRESULT CAutoComplete::OnMeasureItem(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
LPMEASUREITEMSTRUCT pMeasure = reinterpret_cast<LPMEASUREITEMSTRUCT>(lParam);
|
|
ATLASSERT(pMeasure != NULL);
|
|
if (pMeasure->CtlType != ODT_LISTVIEW)
|
|
return FALSE;
|
|
if (!m_hwndList)
|
|
return FALSE;
|
|
ATLASSERT(m_hwndList.GetStyle() & LVS_OWNERDRAWFIXED);
|
|
pMeasure->itemHeight = m_hwndList.m_cyItem; // height of item
|
|
return TRUE;
|
|
}
|
|
|
|
// WM_MOUSEACTIVATE @implemented
|
|
// The return value of this message specifies whether the window should be activated or not.
|
|
LRESULT CAutoComplete::OnMouseActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
return MA_NOACTIVATE; // don't activate by mouse
|
|
}
|
|
|
|
// WM_NCACTIVATE
|
|
// This message is sent to a window to indicate an active or inactive state.
|
|
LRESULT CAutoComplete::OnNCActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
bHandled = FALSE; // do default
|
|
return 0;
|
|
}
|
|
|
|
// WM_NCLBUTTONDOWN
|
|
LRESULT CAutoComplete::OnNCLButtonDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
switch (wParam)
|
|
{
|
|
case HTBOTTOMRIGHT: case HTTOPRIGHT:
|
|
{
|
|
// add thick frame to resize.
|
|
ModifyStyle(0, WS_THICKFRAME);
|
|
// frame changed
|
|
UINT uSWP_ = SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOACTIVATE;
|
|
SetWindowPos(NULL, 0, 0, 0, 0, uSWP_);
|
|
break;
|
|
}
|
|
}
|
|
bHandled = FALSE; // do default
|
|
return 0;
|
|
}
|
|
|
|
// WM_NOTIFY
|
|
// This message informs the parent window of a control that an event has occurred.
|
|
LRESULT CAutoComplete::OnNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
LPNMHDR pnmh = reinterpret_cast<LPNMHDR>(lParam);
|
|
ATLASSERT(pnmh != NULL);
|
|
|
|
switch (pnmh->code)
|
|
{
|
|
case NM_DBLCLK: // double-clicked
|
|
{
|
|
TRACE("NM_DBLCLK\n");
|
|
HideDropDown();
|
|
break;
|
|
}
|
|
case NM_HOVER: // mouse is hovering
|
|
{
|
|
POINT pt;
|
|
::GetCursorPos(&pt); // get cursor position in screen coordinates
|
|
m_hwndList.ScreenToClient(&pt); // into client coordinates
|
|
INT iItem = m_hwndList.ItemFromPoint(pt.x, pt.y);
|
|
if (iItem != -1)
|
|
{
|
|
m_bInSelectItem = TRUE; // don't respond
|
|
m_hwndList.SetCurSel(iItem); // select
|
|
m_bInSelectItem = FALSE;
|
|
}
|
|
return TRUE; // eat
|
|
}
|
|
case LVN_GETDISPINFOA: // for user's information only
|
|
{
|
|
TRACE("LVN_GETDISPINFOA\n");
|
|
if (pnmh->hwndFrom != m_hwndList)
|
|
break;
|
|
|
|
LV_DISPINFOA *pDispInfo = reinterpret_cast<LV_DISPINFOA *>(pnmh);
|
|
LV_ITEMA *pItem = &pDispInfo->item;
|
|
INT iItem = pItem->iItem;
|
|
if (iItem == -1)
|
|
break;
|
|
|
|
CStringW strText = GetItemText(iItem);
|
|
if (pItem->mask & LVIF_TEXT)
|
|
SHUnicodeToAnsi(strText, pItem->pszText, pItem->cchTextMax);
|
|
break;
|
|
}
|
|
case LVN_GETDISPINFOW: // for user's information only
|
|
{
|
|
TRACE("LVN_GETDISPINFOW\n");
|
|
if (pnmh->hwndFrom != m_hwndList)
|
|
break;
|
|
|
|
LV_DISPINFOW *pDispInfo = reinterpret_cast<LV_DISPINFOW *>(pnmh);
|
|
LV_ITEMW *pItem = &pDispInfo->item;
|
|
INT iItem = pItem->iItem;
|
|
if (iItem == -1)
|
|
break;
|
|
|
|
CStringW strText = GetItemText(iItem);
|
|
if (pItem->mask & LVIF_TEXT)
|
|
StringCbCopyW(pItem->pszText, pItem->cchTextMax, strText);
|
|
break;
|
|
}
|
|
case LVN_HOTTRACK: // enabled by LVS_EX_TRACKSELECT
|
|
{
|
|
TRACE("LVN_HOTTRACK\n");
|
|
LPNMLISTVIEW pListView = reinterpret_cast<LPNMLISTVIEW>(pnmh);
|
|
INT iItem = pListView->iItem;
|
|
TRACE("LVN_HOTTRACK: iItem:%d\n", iItem);
|
|
m_hwndList.SetCurSel(iItem);
|
|
m_hwndList.EnsureVisible(iItem, FALSE);
|
|
return TRUE;
|
|
}
|
|
case LVN_ITEMACTIVATE: // enabled by LVS_EX_ONECLICKACTIVATE
|
|
{
|
|
TRACE("LVN_ITEMACTIVATE\n");
|
|
LPNMITEMACTIVATE pItemActivate = reinterpret_cast<LPNMITEMACTIVATE>(pnmh);
|
|
INT iItem = pItemActivate->iItem;
|
|
TRACE("LVN_ITEMACTIVATE: iItem:%d\n", iItem);
|
|
if (iItem != -1) // the item is clicked
|
|
{
|
|
SelectItem(iItem);
|
|
HideDropDown();
|
|
}
|
|
break;
|
|
}
|
|
case LVN_ITEMCHANGED: // item info is changed
|
|
{
|
|
TRACE("LVN_ITEMCHANGED\n");
|
|
LPNMLISTVIEW pListView = reinterpret_cast<LPNMLISTVIEW>(pnmh);
|
|
if (pListView->uChanged & LVIF_STATE) // selection changed
|
|
{
|
|
// listview selection changed
|
|
if (!m_bInSelectItem)
|
|
{
|
|
OnListSelChange();
|
|
}
|
|
UpdateScrollBar();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// WM_NCHITTEST @implemented
|
|
// The return value is indicating the cursor shape and the behaviour.
|
|
LRESULT CAutoComplete::OnNCHitTest(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
TRACE("CAutoComplete::OnNCHitTest(%p)\n", this);
|
|
POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) }; // in screen coordinates
|
|
ScreenToClient(&pt); // into client coordinates
|
|
if (ChildWindowFromPoint(pt) == m_hwndSizeBox) // hit?
|
|
{
|
|
// allow resizing (with cursor shape)
|
|
return m_bDowner ? HTBOTTOMRIGHT : HTTOPRIGHT;
|
|
}
|
|
bHandled = FALSE; // do default
|
|
return 0;
|
|
}
|
|
|
|
// WM_SIZE @implemented
|
|
// This message is sent when the window size is changed.
|
|
LRESULT CAutoComplete::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
// calculate the positions of the controls
|
|
CRect rcList, rcScrollBar, rcSizeBox;
|
|
CalcRects(m_bDowner, rcList, rcScrollBar, rcSizeBox);
|
|
|
|
// reposition the controls in smartest way
|
|
UINT uSWP_ = SWP_NOACTIVATE | SWP_NOCOPYBITS;
|
|
HDWP hDWP = ::BeginDeferWindowPos(3);
|
|
hDWP = ::DeferWindowPos(hDWP, m_hwndScrollBar, HWND_TOP,
|
|
rcScrollBar.left, rcScrollBar.top,
|
|
rcScrollBar.Width(), rcScrollBar.Height(), uSWP_);
|
|
hDWP = ::DeferWindowPos(hDWP, m_hwndSizeBox, m_hwndScrollBar,
|
|
rcSizeBox.left, rcSizeBox.top,
|
|
rcSizeBox.Width(), rcSizeBox.Height(), uSWP_);
|
|
hDWP = ::DeferWindowPos(hDWP, m_hwndList, m_hwndSizeBox,
|
|
rcList.left, rcList.top,
|
|
rcList.Width(), rcList.Height(), uSWP_);
|
|
::EndDeferWindowPos(hDWP);
|
|
|
|
UpdateScrollBar();
|
|
return 0;
|
|
}
|
|
|
|
// WM_SHOWWINDOW
|
|
LRESULT CAutoComplete::OnShowWindow(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
// hook mouse events
|
|
BOOL bShow = (BOOL)wParam;
|
|
if (bShow)
|
|
{
|
|
if (s_hWatchWnd != m_hWnd && ::IsWindowVisible(s_hWatchWnd))
|
|
::ShowWindowAsync(s_hWatchWnd, SW_HIDE);
|
|
s_hWatchWnd = m_hWnd; // watch this
|
|
|
|
// unhook mouse if any
|
|
if (s_hMouseHook)
|
|
{
|
|
HHOOK hHookOld = s_hMouseHook;
|
|
s_hMouseHook = NULL;
|
|
::UnhookWindowsHookEx(hHookOld);
|
|
}
|
|
|
|
// hook mouse
|
|
s_hMouseHook = ::SetWindowsHookEx(WH_MOUSE, MouseProc, NULL, ::GetCurrentThreadId());
|
|
ATLASSERT(s_hMouseHook != NULL);
|
|
|
|
// set timer
|
|
SetTimer(WATCH_TIMER_ID, WATCH_INTERVAL, NULL);
|
|
|
|
bHandled = FALSE; // do default
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
// kill timer
|
|
KillTimer(WATCH_TIMER_ID);
|
|
|
|
s_hWatchWnd = NULL; // unwatch
|
|
|
|
// unhook mouse if any
|
|
if (s_hMouseHook)
|
|
{
|
|
HHOOK hHookOld = s_hMouseHook;
|
|
s_hMouseHook = NULL;
|
|
::UnhookWindowsHookEx(hHookOld);
|
|
}
|
|
|
|
LRESULT ret = DefWindowProcW(uMsg, wParam, lParam); // do default
|
|
|
|
if (m_hwndCombo)
|
|
::InvalidateRect(m_hwndCombo, NULL, TRUE); // redraw
|
|
|
|
m_outerList.RemoveAll(); // no use
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
// WM_TIMER
|
|
LRESULT CAutoComplete::OnTimer(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
if (wParam != WATCH_TIMER_ID) // sanity check
|
|
return 0;
|
|
|
|
// if the textbox is dead, then kill the timer
|
|
if (!::IsWindow(m_hwndEdit))
|
|
{
|
|
KillTimer(WATCH_TIMER_ID);
|
|
return 0;
|
|
}
|
|
|
|
// m_hwndEdit is moved?
|
|
RECT rcEdit;
|
|
::GetWindowRect(m_hwndEdit, &rcEdit);
|
|
if (!::EqualRect(&rcEdit, &m_rcEdit))
|
|
{
|
|
// if so, hide
|
|
HideDropDown();
|
|
|
|
m_rcEdit = rcEdit; // update rectangle
|
|
m_bResized = FALSE; // clear flag
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// WM_VSCROLL
|
|
// This message is sent when a scroll event occurs.
|
|
LRESULT CAutoComplete::OnVScroll(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
TRACE("CAutoComplete::OnVScroll(%p)\n", this);
|
|
WORD code = LOWORD(wParam);
|
|
switch (code)
|
|
{
|
|
case SB_THUMBPOSITION: case SB_THUMBTRACK:
|
|
{
|
|
// get the scrolling info
|
|
INT nPos = HIWORD(wParam);
|
|
SCROLLINFO si = { sizeof(si), SIF_ALL };
|
|
m_hwndList.GetScrollInfo(SB_VERT, &si);
|
|
|
|
// scroll the list-view by CListView::EnsureVisible
|
|
INT cItems = m_hwndList.GetItemCount();
|
|
// iItem : cItems == (nPos - si.nMin) : (si.nMax - si.nMin).
|
|
INT iItem = cItems * (nPos - si.nMin) / (si.nMax - si.nMin);
|
|
if (nPos > si.nPos)
|
|
{
|
|
iItem += m_hwndList.GetVisibleCount();
|
|
if (iItem >= cItems)
|
|
iItem = cItems - 1;
|
|
}
|
|
m_hwndList.EnsureVisible(iItem, FALSE);
|
|
|
|
// update scrolling position of m_hwndScrollBar
|
|
si.fMask = SIF_POS;
|
|
m_hwndList.GetScrollInfo(SB_VERT, &si);
|
|
m_hwndScrollBar.SetScrollInfo(SB_VERT, &si, FALSE);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
// pass it to m_hwndList
|
|
m_hwndList.SendMessageW(WM_VSCROLL, wParam, lParam);
|
|
UpdateScrollBar();
|
|
break;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static inline PAC_THREAD
|
|
InterlockedExchangeThreadData(volatile PAC_THREAD *Target, PAC_THREAD Value)
|
|
{
|
|
return reinterpret_cast<PAC_THREAD>(
|
|
::InterlockedExchangePointer(reinterpret_cast<volatile PVOID *>(Target), Value));
|
|
}
|
|
|
|
static unsigned __stdcall AutoCompThreadProc(void *arg)
|
|
{
|
|
CAutoComplete* pThis = reinterpret_cast<CAutoComplete*>(arg);
|
|
pThis->AutoCompThreadProc();
|
|
return 0;
|
|
}
|
|
|
|
VOID CAutoComplete::AutoCompThreadProc()
|
|
{
|
|
for (;;)
|
|
{
|
|
PAC_THREAD pThread = InterlockedExchangeThreadData(&m_pThread, NULL);
|
|
if (!pThread)
|
|
break;
|
|
DoThreadWork(pThread);
|
|
}
|
|
}
|
|
|
|
VOID CAutoComplete::DoThreadWork(PAC_THREAD pThread)
|
|
{
|
|
if (pThread->m_bExpand || m_innerList.GetSize() == 0)
|
|
{
|
|
ReLoadInnerList(pThread);
|
|
}
|
|
else
|
|
{
|
|
pThread->m_innerList = m_innerList;
|
|
}
|
|
|
|
if (m_pThread || !m_hThread)
|
|
{
|
|
delete pThread;
|
|
return;
|
|
}
|
|
|
|
ExtractInnerList(pThread->m_outerList, pThread->m_innerList, pThread->m_strText);
|
|
|
|
if (m_pThread || !m_hThread)
|
|
{
|
|
delete pThread;
|
|
return;
|
|
}
|
|
|
|
DoSort(pThread->m_outerList);
|
|
DoUniqueAndTrim(pThread->m_outerList);
|
|
|
|
if (m_pThread || !m_hThread ||
|
|
!::PostMessageW(m_hWnd, AUTOCOMP_FINISH, 0, (LPARAM)pThread))
|
|
{
|
|
delete pThread;
|
|
}
|
|
}
|
|
|
|
// AUTOCOMP_START
|
|
LRESULT CAutoComplete::OnAutoCompStart(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
BOOL bAppendOK = (BOOL)wParam;
|
|
|
|
CStringW strText = GetEditText();
|
|
if (m_strText.CompareNoCase(strText) == 0)
|
|
{
|
|
// no change
|
|
return 0;
|
|
}
|
|
|
|
PAC_THREAD pThread = new AC_THREAD { this, bAppendOK, strText };
|
|
|
|
// if previous text was empty
|
|
if (m_strText.IsEmpty())
|
|
{
|
|
pThread->m_bReset = TRUE;
|
|
}
|
|
m_strText = strText;
|
|
|
|
// do expand the items if the stem is changed
|
|
CStringW strStemText = GetStemText(pThread->m_strText);
|
|
if (m_strStemText.CompareNoCase(strStemText) != 0)
|
|
{
|
|
pThread->m_bReset = TRUE;
|
|
pThread->m_bExpand = !strStemText.IsEmpty();
|
|
m_strStemText = strStemText;
|
|
}
|
|
|
|
// reset if necessary
|
|
if (pThread->m_bReset && m_pEnum)
|
|
{
|
|
HRESULT hr = m_pEnum->Reset(); // IEnumString::Reset
|
|
TRACE("m_pEnum->Reset(%p): 0x%08lx\n",
|
|
static_cast<IUnknown *>(m_pEnum), hr);
|
|
}
|
|
|
|
// update ac list if necessary
|
|
if (pThread->m_bExpand && m_pACList)
|
|
{
|
|
HRESULT hr = m_pACList->Expand(strStemText); // IACList::Expand
|
|
TRACE("m_pACList->Expand(%p, %S): 0x%08lx\n",
|
|
static_cast<IUnknown *>(m_pACList),
|
|
static_cast<LPCWSTR>(strStemText), hr);
|
|
}
|
|
|
|
PAC_THREAD pOld = InterlockedExchangeThreadData(&m_pThread, pThread);
|
|
if (pOld)
|
|
delete pOld;
|
|
|
|
BOOL bDoStart = FALSE;
|
|
if (m_hThread)
|
|
{
|
|
if (WaitForSingleObject(m_hThread, 0) != WAIT_TIMEOUT)
|
|
{
|
|
CloseHandle(m_hThread);
|
|
m_hThread = NULL;
|
|
bDoStart = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bDoStart = TRUE;
|
|
}
|
|
|
|
if (bDoStart)
|
|
m_hThread = (HANDLE)_beginthreadex(NULL, 0, ::AutoCompThreadProc, this, 0, NULL);
|
|
|
|
return 0;
|
|
}
|
|
|
|
// AUTOCOMP_FINISH
|
|
LRESULT CAutoComplete::OnAutoCompFinish(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
|
|
{
|
|
PAC_THREAD pThread = reinterpret_cast<PAC_THREAD>(lParam);
|
|
if (m_pThread == NULL)
|
|
{
|
|
FinishCompletion(pThread);
|
|
}
|
|
CloseHandle(m_hThread);
|
|
m_hThread = NULL;
|
|
delete pThread;
|
|
return 0;
|
|
}
|
|
|
|
VOID CAutoComplete::FinishCompletion(PAC_THREAD pThread)
|
|
{
|
|
if (m_pThread || !m_hThread)
|
|
return;
|
|
|
|
if (!CanAutoSuggest() && !CanAutoAppend())
|
|
return;
|
|
|
|
// set inner list
|
|
m_innerList = pThread->m_innerList;
|
|
|
|
// set the items of the virtual listview
|
|
m_outerList = pThread->m_outerList; // FIXME: We need more speed!
|
|
m_hwndList.SendMessageW(LVM_SETITEMCOUNT, m_outerList.GetSize(), 0);
|
|
|
|
// save text
|
|
m_strText = pThread->m_strText;
|
|
m_strStemText = GetStemText(m_strText);
|
|
|
|
if (CanAutoSuggest()) // can we auto-suggest?
|
|
{
|
|
m_bInSelectItem = TRUE; // don't respond
|
|
SelectItem(-1); // select none
|
|
m_bInSelectItem = FALSE;
|
|
|
|
if (m_outerList.GetSize() > 0)
|
|
RepositionDropDown();
|
|
else
|
|
HideDropDown();
|
|
}
|
|
|
|
if (CanAutoAppend() && pThread->m_bAppendOK) // can we auto-append?
|
|
{
|
|
DoAutoAppend(pThread);
|
|
}
|
|
}
|