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.
538 lines
12 KiB
538 lines
12 KiB
// ProgView.cpp : Implementation of CProgView
|
|
|
|
#include "stdafx.h"
|
|
#include <commctrl.h>
|
|
#include "CompatUI.h"
|
|
#include "ProgView.h"
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CProgView
|
|
|
|
HRESULT
|
|
CProgView::InPlaceActivate(
|
|
LONG iVerb,
|
|
const RECT* prcPosRect
|
|
)
|
|
{
|
|
HRESULT hr = CComCompositeControl<CProgView>::InPlaceActivate(iVerb, prcPosRect);
|
|
|
|
|
|
/*
|
|
//
|
|
// this code below might be useful in order to deal with accelerators
|
|
// but ie host does not appear to be paying any attention
|
|
//
|
|
|
|
CComPtr<IOleControlSite> spCtlSite;
|
|
HRESULT hRet = InternalGetSite(IID_IOleControlSite, (void**)&spCtlSite);
|
|
if (SUCCEEDED(hRet)) {
|
|
spCtlSite->OnControlInfoChanged();
|
|
}
|
|
*/
|
|
|
|
return hr;
|
|
}
|
|
|
|
LRESULT
|
|
CProgView::OnNotifyListView(
|
|
int idCtrl,
|
|
LPNMHDR pnmh,
|
|
BOOL& bHandled
|
|
)
|
|
{
|
|
|
|
if (idCtrl != IDC_LISTPROGRAMS) {
|
|
bHandled = FALSE;
|
|
return 0;
|
|
}
|
|
|
|
// see that we get the notification to fill-in the details
|
|
return NotifyProgramList(m_pProgramList, pnmh, bHandled);
|
|
}
|
|
|
|
LRESULT
|
|
CProgView::OnDblclkListprograms(
|
|
int idCtrl,
|
|
LPNMHDR pnmh,
|
|
BOOL& bHandled)
|
|
{
|
|
LPNMITEMACTIVATE lpnmh;
|
|
|
|
if (idCtrl != IDC_LISTPROGRAMS) {
|
|
bHandled = FALSE;
|
|
return 0;
|
|
}
|
|
|
|
// we have a double-click !
|
|
|
|
lpnmh = (LPNMITEMACTIVATE)pnmh;
|
|
|
|
Fire_DblClk((LONG)lpnmh->uKeyFlags);
|
|
bHandled = TRUE;
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
STDMETHODIMP CProgView::GetSelectedItem()
|
|
{
|
|
|
|
GetProgramListSelection(m_pProgramList);
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CProgView::get_SelectionName(VARIANT*pVal)
|
|
{
|
|
if (!m_Safe) {
|
|
return HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
|
|
}
|
|
|
|
|
|
GetProgramListSelectionDetails(m_pProgramList, 0, pVal);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CProgView::GetSelectionInformation(LONG lInformationClass, VARIANT *pVal)
|
|
{
|
|
if (!m_Safe) {
|
|
return HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
|
|
}
|
|
|
|
GetProgramListSelectionDetails(m_pProgramList, lInformationClass, pVal);
|
|
return S_OK;
|
|
}
|
|
|
|
VOID
|
|
CProgView::ShowProgressWindows(BOOL bProgress)
|
|
{
|
|
HDWP hDefer = ::BeginDeferWindowPos(4);
|
|
|
|
if (!hDefer){
|
|
return;
|
|
}
|
|
|
|
DWORD dwProgressFlag = bProgress ? SWP_SHOWWINDOW : SWP_HIDEWINDOW;
|
|
DWORD dwListFlag = bProgress ? SWP_HIDEWINDOW : SWP_SHOWWINDOW;
|
|
|
|
hDefer = ::DeferWindowPos(hDefer, GetDlgItem(IDC_ANIMATEFIND), NULL,
|
|
0, 0, 0, 0,
|
|
SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|dwProgressFlag);
|
|
|
|
hDefer = ::DeferWindowPos(hDefer, GetDlgItem(IDC_STATUSLINE1), NULL,
|
|
0, 0, 0, 0,
|
|
SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|dwProgressFlag);
|
|
|
|
hDefer = ::DeferWindowPos(hDefer, GetDlgItem(IDC_STATUSLINE2), NULL,
|
|
0, 0, 0, 0,
|
|
SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|dwProgressFlag);
|
|
|
|
hDefer = ::DeferWindowPos(hDefer, GetDlgItem(IDC_LISTPROGRAMS), NULL,
|
|
0, 0, 0, 0,
|
|
SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|dwListFlag);
|
|
|
|
|
|
EndDeferWindowPos(hDefer);
|
|
|
|
}
|
|
|
|
STDMETHODIMP CProgView::PopulateList()
|
|
{
|
|
HANDLE hThread;
|
|
|
|
ResetEvent(m_hEventCancel);
|
|
ResetEvent(m_hEventCmd);
|
|
|
|
if (!m_bInPlaceActive) {
|
|
InPlaceActivate(OLEIVERB_INPLACEACTIVATE);
|
|
}
|
|
if (m_hThreadPopulate == NULL) {
|
|
m_hThreadPopulate = CreateThread(NULL, 0, _PopulateThreadProc, (LPVOID)this, 0, NULL);
|
|
}
|
|
|
|
if (m_hThreadPopulate != NULL && !IsScanInProgress()) {
|
|
m_nCmdPopulate = CMD_SCAN;
|
|
SetEvent(m_hEventCmd);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
BOOL CProgView::PopulateListInternal()
|
|
{
|
|
|
|
if (InterlockedCompareExchange(&m_PopulateInProgress, TRUE, FALSE) == TRUE) {
|
|
//
|
|
// populate in progress -- quit
|
|
//
|
|
return FALSE;
|
|
}
|
|
|
|
if (m_pProgramList != NULL) {
|
|
CleanupProgramList(m_pProgramList);
|
|
m_pProgramList = NULL;
|
|
|
|
}
|
|
|
|
ShowProgressWindows(TRUE);
|
|
Animate_OpenEx(GetDlgItem(IDC_ANIMATEFIND), _Module.GetModuleInstance(), MAKEINTRESOURCE(IDA_FINDANIM));
|
|
Animate_Play(GetDlgItem(IDC_ANIMATEFIND), 0, -1, -1);
|
|
|
|
PostMessage(WM_VIEW_CHANGED);
|
|
|
|
// FireViewChange();
|
|
|
|
// if (m_bInPlaceActive) {
|
|
/* HCURSOR hcWait = (HCURSOR)::LoadImage(NULL,
|
|
MAKEINTRESOURCE(IDC_WAIT),
|
|
IMAGE_CURSOR,
|
|
0, 0,
|
|
LR_DEFAULTSIZE|LR_SHARED);
|
|
|
|
// HCURSOR hcWait = ::LoadCursor(_Module.GetResourceInstance(),
|
|
// MAKEINTRESOURCE(IDC_WAIT));
|
|
|
|
|
|
HCURSOR hcSave = SetCursor(hcWait);
|
|
*/
|
|
|
|
//
|
|
// malloc used on this thread should NOT be used on UI thread
|
|
//
|
|
|
|
InitializeProgramList(&m_pProgramList, GetDlgItem(IDC_LISTPROGRAMS));
|
|
PopulateProgramList(m_pProgramList, this, m_hEventCancel);
|
|
|
|
// SetCursor(hcSave);
|
|
|
|
Animate_Stop(GetDlgItem(IDC_ANIMATEFIND));
|
|
Animate_Close(GetDlgItem(IDC_ANIMATEFIND));
|
|
ShowProgressWindows();
|
|
|
|
InterlockedCompareExchange(&m_PopulateInProgress, FALSE, TRUE);
|
|
|
|
PostMessage(WM_VIEW_CHANGED);
|
|
PostMessage(WM_LIST_POPULATED); // we are done, signal to the main thread
|
|
|
|
|
|
// FireViewChange();
|
|
|
|
// } else {
|
|
// m_bPendingPopulate = TRUE;
|
|
// }
|
|
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
DWORD WINAPI
|
|
CProgView::_PopulateThreadProc(
|
|
LPVOID lpvParam
|
|
)
|
|
{
|
|
CProgView* pProgView = (CProgView*)lpvParam;
|
|
DWORD dwWait;
|
|
BOOL bExit = FALSE;
|
|
HRESULT hr = CoInitialize(NULL);
|
|
if (!SUCCEEDED(hr)) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// keep this thread alive, block it on a command event
|
|
//
|
|
while(!bExit) {
|
|
dwWait = WaitForSingleObject(pProgView->m_hEventCmd, INFINITE);
|
|
if (dwWait != WAIT_OBJECT_0) {
|
|
break; // get out, we are being killed
|
|
}
|
|
//
|
|
// get the command
|
|
//
|
|
switch(pProgView->m_nCmdPopulate) {
|
|
case CMD_NONE:
|
|
break;
|
|
|
|
case CMD_EXIT:
|
|
bExit = TRUE;
|
|
//
|
|
// intentional fall-through
|
|
//
|
|
|
|
case CMD_CLEANUP:
|
|
if (pProgView->m_pProgramList) {
|
|
CleanupProgramList(pProgView->m_pProgramList);
|
|
pProgView->m_pProgramList = NULL;
|
|
}
|
|
break;
|
|
|
|
case CMD_SCAN:
|
|
pProgView->PopulateListInternal();
|
|
break;
|
|
}
|
|
|
|
pProgView->m_nCmdPopulate = CMD_NONE;
|
|
}
|
|
CoUninitialize();
|
|
return TRUE;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CProgView::UpdateListItem(
|
|
BSTR pTarget,
|
|
VARIANT *pKeys,
|
|
BOOL *pResult
|
|
)
|
|
{
|
|
VARIANT vKeys;
|
|
VariantInit(&vKeys);
|
|
CComBSTR bstrKeys;
|
|
HRESULT hr;
|
|
|
|
if (!m_pProgramList) {
|
|
return S_OK;
|
|
}
|
|
|
|
if (!m_Safe) {
|
|
return HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
|
|
}
|
|
|
|
|
|
if (pKeys->vt == VT_NULL || pKeys->vt == VT_EMPTY) {
|
|
*pResult = UpdateProgramListItem(m_pProgramList, pTarget, NULL);
|
|
return S_OK;
|
|
}
|
|
|
|
hr = VariantChangeType(&vKeys, pKeys, 0, VT_BSTR);
|
|
if (SUCCEEDED(hr)) {
|
|
bstrKeys = vKeys.bstrVal;
|
|
|
|
if (bstrKeys.Length()) {
|
|
*pResult = UpdateProgramListItem(m_pProgramList, pTarget, bstrKeys);
|
|
} else {
|
|
*pResult = FALSE;
|
|
}
|
|
}
|
|
|
|
VariantClear(&vKeys);
|
|
return S_OK;
|
|
}
|
|
|
|
BOOL
|
|
CProgView::PreTranslateAccelerator(
|
|
LPMSG pMsg,
|
|
HRESULT& hRet
|
|
)
|
|
{
|
|
HWND hWndCtl;
|
|
HWND hwndList = GetDlgItem(IDC_LISTPROGRAMS);
|
|
|
|
hRet = S_OK;
|
|
hWndCtl = ::GetFocus();
|
|
if (IsChild(hWndCtl) && ::GetParent(hWndCtl) != m_hWnd) {
|
|
do {
|
|
hWndCtl = ::GetParent(hWndCtl);
|
|
} while (::GetParent(hWndCtl) != m_hWnd);
|
|
}
|
|
|
|
if (hWndCtl == hwndList &&
|
|
pMsg->message == WM_KEYDOWN &&
|
|
(LOWORD(pMsg->wParam) == VK_RETURN ||
|
|
LOWORD(pMsg->wParam) == VK_EXECUTE)) {
|
|
|
|
if (ListView_GetNextItem(hwndList, -1, LVNI_SELECTED) >= 0) {
|
|
Fire_DblClk(0);
|
|
return TRUE;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// check for external accelerators because the next call is going to eat the message
|
|
//
|
|
if (m_ExternAccel.IsAccelKey(pMsg)) { // we do not touch external accel messages
|
|
return FALSE;
|
|
}
|
|
|
|
return CComCompositeControl<CProgView>::PreTranslateAccelerator(pMsg, hRet);
|
|
}
|
|
|
|
|
|
STDMETHODIMP CProgView::CancelPopulateList()
|
|
{
|
|
if (m_hEventCancel && InterlockedCompareExchange(&m_PopulateInProgress, TRUE, TRUE) == TRUE) {
|
|
SetEvent(m_hEventCancel);
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CProgView::get_AccelCmd(LONG lCmd, BSTR *pVal)
|
|
{
|
|
CComBSTR bstrAccel = m_Accel.GetAccelString((WORD)lCmd).c_str();
|
|
*pVal = bstrAccel.Copy();
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CProgView::put_AccelCmd(LONG lCmd, BSTR newVal)
|
|
{
|
|
m_Accel.SetAccel(newVal);
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CProgView::ClearAccel()
|
|
{
|
|
m_Accel.ClearAccel();
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CProgView::get_ExternAccel(BSTR *pVal)
|
|
{
|
|
CComBSTR bstrAccel = m_ExternAccel.GetAccelString().c_str();
|
|
*pVal = bstrAccel.Copy();
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CProgView::put_ExternAccel(BSTR newVal)
|
|
{
|
|
m_ExternAccel.SetAccel(newVal);
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CProgView::ClearExternAccel()
|
|
{
|
|
m_ExternAccel.ClearAccel();
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CProgView::get_ItemCount(VARIANT* pVal)
|
|
{
|
|
if (!m_Safe) {
|
|
return HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
|
|
}
|
|
|
|
pVal->vt = VT_I4;
|
|
pVal->intVal = (int)ListView_GetItemCount(GetDlgItem(IDC_LISTPROGRAMS));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// in upload.c
|
|
//
|
|
wstring StrUpCase(wstring& wstr);
|
|
|
|
//
|
|
// expand env -- lives in util.cpp
|
|
// we have a bit differing implementation here
|
|
//
|
|
|
|
wstring
|
|
ExpandEnvironmentVars(
|
|
LPCTSTR lpszCmd
|
|
)
|
|
{
|
|
DWORD dwLength;
|
|
LPTSTR lpBuffer = NULL;
|
|
BOOL bExpanded = FALSE;
|
|
wstring strCmd;
|
|
TCHAR szBuffer[MAX_PATH];
|
|
|
|
if (_tcschr(lpszCmd, TEXT('%')) == NULL) {
|
|
goto out;
|
|
}
|
|
|
|
dwLength = ExpandEnvironmentStrings(lpszCmd, NULL, 0);
|
|
if (!dwLength) {
|
|
goto out;
|
|
}
|
|
|
|
if (dwLength < CHARCOUNT(szBuffer)) {
|
|
lpBuffer = szBuffer;
|
|
} else {
|
|
lpBuffer = new TCHAR[dwLength];
|
|
if (NULL == lpBuffer) {
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
dwLength = ExpandEnvironmentStrings(lpszCmd, lpBuffer, dwLength);
|
|
if (!dwLength) {
|
|
goto out;
|
|
}
|
|
|
|
strCmd = lpBuffer;
|
|
bExpanded = TRUE;
|
|
|
|
out:
|
|
if (!bExpanded) {
|
|
strCmd = lpszCmd;
|
|
}
|
|
if (lpBuffer && lpBuffer != szBuffer) {
|
|
delete[] lpBuffer;
|
|
}
|
|
return strCmd;
|
|
}
|
|
|
|
STDMETHODIMP CProgView::put_ExcludeFiles(BSTR newVal)
|
|
{
|
|
// parse exclude files, put them into our blacklist
|
|
wstring strFile;
|
|
LPCWSTR pch = newVal;
|
|
LPCWSTR pend;
|
|
|
|
m_ExcludedFiles.clear();
|
|
|
|
while (pch != NULL && *pch != TEXT('\0')) {
|
|
|
|
pch += _tcsspn(pch, TEXT(" \t"));
|
|
// begining
|
|
// find the ;
|
|
pend = _tcschr(pch, TEXT(';'));
|
|
if (pend == NULL) {
|
|
// from pch to the end
|
|
strFile = pch;
|
|
pch = NULL; // will bail out
|
|
} else {
|
|
strFile = wstring(pch, (wstring::size_type)(pend - pch));
|
|
pch = pend + 1; // one past ;
|
|
}
|
|
|
|
// add
|
|
if (strFile.length()) {
|
|
strFile = ExpandEnvironmentVars(strFile.c_str());
|
|
m_ExcludedFiles.insert(StrUpCase(strFile));
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CProgView::get_ExcludeFiles(BSTR* pVal)
|
|
{
|
|
// parse exclude files, put them into our blacklist
|
|
STRSET::iterator iter;
|
|
CComBSTR bstrFiles;
|
|
|
|
for (iter = m_ExcludedFiles.begin(); iter != m_ExcludedFiles.end(); ++iter) {
|
|
if (bstrFiles.Length()) {
|
|
bstrFiles += TEXT(';');
|
|
}
|
|
bstrFiles += (*iter).c_str();
|
|
}
|
|
|
|
*pVal = bstrFiles.Copy();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
BOOL CProgView::IsFileExcluded(LPCTSTR pszFile)
|
|
{
|
|
wstring strFile = pszFile;
|
|
STRSET::iterator iter;
|
|
|
|
iter = m_ExcludedFiles.find(StrUpCase(strFile));
|
|
return iter != m_ExcludedFiles.end();
|
|
}
|