375 lines
10 KiB
C++
375 lines
10 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1997-2001.
|
|
//
|
|
// File: Util.cpp
|
|
//
|
|
// Contents:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
/////////////////////////////////////////////////////////////////////
|
|
// Util.cpp
|
|
//
|
|
// Utility routines.
|
|
//
|
|
// HISTORY
|
|
// 4-Aug-97 t-danm Creation.
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
#include "stdafx.h"
|
|
#include "debug.h"
|
|
#include "util.h"
|
|
#include "resource.h"
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
// ListView_FindString()
|
|
//
|
|
// Searches the listview items and return the index of the item
|
|
// matching the string. Return -1 if no matches.
|
|
//
|
|
// INTERFACE NOTES
|
|
// Although not documented, the search is performed without case.
|
|
//
|
|
int
|
|
ListView_FindString(
|
|
HWND hwndListview,
|
|
LPCTSTR pszTextSearch)
|
|
{
|
|
Assert(IsWindow(hwndListview));
|
|
Assert(pszTextSearch != NULL);
|
|
|
|
LV_FINDINFO lvFindInfo;
|
|
GarbageInit(&lvFindInfo, sizeof(lvFindInfo));
|
|
lvFindInfo.flags = LVFI_STRING;
|
|
lvFindInfo.psz = pszTextSearch;
|
|
return ListView_FindItem(hwndListview, -1, &lvFindInfo);
|
|
} // ListView_FindString()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
// ListView_GetSelectedItem()
|
|
//
|
|
// Return the index of the selected item.
|
|
// If no items are selected, return -1.
|
|
//
|
|
int
|
|
ListView_GetSelectedItem(HWND hwndListview)
|
|
{
|
|
Assert(IsWindow(hwndListview));
|
|
return ListView_GetNextItem(hwndListview, -1, LVNI_SELECTED);
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
// ListView_SelectItem()
|
|
//
|
|
// Set the selection of a specific listview item.
|
|
//
|
|
void
|
|
ListView_SelectItem(
|
|
HWND hwndListview,
|
|
int iItem)
|
|
{
|
|
Assert(IsWindow(hwndListview));
|
|
Assert(iItem >= 0);
|
|
ListView_SetItemState(hwndListview, iItem, LVIS_SELECTED, LVIS_SELECTED);
|
|
} // ListView_SelectItem()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
// ListView_UnselectItem()
|
|
//
|
|
// Clear the selection of a specific listview item.
|
|
//
|
|
void
|
|
ListView_UnselectItem(
|
|
HWND hwndListview,
|
|
int iItem)
|
|
{
|
|
Assert(IsWindow(hwndListview));
|
|
Assert(iItem >= 0);
|
|
ListView_SetItemState(hwndListview, iItem, 0, LVIS_SELECTED);
|
|
} // ListView_UnselectItem()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
// ListView_UnselectAllItems()
|
|
//
|
|
// Remove the selection of any selected item.
|
|
//
|
|
void
|
|
ListView_UnselectAllItems(HWND hwndListview)
|
|
{
|
|
Assert(IsWindow(hwndListview));
|
|
|
|
int iItem = -1;
|
|
while (TRUE)
|
|
{
|
|
// Search the listview for any selected items
|
|
iItem = ListView_GetNextItem(hwndListview, iItem, LVNI_SELECTED);
|
|
if (iItem < 0)
|
|
break;
|
|
// Clear the selection
|
|
ListView_SetItemState(hwndListview, iItem, 0, LVIS_SELECTED);
|
|
}
|
|
} // ListView_UnselectAllItems()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
// ListView_SetItemImage()
|
|
//
|
|
// Change the image of a listview item.
|
|
//
|
|
void
|
|
ListView_SetItemImage(HWND hwndListview, int iItem, int iImage)
|
|
{
|
|
Assert(IsWindow(hwndListview));
|
|
Assert(iItem >= 0);
|
|
|
|
LV_ITEM lvItem;
|
|
GarbageInit(OUT &lvItem, sizeof(lvItem));
|
|
lvItem.mask = LVIF_IMAGE;
|
|
lvItem.iItem = iItem;
|
|
lvItem.iSubItem = 0;
|
|
lvItem.iImage = iImage;
|
|
ListView_SetItem(hwndListview, IN &lvItem);
|
|
} // ListView_SetItemImage()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// FTrimString()
|
|
//
|
|
// Trim leading and trailing spaces of the string.
|
|
// Return TRUE if one or more spaces has been removed, otherwise FALSE.
|
|
//
|
|
BOOL FTrimString(INOUT TCHAR szString[])
|
|
{
|
|
TCHAR * pchSrc;
|
|
TCHAR * pchDst;
|
|
|
|
Assert(szString != NULL);
|
|
if (szString[0] == 0)
|
|
return FALSE;
|
|
pchSrc = szString;
|
|
if (*pchSrc == ' ')
|
|
{
|
|
while (*pchSrc == ' ')
|
|
pchSrc++;
|
|
pchDst = szString;
|
|
do
|
|
{
|
|
*pchDst++ = *pchSrc++;
|
|
}
|
|
while (*pchSrc != '\0');
|
|
|
|
while (pchDst > szString && *(pchDst - 1) == ' ')
|
|
pchDst--;
|
|
*pchDst = '\0';
|
|
return TRUE;
|
|
}
|
|
pchDst = szString;
|
|
while (*pchDst != '\0')
|
|
pchDst++;
|
|
Assert(pchDst > szString);
|
|
if (*(pchDst - 1) != ' ')
|
|
return FALSE;
|
|
while (pchDst > szString && *(pchDst - 1) == ' ')
|
|
pchDst--;
|
|
*pchDst = '\0';
|
|
return TRUE;
|
|
} // FTrimString()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
INT_PTR DoDialogBox(
|
|
UINT wIdDialog,
|
|
HWND hwndParent,
|
|
DLGPROC dlgproc,
|
|
LPARAM lParam)
|
|
{
|
|
Assert(wIdDialog != 0);
|
|
Endorse(hwndParent == NULL);
|
|
Assert(dlgproc != NULL);
|
|
Endorse(lParam == NULL);
|
|
|
|
INT_PTR nResult = ::DialogBoxParam(
|
|
g_hInstance,
|
|
MAKEINTRESOURCE(wIdDialog),
|
|
hwndParent, (DLGPROC)dlgproc,
|
|
lParam);
|
|
Report(nResult != -1 && "Failure to display dialog");
|
|
return nResult;
|
|
} // DoDialogBox()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
int DoMessageBox(
|
|
UINT uStringId,
|
|
UINT uFlags)
|
|
{
|
|
TCHAR szCaption[128];
|
|
TCHAR szMessage[512];
|
|
|
|
CchLoadString(IDS_CAPTION, OUT szCaption, LENGTH(szCaption));
|
|
CchLoadString(uStringId, OUT szMessage, LENGTH(szMessage));
|
|
return ::MessageBox(::GetActiveWindow(), szMessage, szCaption, uFlags);
|
|
} // DoMessageBox()
|
|
|
|
#ifdef DEBUG
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CchLoadString()
|
|
//
|
|
// Same as ::LoadString() but with extra error checking.
|
|
// CchLoadString is #defined to ::LoadString in the retail build.
|
|
//
|
|
int CchLoadString(
|
|
UINT uIdString, // IN: String Id
|
|
TCHAR szBuffer[], // OUT: Buffer to receive the string
|
|
int cchBuffer) // IN: Length of the buffer (in characters; not in bytes)
|
|
{
|
|
int cch;
|
|
|
|
Assert(szBuffer != NULL);
|
|
cch = ::LoadString(g_hInstance, uIdString, OUT szBuffer, cchBuffer);
|
|
Report(cch > 0 && "String not found");
|
|
Report(cch < cchBuffer - 2 && "Output buffer too small");
|
|
return cch;
|
|
} // CchLoadString()
|
|
|
|
#endif // DEBUG
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
// RegOpenOrCreateKey()
|
|
//
|
|
// Open an existing key or create it if does not exists
|
|
//
|
|
HKEY
|
|
RegOpenOrCreateKey(
|
|
HKEY hkeyRoot, // IN: Root of an existing key
|
|
const TCHAR szSubkey[]) // IN: Subkey to create
|
|
{
|
|
Assert(hkeyRoot != NULL);
|
|
Assert(szSubkey != NULL);
|
|
HKEY hkey; // Primary Registry key
|
|
DWORD dwDisposition; // Disposition (REG_OPENED_EXISTING_KEY or REG_CREATED_NEW_KEY)
|
|
LONG lRetCode; // Code returned by the Registry functions
|
|
lRetCode = RegCreateKeyEx(
|
|
hkeyRoot, szSubkey,
|
|
0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS,
|
|
NULL, // SecurityAttributes
|
|
&hkey, // OUT: Returned registry key handle
|
|
&dwDisposition); // OUT: Returned disposition
|
|
if (lRetCode != ERROR_SUCCESS)
|
|
{
|
|
Assert(hkey == NULL);
|
|
return NULL;
|
|
}
|
|
return hkey;
|
|
} // RegOpenOrCreateKey()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
// RegWriteString()
|
|
//
|
|
// Write a tring to the Registry.
|
|
//
|
|
BOOL
|
|
RegWriteString(
|
|
HKEY hkey, // IN: Key to append to
|
|
const TCHAR szKey[], // IN: Key to save
|
|
const TCHAR szValue[]) // IN: Value of the key
|
|
{
|
|
Assert(hkey != NULL); // Verify Registry has been opened
|
|
Assert(szKey != NULL);
|
|
Assert(szValue != NULL);
|
|
LONG lRetCode = RegSetValueEx(hkey, szKey, 0, REG_SZ,
|
|
(LPBYTE)szValue, lstrlen(szValue) * sizeof(TCHAR));
|
|
// There should be no error writing to the Registry
|
|
Report((lRetCode == ERROR_SUCCESS) && "RegWriteString() - Error writing to Registry");
|
|
return (lRetCode == ERROR_SUCCESS);
|
|
} // RegWriteString()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
BOOL
|
|
RegWriteString(
|
|
HKEY hkey, // IN: Key to append to
|
|
const TCHAR szKey[], // IN: Key to save
|
|
UINT uStringId) // IN: Value of the key
|
|
{
|
|
if ( szKey )
|
|
{
|
|
TCHAR szValue[512];
|
|
CchLoadString(uStringId, OUT szValue, LENGTH(szValue));
|
|
return RegWriteString(hkey, szKey, szValue);
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// HrExtractDataAlloc()
|
|
//
|
|
// Extract data from a source DataObject for a particular clipboard format.
|
|
//
|
|
// RETURNS
|
|
// Return S_OK if data was successfully retrieved and placed into allocated buffer.
|
|
//
|
|
// INTERFACE NOTES
|
|
// The routine will allocate memory, copy the data from the source to
|
|
// the allocated buffer and return a pointer to the allocated buffer.
|
|
// The caller is responsible to free the allocated memory using GlobalFree()
|
|
// when no longer needed.
|
|
//
|
|
// IMPLEMENTATION NOTES
|
|
// The memory block is allocated by pDataObject->GetData() rather
|
|
// than by the routine itself.
|
|
//
|
|
// HISTORY
|
|
// 12-Aug-97 t-danm Creation.
|
|
//
|
|
HRESULT
|
|
HrExtractDataAlloc(
|
|
IDataObject * pDataObject, // IN: Data source to extract data from
|
|
UINT cfClipboardFormat, // IN: Clipboard format to extract data
|
|
PVOID * ppavData, // OUT: Pointer to allocated memory
|
|
UINT * pcbData) // OUT: OPTIONAL: Number of bytes stored in memory buffer
|
|
{
|
|
Assert(pDataObject != NULL);
|
|
Assert(cfClipboardFormat != NULL);
|
|
Assert(ppavData != NULL);
|
|
Assert(*ppavData == NULL && "Memory Leak");
|
|
Endorse(pcbData == NULL); // TRUE => Don't care about the size of the allocated buffer
|
|
|
|
FORMATETC formatetc = { (CLIPFORMAT)cfClipboardFormat, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
|
|
STGMEDIUM stgmedium = { TYMED_HGLOBAL, NULL };
|
|
Assert(stgmedium.hGlobal == NULL);
|
|
HRESULT hr = pDataObject->GetData(IN &formatetc, OUT &stgmedium);
|
|
if (FAILED(hr))
|
|
{
|
|
Trace1("HrExtractDataAlloc() - Call to pDataObject->GetData() failed. hr=0x%X.\n", hr);
|
|
return hr;
|
|
}
|
|
if (stgmedium.hGlobal == NULL)
|
|
{
|
|
// This is because the producer did not set the hGlobal handle
|
|
Trace0("HrExtractDataAlloc() - Memory handle hGlobal is NULL.\n");
|
|
return S_FALSE;
|
|
}
|
|
UINT cbData = (UINT)GlobalSize(stgmedium.hGlobal);
|
|
if (cbData == 0)
|
|
{
|
|
Trace1("HrExtractDataAlloc() - Corrupted hGlobal handle. err=%d.\n", GetLastError());
|
|
return E_UNEXPECTED;
|
|
}
|
|
*ppavData = stgmedium.hGlobal;
|
|
if (pcbData != NULL)
|
|
*pcbData = cbData;
|
|
return S_OK;
|
|
} // HrExtractDataAlloc()
|
|
|
|
|