You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1020 lines
33 KiB
1020 lines
33 KiB
// Copyright 1998 Microsoft
|
|
|
|
#include "priv.h"
|
|
#include "autocomp.h"
|
|
|
|
#define AC_GIVEUP_COUNT 1000
|
|
#define AC_TIMEOUT (60 * 1000)
|
|
|
|
//
|
|
// Thread messages
|
|
//
|
|
enum
|
|
{
|
|
ACM_FIRST = WM_USER,
|
|
ACM_STARTSEARCH,
|
|
ACM_STOPSEARCH,
|
|
ACM_SETFOCUS,
|
|
ACM_KILLFOCUS,
|
|
ACM_QUIT,
|
|
ACM_LAST,
|
|
};
|
|
|
|
|
|
// Special prefixes that we optionally filter out
|
|
const struct{
|
|
int cch;
|
|
LPCWSTR psz;
|
|
}
|
|
g_rgSpecialPrefix[] =
|
|
{
|
|
{4, L"www."},
|
|
{11, L"http://www."}, // This must be before "http://"
|
|
{7, L"http://"},
|
|
{8, L"https://"},
|
|
};
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
// CACString functions - Hold autocomplete strings
|
|
//--------------------------------------------------------------------------
|
|
ULONG CACString::AddRef()
|
|
{
|
|
return InterlockedIncrement(&m_cRef);
|
|
}
|
|
|
|
ULONG CACString::Release()
|
|
{
|
|
ASSERT( 0 != m_cRef );
|
|
ULONG cRef = InterlockedDecrement(&m_cRef);
|
|
if ( 0 == cRef )
|
|
{
|
|
delete this;
|
|
}
|
|
return cRef;
|
|
}
|
|
|
|
CACString* CreateACString(LPCWSTR pszStr, int iIgnore, ULONG ulSortIndex)
|
|
{
|
|
ASSERT(pszStr);
|
|
|
|
int cChars = lstrlen(pszStr);
|
|
|
|
// Allocate the CACString class with enough room for the new string
|
|
CACString* pStr = (CACString*)LocalAlloc(LPTR, cChars * sizeof(WCHAR) + sizeof(CACString));
|
|
if (pStr)
|
|
{
|
|
StringCchCopy(pStr->m_sz, cChars + sizeof(CACString)/sizeof(WCHAR), pszStr);
|
|
|
|
pStr->m_ulSortIndex = ulSortIndex;
|
|
pStr->m_cRef = 1;
|
|
pStr->m_cChars = cChars;
|
|
pStr->m_iIgnore = iIgnore;
|
|
}
|
|
return pStr;
|
|
}
|
|
|
|
int CACString::CompareSortingIndex(CACString& r)
|
|
{
|
|
int iRet;
|
|
|
|
// If the sorting indices are equal, just do a string compare
|
|
if (m_ulSortIndex == r.m_ulSortIndex)
|
|
{
|
|
iRet = StrCmpI(r);
|
|
}
|
|
else
|
|
{
|
|
iRet = (m_ulSortIndex > r.m_ulSortIndex) ? 1 : -1;
|
|
}
|
|
|
|
return iRet;
|
|
}
|
|
|
|
HRESULT CACThread::QueryInterface(REFIID riid, void **ppvObj)
|
|
{
|
|
static const QITAB qit[] = { { 0 }, };
|
|
return QISearch(this, qit, riid, ppvObj);
|
|
}
|
|
|
|
ULONG CACThread::AddRef(void)
|
|
{
|
|
return InterlockedIncrement(&m_cRef);
|
|
}
|
|
|
|
ULONG CACThread::Release(void)
|
|
{
|
|
ASSERT( 0 != m_cRef );
|
|
ULONG cRef = InterlockedDecrement(&m_cRef);
|
|
if ( 0 == cRef )
|
|
{
|
|
delete this;
|
|
}
|
|
return cRef;
|
|
}
|
|
|
|
CACThread::CACThread(CAutoComplete& rAutoComp) : m_pAutoComp(&rAutoComp), m_cRef(1)
|
|
{
|
|
ASSERT(!m_fWorkItemQueued);
|
|
ASSERT(!m_idThread);
|
|
ASSERT(!m_hCreateEvent);
|
|
ASSERT(!m_fDisabled);
|
|
ASSERT(!m_pszSearch);
|
|
ASSERT(!m_hdpa_list);
|
|
ASSERT(!m_pes);
|
|
ASSERT(!m_pacl);
|
|
|
|
DllAddRef();
|
|
}
|
|
|
|
CACThread::~CACThread()
|
|
{
|
|
SyncShutDownBGThread(); // In case somehow
|
|
|
|
// These should have been freed.
|
|
ASSERT(!m_idThread);
|
|
ASSERT(!m_hdpa_list);
|
|
|
|
SAFERELEASE(m_pes);
|
|
SAFERELEASE(m_peac);
|
|
SAFERELEASE(m_pacl);
|
|
|
|
DllRelease();
|
|
}
|
|
|
|
BOOL CACThread::Init(IEnumString* pes, // source of the autocomplete strings
|
|
IACList* pacl) // optional interface to call Expand
|
|
{
|
|
// REARCHITECT: We need to marshal these interfaces to this thread!
|
|
ASSERT(pes);
|
|
m_pes = pes;
|
|
m_pes->AddRef();
|
|
|
|
m_peac = NULL;
|
|
pes->QueryInterface(IID_PPV_ARG(IEnumACString, &m_peac));
|
|
|
|
if (pacl)
|
|
{
|
|
m_pacl = pacl;
|
|
m_pacl->AddRef();
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
// Called when the edit box recieves focus. We use this event to create
|
|
// a background thread or to keep the backgroung thread from shutting down
|
|
//--------------------------------------------------------------------------
|
|
void CACThread::GotFocus()
|
|
{
|
|
TraceMsg(AC_GENERAL, "CACThread::GotFocus()");
|
|
|
|
// Should not be NULL if the foreground thread is calling us!
|
|
ASSERT(m_pAutoComp);
|
|
|
|
//
|
|
// Check to see if autocomplete is supposed to be enabled.
|
|
//
|
|
if (m_pAutoComp && m_pAutoComp->IsEnabled())
|
|
{
|
|
m_fDisabled = FALSE;
|
|
|
|
if (m_fWorkItemQueued)
|
|
{
|
|
// If the thread hasn't started yet, wait for a thread creation event
|
|
if (0 == m_idThread && m_hCreateEvent)
|
|
{
|
|
WaitForSingleObject(m_hCreateEvent, 1000);
|
|
}
|
|
|
|
if (m_idThread)
|
|
{
|
|
//
|
|
// Tell the thread to cancel its timeout and stay alive.
|
|
//
|
|
// REARCHITECT: We have a race condition here. The thread can be
|
|
// in the process of shutting down!
|
|
PostThreadMessage(m_idThread, ACM_SETFOCUS, 0, 0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// The background thread signals an event when it starts up.
|
|
// We wait on this event before trying a synchronous shutdown
|
|
// because any posted messages would be lost.
|
|
//
|
|
if (NULL == m_hCreateEvent)
|
|
{
|
|
m_hCreateEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
|
|
}
|
|
else
|
|
{
|
|
ResetEvent(m_hCreateEvent);
|
|
}
|
|
|
|
//
|
|
// Make sure we have a background search thread.
|
|
//
|
|
// If we start it any later, we run the risk of not
|
|
// having its message queue available by the time
|
|
// we post a message to it.
|
|
//
|
|
// AddRef ourselves now, to prevent us getting freed
|
|
// before the thread proc starts running.
|
|
//
|
|
AddRef();
|
|
|
|
// Call to Shlwapi thread pool
|
|
if (SHQueueUserWorkItem(_ThreadProc,
|
|
this,
|
|
0,
|
|
(DWORD_PTR)NULL,
|
|
NULL,
|
|
"browseui.dll",
|
|
TPS_LONGEXECTIME | TPS_DEMANDTHREAD
|
|
))
|
|
{
|
|
InterlockedExchange(&m_fWorkItemQueued, TRUE);
|
|
}
|
|
else
|
|
{
|
|
// Couldn't get thread
|
|
Release();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_fDisabled = TRUE;
|
|
_SendAsyncShutDownMsg(FALSE);
|
|
}
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
// Called when the edit box loses focus.
|
|
//--------------------------------------------------------------------------
|
|
void CACThread::LostFocus()
|
|
{
|
|
TraceMsg(AC_GENERAL, "CACThread::LostFocus()");
|
|
|
|
//
|
|
// If there is a thread around, tell it to stop searching.
|
|
//
|
|
if (m_idThread)
|
|
{
|
|
StopSearch();
|
|
PostThreadMessage(m_idThread, ACM_KILLFOCUS, 0, 0);
|
|
}
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
// Sends the search request to the background thread.
|
|
//--------------------------------------------------------------------------
|
|
BOOL CACThread::StartSearch
|
|
(
|
|
LPCWSTR pszSearch, // String to search
|
|
DWORD dwOptions // ACO_* flags
|
|
)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
|
|
// If the thread hasn't started yet, wait for a thread creation event
|
|
if (0 == m_idThread && m_fWorkItemQueued && m_hCreateEvent)
|
|
{
|
|
WaitForSingleObject(m_hCreateEvent, 1000);
|
|
}
|
|
|
|
if (m_idThread)
|
|
{
|
|
LPWSTR pszSrch = StrDup(pszSearch);
|
|
if (pszSrch)
|
|
{
|
|
//
|
|
// This is being sent to another thread, remove it from this thread's
|
|
// memlist.
|
|
//
|
|
//
|
|
// If the background thread is already searching, abort that search
|
|
//
|
|
StopSearch();
|
|
|
|
//
|
|
// Send request off to the background search thread.
|
|
//
|
|
if (PostThreadMessage(m_idThread, ACM_STARTSEARCH, dwOptions, (LPARAM)pszSrch))
|
|
{
|
|
fRet = TRUE;
|
|
}
|
|
else
|
|
{
|
|
TraceMsg(AC_GENERAL, "CACThread::_StartSearch could not send message to thread!");
|
|
LocalFree(pszSrch);
|
|
}
|
|
}
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
// Tells the background thread to stop and pending search
|
|
//--------------------------------------------------------------------------
|
|
void CACThread::StopSearch()
|
|
{
|
|
TraceMsg(AC_GENERAL, "CACThread::_StopSearch()");
|
|
|
|
//
|
|
// Tell the thread to stop.
|
|
//
|
|
if (m_idThread)
|
|
{
|
|
PostThreadMessage(m_idThread, ACM_STOPSEARCH, 0, 0);
|
|
}
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
// Posts a quit message to the background thread
|
|
//--------------------------------------------------------------------------
|
|
void CACThread::_SendAsyncShutDownMsg(BOOL fFinalShutDown)
|
|
{
|
|
if (0 == m_idThread && m_fWorkItemQueued && m_hCreateEvent)
|
|
{
|
|
//
|
|
// Make sure that the thread has started up before posting a quit
|
|
// message or the quit message will be lost!
|
|
//
|
|
WaitForSingleObject(m_hCreateEvent, 3000);
|
|
}
|
|
|
|
if (m_idThread)
|
|
{
|
|
// Stop the search because it can hold up the thread for quite a
|
|
// while by waiting for disk data.
|
|
StopSearch();
|
|
|
|
// Tell the thread to go away, we won't be needing it anymore. Note that we pass
|
|
// the dropdown window because during the final shutdown we need to asynchronously
|
|
// destroy the dropdown to avoid a crash. The background thread will keep browseui
|
|
// mapped in memory until the dropdown is destroyed.
|
|
HWND hwndDropDown = (fFinalShutDown ? m_pAutoComp->m_hwndDropDown : NULL);
|
|
|
|
PostThreadMessage(m_idThread, ACM_QUIT, 0, (LPARAM)hwndDropDown);
|
|
}
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
// Synchroniously shutdown the background thread
|
|
//
|
|
// Note: this is no longer synchronous because we now orphan this object
|
|
// when the associated autocomplet shuts down.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
void CACThread::SyncShutDownBGThread()
|
|
{
|
|
_SendAsyncShutDownMsg(TRUE);
|
|
|
|
// Block shutdown if background thread is about to use this variable
|
|
ENTERCRITICAL;
|
|
m_pAutoComp = NULL;
|
|
LEAVECRITICAL;
|
|
|
|
if (m_hCreateEvent)
|
|
{
|
|
CloseHandle(m_hCreateEvent);
|
|
m_hCreateEvent = NULL;
|
|
}
|
|
}
|
|
|
|
void CACThread::_FreeThreadData()
|
|
{
|
|
if (m_hdpa_list)
|
|
{
|
|
CAutoComplete::_FreeDPAPtrs(m_hdpa_list);
|
|
m_hdpa_list = NULL;
|
|
}
|
|
|
|
if (m_pszSearch)
|
|
{
|
|
LocalFree(m_pszSearch);
|
|
m_pszSearch = NULL;
|
|
}
|
|
|
|
InterlockedExchange(&m_idThread, 0);
|
|
InterlockedExchange(&m_fWorkItemQueued, 0);
|
|
}
|
|
|
|
DWORD WINAPI CACThread::_ThreadProc(void *pv)
|
|
{
|
|
CACThread *pThis = (CACThread *)pv;
|
|
HRESULT hrInit = SHCoInitialize();
|
|
if (SUCCEEDED(hrInit))
|
|
{
|
|
pThis->_ThreadLoop();
|
|
}
|
|
pThis->Release();
|
|
SHCoUninitialize(hrInit);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
HRESULT CACThread::_ProcessMessage(MSG * pMsg, DWORD * pdwTimeout, BOOL * pfStayAlive)
|
|
{
|
|
TraceMsg(AC_GENERAL, "AutoCompleteThread: Message %x received.", pMsg->message);
|
|
|
|
switch (pMsg->message)
|
|
{
|
|
case ACM_STARTSEARCH:
|
|
TraceMsg(AC_GENERAL, "AutoCompleteThread: Search started.");
|
|
*pdwTimeout = INFINITE;
|
|
_Search((LPWSTR)pMsg->lParam, (DWORD)pMsg->wParam);
|
|
TraceMsg(AC_GENERAL, "AutoCompleteThread: Search completed.");
|
|
break;
|
|
|
|
case ACM_STOPSEARCH:
|
|
while (PeekMessage(pMsg, pMsg->hwnd, ACM_STOPSEARCH, ACM_STOPSEARCH, PM_REMOVE))
|
|
{
|
|
NULL;
|
|
}
|
|
TraceMsg(AC_GENERAL, "AutoCompleteThread: Search stopped.");
|
|
break;
|
|
|
|
case ACM_SETFOCUS:
|
|
TraceMsg(AC_GENERAL, "AutoCompleteThread: Got Focus.");
|
|
*pdwTimeout = INFINITE;
|
|
break;
|
|
|
|
case ACM_KILLFOCUS:
|
|
TraceMsg(AC_GENERAL, "AutoCompleteThread: Lost Focus.");
|
|
*pdwTimeout = AC_TIMEOUT;
|
|
break;
|
|
|
|
case ACM_QUIT:
|
|
{
|
|
TraceMsg(AC_GENERAL, "AutoCompleteThread: ACM_QUIT received.");
|
|
*pfStayAlive = FALSE;
|
|
|
|
//
|
|
// If a hwnd was passed in then we are shutting down and we need to
|
|
// wait until the dropdown window is destroyed before exiting this
|
|
// thread. That way browseui will stay mapped in memory.
|
|
//
|
|
HWND hwndDropDown = (HWND)pMsg->lParam;
|
|
if (hwndDropDown)
|
|
{
|
|
// We wait 5 seconds for the window to go away, checking every 100ms
|
|
int cSleep = 50;
|
|
while (IsWindow(hwndDropDown) && (--cSleep > 0))
|
|
{
|
|
MsgWaitForMultipleObjects(0, NULL, FALSE, 100, QS_TIMER);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
// pump any ole-based window message that might also be on this thread
|
|
TranslateMessage(pMsg);
|
|
DispatchMessage(pMsg);
|
|
break;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
// Message pump for the background thread
|
|
//--------------------------------------------------------------------------
|
|
HRESULT CACThread::_ThreadLoop()
|
|
{
|
|
MSG Msg;
|
|
DWORD dwTimeout = INFINITE;
|
|
BOOL fStayAlive = TRUE;
|
|
|
|
TraceMsg(AC_WARNING, "AutoComplete service thread started.");
|
|
|
|
//
|
|
// We need to call a window's api for a message queue to be created
|
|
// so we call peekmessage. Then we get the thread id and thread handle
|
|
// and we signal an event to tell the forground thread that we are listening.
|
|
//
|
|
while (PeekMessage(&Msg, NULL, ACM_FIRST, ACM_LAST, PM_REMOVE))
|
|
{
|
|
// purge any messages we care about from previous owners of this thread.
|
|
}
|
|
|
|
// The forground thread needs this is so that it can post us messages
|
|
InterlockedExchange(&m_idThread, GetCurrentThreadId());
|
|
|
|
if (m_hCreateEvent)
|
|
{
|
|
SetEvent(m_hCreateEvent);
|
|
}
|
|
|
|
HANDLE hThread = GetCurrentThread();
|
|
int nOldPriority = GetThreadPriority(hThread);
|
|
SetThreadPriority(hThread, THREAD_PRIORITY_BELOW_NORMAL);
|
|
|
|
while (fStayAlive)
|
|
{
|
|
while (fStayAlive && PeekMessage(&Msg, NULL, 0, (UINT)-1, PM_NOREMOVE))
|
|
{
|
|
if (-1 != GetMessage(&Msg, NULL, 0, 0))
|
|
{
|
|
if (!Msg.hwnd)
|
|
{
|
|
// No hwnd means it's a thread message, so it's ours.
|
|
_ProcessMessage(&Msg, &dwTimeout, &fStayAlive);
|
|
}
|
|
else
|
|
{
|
|
// It has an hwnd then it's not ours. We will not allow windows on our thread.
|
|
// If anyone creates their windows on their thread, file a bug against them
|
|
// to remove it.
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fStayAlive)
|
|
{
|
|
TraceMsg(AC_GENERAL, "AutoCompleteThread: Sleeping for%s.", dwTimeout == INFINITE ? "ever" : " one minute");
|
|
DWORD dwWait = MsgWaitForMultipleObjects(0, NULL, FALSE, dwTimeout, QS_ALLINPUT);
|
|
#ifdef DEBUG
|
|
switch (dwWait)
|
|
{
|
|
case 0xFFFFFFFF:
|
|
ASSERT(dwWait != 0xFFFFFFFF);
|
|
break;
|
|
|
|
case WAIT_TIMEOUT:
|
|
TraceMsg(AC_GENERAL, "AutoCompleteThread: Timeout expired.");
|
|
break;
|
|
}
|
|
#endif
|
|
fStayAlive = (dwWait == WAIT_OBJECT_0);
|
|
}
|
|
}
|
|
|
|
TraceMsg(AC_GENERAL, "AutoCompleteThread: Thread dying.");
|
|
|
|
_FreeThreadData();
|
|
SetThreadPriority(hThread, nOldPriority);
|
|
|
|
|
|
// Purge any remaining messages before returning this thread to the pool.
|
|
while (PeekMessage(&Msg, NULL, ACM_FIRST, ACM_LAST, PM_REMOVE))
|
|
{}
|
|
|
|
TraceMsg(AC_WARNING, "AutoCompleteThread: Thread dead.");
|
|
return S_OK;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
// Returns true if the search string matches one or more characters of a
|
|
// prefix that we filter out matches to
|
|
//--------------------------------------------------------------------------
|
|
BOOL CACThread::MatchesSpecialPrefix(LPCWSTR pszSearch)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
int cchSearch = lstrlen(pszSearch);
|
|
for (int i = 0; i < ARRAYSIZE(g_rgSpecialPrefix); ++i)
|
|
{
|
|
// See if the search string matches one or more characters of the prefix
|
|
if (cchSearch <= g_rgSpecialPrefix[i].cch &&
|
|
StrCmpNI(g_rgSpecialPrefix[i].psz, pszSearch, cchSearch) == 0)
|
|
{
|
|
fRet = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
// Returns the length of the prefix it the string starts with a special
|
|
// prefix that we filter out matches to. Otherwise returns zero.
|
|
//--------------------------------------------------------------------------
|
|
int CACThread::GetSpecialPrefixLen(LPCWSTR psz)
|
|
{
|
|
int nRet = 0;
|
|
int cch = lstrlen(psz);
|
|
for (int i = 0; i < ARRAYSIZE(g_rgSpecialPrefix); ++i)
|
|
{
|
|
if (cch >= g_rgSpecialPrefix[i].cch &&
|
|
StrCmpNI(g_rgSpecialPrefix[i].psz, psz, g_rgSpecialPrefix[i].cch) == 0)
|
|
{
|
|
nRet = g_rgSpecialPrefix[i].cch;
|
|
break;
|
|
}
|
|
}
|
|
return nRet;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
// Returns the next autocomplete string
|
|
//--------------------------------------------------------------------------
|
|
HRESULT CACThread::_Next(LPWSTR pszUrl, ULONG cchMax, ULONG* pulSortIndex)
|
|
{
|
|
ASSERT(pulSortIndex);
|
|
|
|
HRESULT hr;
|
|
|
|
// Use the new interface if we have it
|
|
if (m_peac)
|
|
{
|
|
hr = m_peac->NextItem(pszUrl, cchMax, pulSortIndex);
|
|
}
|
|
|
|
// Fall back to the old IEnumString interface
|
|
else
|
|
{
|
|
LPWSTR pszNext;
|
|
ULONG ulFetched;
|
|
|
|
hr = m_pes->Next(1, &pszNext, &ulFetched);
|
|
if (S_OK == hr)
|
|
{
|
|
StringCchCopy(pszUrl, cchMax, pszNext);
|
|
if (pulSortIndex)
|
|
{
|
|
*pulSortIndex = 0;
|
|
}
|
|
CoTaskMemFree(pszNext);
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
// Searches for items that match pszSearch.
|
|
//--------------------------------------------------------------------------
|
|
void CACThread::_Search
|
|
(
|
|
LPWSTR pszSearch, // String to search for (we must free this)
|
|
DWORD dwOptions // ACO_* flags
|
|
)
|
|
{
|
|
if (pszSearch)
|
|
{
|
|
TraceMsg(AC_GENERAL, "CACThread(BGThread)::_Search(pszSearch=0x%x)", pszSearch);
|
|
|
|
// Save the search string in our thread data so it is still freed if this thread is killed
|
|
m_pszSearch = pszSearch;
|
|
|
|
// If we were passed a wildcard string, then everything matches
|
|
BOOL fWildCard = ((pszSearch[0] == CH_WILDCARD) && (pszSearch[1] == L'\0'));
|
|
|
|
// To avoid huge number of useless matches, avoid matches
|
|
// to common prefixes
|
|
BOOL fFilter = (dwOptions & ACO_FILTERPREFIXES) && MatchesSpecialPrefix(pszSearch);
|
|
BOOL fAppendOnly = IsFlagSet(dwOptions, ACO_AUTOAPPEND) && IsFlagClear(dwOptions, ACO_AUTOSUGGEST);
|
|
|
|
if (m_pes) // paranoia
|
|
{
|
|
// If this fails, the m_pes->Next() will likely do something
|
|
// bad, so we will avoid it altogether.
|
|
if (SUCCEEDED(m_pes->Reset()))
|
|
{
|
|
BOOL fStopped = FALSE;
|
|
m_dwSearchStatus = 0;
|
|
|
|
_DoExpand(pszSearch);
|
|
int cchSearch = lstrlen(pszSearch);
|
|
|
|
WCHAR szUrl[MAX_URL_STRING];
|
|
ULONG ulSortIndex;
|
|
|
|
while (!fStopped && IsFlagClear(m_dwSearchStatus, SRCH_LIMITREACHED) &&
|
|
(_Next(szUrl, ARRAYSIZE(szUrl), &ulSortIndex) == S_OK))
|
|
{
|
|
//
|
|
// First check for a simple match
|
|
//
|
|
if (fWildCard ||
|
|
(StrCmpNI(szUrl, pszSearch, cchSearch) == 0) &&
|
|
|
|
// Filter out matches to common prefixes
|
|
(!fFilter || GetSpecialPrefixLen(szUrl) == 0))
|
|
{
|
|
_AddToList(szUrl, 0, ulSortIndex);
|
|
}
|
|
|
|
// If the dropdown is enabled, check for matches after common prefixes.
|
|
if (!fAppendOnly)
|
|
{
|
|
//
|
|
// Also check for a match if we skip the protocol. We
|
|
// assume that szUrl has been cononicalized (protocol
|
|
// in lower case).
|
|
//
|
|
LPCWSTR psz = szUrl;
|
|
if (StrCmpN(szUrl, L"http://", 7) == 0)
|
|
{
|
|
psz += 7;
|
|
}
|
|
if (StrCmpN(szUrl, L"https://", 8) == 0 ||
|
|
StrCmpN(szUrl, L"file:///", 8) == 0)
|
|
{
|
|
psz += 8;
|
|
}
|
|
|
|
if (psz != szUrl &&
|
|
StrCmpNI(psz, pszSearch, cchSearch) == 0 &&
|
|
|
|
// Filter out "www." prefixes
|
|
(!fFilter || GetSpecialPrefixLen(psz) == 0))
|
|
{
|
|
_AddToList(szUrl, (int)(psz - szUrl), ulSortIndex);
|
|
}
|
|
|
|
//
|
|
// Finally check for a match if we skip "www." after
|
|
// the optional protocol
|
|
//
|
|
if (StrCmpN(psz, L"www.", 4) == 0 &&
|
|
StrCmpNI(psz + 4, pszSearch, cchSearch) == 0)
|
|
{
|
|
_AddToList(szUrl, (int)(psz + 4 - szUrl), ulSortIndex);
|
|
}
|
|
}
|
|
|
|
// Check to see if the search was canceled
|
|
MSG msg;
|
|
fStopped = PeekMessage(&msg, NULL, ACM_STOPSEARCH, ACM_STOPSEARCH, PM_NOREMOVE);
|
|
#ifdef DEBUG
|
|
fStopped = FALSE;
|
|
if (fStopped)
|
|
TraceMsg(AC_GENERAL, "AutoCompleteThread: Search TERMINATED");
|
|
#endif
|
|
}
|
|
|
|
if (fStopped)
|
|
{
|
|
// Search aborted so free the results
|
|
if (m_hdpa_list)
|
|
{
|
|
// clear the list
|
|
CAutoComplete::_FreeDPAPtrs(m_hdpa_list);
|
|
m_hdpa_list = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Sort the results and remove duplicates
|
|
//
|
|
if (m_hdpa_list)
|
|
{
|
|
DPA_Sort(m_hdpa_list, _DpaCompare, 0);
|
|
|
|
//
|
|
// Perge duplicates.
|
|
//
|
|
for (int i = DPA_GetPtrCount(m_hdpa_list) - 1; i > 0; --i)
|
|
{
|
|
CACString& rStr1 = *(CACString*)DPA_GetPtr(m_hdpa_list, i-1);
|
|
CACString& rStr2 = *(CACString*)DPA_GetPtr(m_hdpa_list, i);
|
|
|
|
// Since URLs are case sensitive, we can't ignore case.
|
|
if (rStr1.StrCmpI(rStr2) == 0)
|
|
{
|
|
// We have a match, so keep the longest string.
|
|
if (rStr1.GetLength() > rStr2.GetLength())
|
|
{
|
|
// Use the smallest sort index
|
|
if (rStr2.GetSortIndex() < rStr1.GetSortIndex())
|
|
{
|
|
rStr1.SetSortIndex(rStr2.GetSortIndex());
|
|
}
|
|
DPA_DeletePtr(m_hdpa_list, i);
|
|
rStr2.Release();
|
|
}
|
|
else
|
|
{
|
|
// Use the smallest sort index
|
|
if (rStr1.GetSortIndex() < rStr2.GetSortIndex())
|
|
{
|
|
rStr2.SetSortIndex(rStr1.GetSortIndex());
|
|
}
|
|
DPA_DeletePtr(m_hdpa_list, i-1);
|
|
rStr1.Release();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Special case: If this is a web site and the entries
|
|
// are identical except one has an extra slash on the end
|
|
// from a redirect, remove the redirected one.
|
|
//
|
|
int cch1 = rStr1.GetLengthToCompare();
|
|
int cch2 = rStr2.GetLengthToCompare();
|
|
int cchDiff = cch1 - cch2;
|
|
|
|
if (
|
|
// Length must differ by one
|
|
(cchDiff == 1 || cchDiff == -1) &&
|
|
|
|
// One string must have a terminating slash
|
|
((cch1 > 0 && rStr1[rStr1.GetLength() - 1] == L'/') ||
|
|
(cch2 > 0 && rStr2[rStr2.GetLength() - 1] == L'/')) &&
|
|
|
|
// Must be a web site
|
|
((StrCmpN(rStr1, L"http://", 7) == 0 || StrCmpN(rStr1, L"https://", 8) == 0) ||
|
|
(StrCmpN(rStr2, L"http://", 7) == 0 || StrCmpN(rStr2, L"https://", 8) == 0)) &&
|
|
|
|
// Must be identical up to the slash (ignoring prefix)
|
|
StrCmpNI(rStr1.GetStrToCompare(), rStr2.GetStrToCompare(), (cchDiff > 0) ? cch2 : cch1) == 0)
|
|
{
|
|
// Remove the longer string with the extra slash
|
|
if (cchDiff > 0)
|
|
{
|
|
// Use the smallest sort index
|
|
if (rStr1.GetSortIndex() < rStr2.GetSortIndex())
|
|
{
|
|
rStr2.SetSortIndex(rStr1.GetSortIndex());
|
|
}
|
|
DPA_DeletePtr(m_hdpa_list, i-1);
|
|
rStr1.Release();
|
|
}
|
|
else
|
|
{
|
|
// Use the smallest sort index
|
|
if (rStr2.GetSortIndex() < rStr1.GetSortIndex())
|
|
{
|
|
rStr1.SetSortIndex(rStr2.GetSortIndex());
|
|
}
|
|
DPA_DeletePtr(m_hdpa_list, i);
|
|
rStr2.Release();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pass the results to the foreground thread
|
|
ENTERCRITICAL;
|
|
if (m_pAutoComp)
|
|
{
|
|
HWND hwndEdit = m_pAutoComp->m_hwndEdit;
|
|
UINT uMsgSearchComplete = m_pAutoComp->m_uMsgSearchComplete;
|
|
LEAVECRITICAL;
|
|
|
|
// Unix loses keys if we post the message, so we send the message
|
|
// outside our critical section
|
|
SendMessage(hwndEdit, uMsgSearchComplete, m_dwSearchStatus, (LPARAM)m_hdpa_list);
|
|
}
|
|
else
|
|
{
|
|
LEAVECRITICAL;
|
|
|
|
// We've been orphaned, so free the list and bail
|
|
CAutoComplete::_FreeDPAPtrs(m_hdpa_list);
|
|
}
|
|
|
|
// The foreground thread owns the list now
|
|
m_hdpa_list = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASSERT(0); // m_pes->Reset Failed!!
|
|
}
|
|
}
|
|
|
|
// We must free the search string
|
|
m_pszSearch = NULL;
|
|
|
|
// Note if the thread is killed here, we leak the string
|
|
// but at least we will not try to free it twice (which is worse)
|
|
// because we nulled m_pszSearch first.
|
|
LocalFree(pszSearch);
|
|
}
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
// Used to sort items alphabetically
|
|
//--------------------------------------------------------------------------
|
|
int CALLBACK CACThread::_DpaCompare(void *p1, void *p2, LPARAM lParam)
|
|
{
|
|
CACString* ps1 = (CACString*)p1;
|
|
CACString* ps2 = (CACString*)p2;
|
|
|
|
return ps1->StrCmpI(*ps2);
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
// Adds a string to our HDPA. Returns TRUE is successful.
|
|
//--------------------------------------------------------------------------
|
|
BOOL CACThread::_AddToList
|
|
(
|
|
LPTSTR pszUrl, // string to add
|
|
int cchMatch, // offset into string where the match occurred
|
|
ULONG ulSortIndex // controls order of items displayed
|
|
)
|
|
{
|
|
TraceMsg(AC_GENERAL, "CACThread(BGThread)::_AddToList(pszUrl = %s)",
|
|
(pszUrl ? pszUrl : TEXT("(null)")));
|
|
|
|
BOOL fRet = TRUE;
|
|
|
|
//
|
|
// Create a new list if necessary.
|
|
//
|
|
if (!m_hdpa_list)
|
|
{
|
|
m_hdpa_list = DPA_Create(AC_LIST_GROWTH_CONST);
|
|
}
|
|
|
|
if (m_hdpa_list && DPA_GetPtrCount(m_hdpa_list) < AC_GIVEUP_COUNT)
|
|
{
|
|
CACString* pStr = CreateACString(pszUrl, cchMatch, ulSortIndex);
|
|
if (pStr)
|
|
{
|
|
if (DPA_AppendPtr(m_hdpa_list, pStr) == -1)
|
|
{
|
|
pStr->Release();
|
|
m_dwSearchStatus |= SRCH_LIMITREACHED;
|
|
fRet = FALSE;
|
|
}
|
|
|
|
// If we have a nonzero sort index, the forground thread will need
|
|
// to use it to order the results
|
|
else if (ulSortIndex)
|
|
{
|
|
m_dwSearchStatus |= SRCH_USESORTINDEX;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_dwSearchStatus |= SRCH_LIMITREACHED;
|
|
fRet = FALSE;
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
// This function will attempt to use the autocomplete list to bind to a
|
|
// location in the Shell Name Space. If that succeeds, the AutoComplete List
|
|
// will then contain entries which are the display names in that ISF.
|
|
//--------------------------------------------------------------------------
|
|
void CACThread::_DoExpand(LPCWSTR pszSearch)
|
|
{
|
|
LPCWSTR psz;
|
|
|
|
if (!m_pacl)
|
|
{
|
|
//
|
|
// Doesn't support IAutoComplete, doesn't have Expand method.
|
|
//
|
|
return;
|
|
}
|
|
|
|
if (*pszSearch == 0)
|
|
{
|
|
//
|
|
// No string means no expansion necessary.
|
|
//
|
|
return;
|
|
}
|
|
|
|
//
|
|
// psz points to last character.
|
|
//
|
|
psz = pszSearch + lstrlen(pszSearch);
|
|
psz = CharPrev(pszSearch, psz);
|
|
|
|
//
|
|
// Search backwards for an expand break character.
|
|
//
|
|
while (psz != pszSearch && *psz != TEXT('/') && *psz != TEXT('\\'))
|
|
{
|
|
psz = CharPrev(pszSearch, psz);
|
|
}
|
|
|
|
if (*psz == TEXT('/') || *psz == TEXT('\\'))
|
|
{
|
|
SHSTR ss;
|
|
|
|
psz++;
|
|
if (SUCCEEDED(ss.SetStr(pszSearch)))
|
|
{
|
|
//
|
|
// Trim ss so that it contains everything up to the last
|
|
// expand break character.
|
|
//
|
|
LPTSTR pszTemp = ss.GetInplaceStr();
|
|
|
|
pszTemp[psz - pszSearch] = TEXT('\0');
|
|
|
|
//
|
|
// Call expand on the string.
|
|
//
|
|
m_pacl->Expand(ss);
|
|
}
|
|
}
|
|
}
|