static void CALLBACK wave_callback(HWAVE hWave, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
{
WAVEHDR *wh;
HGLOBAL hg;
if(uMsg == WOM_DONE)
{
EnterCriticalSection( &cs );
wh = (WAVEHDR *)dwParam1;
waveOutUnprepareHeader(dev, wh, sizeof (WAVEHDR));
//Deallocate the buffer memory
hg = GlobalHandle(wh->lpData);
GlobalUnlock(hg);
GlobalFree(hg);
//Deallocate the header memory
hg = GlobalHandle(wh);
GlobalUnlock(hg);
GlobalFree(hg);
// decrease the number of USED blocks
nBlocks--;
LeaveCriticalSection( &cs );
}
}
void _RTLDataClass::operator delete(void *ptr)
{
HANDLE hMem = LOWORD(GlobalHandle(FP_SEG(ptr)));
if (hMem)
if (GlobalUnlock(hMem))
GlobalFree(hMem);
}
// Release wave in memory
int ReleaseWaveIn(HWAVEIN* hWaveIn, WAVEHDR* waveHeader)
{
int res;
res = waveInUnprepareHeader(*hWaveIn, waveHeader, sizeof(WAVEHDR));
if ( res != MMSYSERR_NOERROR )
{
_debug_print("UnPrepare Wave In Header FAILED!",1);
return -1;
}
else
{
_debug_print("UnPrepare Wave In Header SUCCEED!");
}
res = (int)GlobalFree(GlobalHandle( waveHeader->lpData ));
if ( res != MMSYSERR_NOERROR )
{
_debug_print("Global Free FAILED!",1);
return -1;
}
else
{
_debug_print("Global Free SUCCEED!");
}
return 0;
}
/*
* MemReAlloc - allocate some memory
*/
void *MemReAlloc( void *ptr, unsigned size )
{
void *x;
#ifndef __OS2_PM__
#if defined( DEBUGMEM )
GLOBALHANDLE h;
h = GlobalHandle( FP_SEG( ptr ) );
GlobalUnlock( h );
x = GlobalLock( GlobalReAlloc( h, size, GMEM_ZEROINIT | GMEM_MOVEABLE ) );
#else
x = realloc( ptr, size );
#endif
#else
x = realloc( ptr, size );
#endif
#if defined( WANT_MSGS )
if( x == NULL ) {
MessageBox( HWND_DESKTOP, "AUUGH, Null Pointer", "Memory Allocation",
MB_OK | MB_ICONHAND | MB_SYSTEMMODAL );
}
#endif
return( x );
} /* MemReAlloc */
static char * formCodePtr( _trmem_hdl hdl, char *ptr, _trmem_who who )
{
#ifdef __WINDOWS__
#pragma warning 579 9; // shut up pointer truncated warning for FP_OFF
GLOBALENTRY entry;
if( hdl->use_code_seg_num ) {
MEMSET( &entry, 0, sizeof( GLOBALENTRY ) );
entry.dwSize = sizeof( GLOBALENTRY );
if( GlobalEntryHandle( &entry, (HGLOBAL) GlobalHandle( FP_SEG( who ) ) ) ) {
if( entry.wType == GT_CODE ) {
who = (_trmem_who) MK_FP( entry.wData, FP_OFF( who ) );
}
}
}
#pragma warning 579 4; // reenable pointer truncated warning
#else
hdl = hdl;
#endif
#if defined( _M_I86LM ) || defined( _M_I86HM ) || defined( _M_I86MM )
return formFarPtr( ptr, who );
#else
return formHex( ptr, (memsize)who, sizeof( who ) );
#endif
}
bool wxSound::Free()
{
if (m_waveData)
{
#ifdef __WXWINCE__
HGLOBAL waveData = (HGLOBAL) m_waveData;
#else
HGLOBAL waveData = GlobalHandle(m_waveData);
#endif
if (waveData)
{
#ifndef __WXWINCE__
if (m_isResource)
::FreeResource(waveData);
else
#endif
{
GlobalUnlock(waveData);
GlobalFree(waveData);
}
m_waveData = NULL;
m_waveLength = 0;
return true;
}
}
return false;
}
int OpenMapFile(char * FileName) {
DWORD RomFileSize, dwRead;
BYTE * MapFileContents;
HGLOBAL hMem;
HANDLE hFile;
hFile = CreateFile(FileName,GENERIC_READ,FILE_SHARE_READ,NULL,
OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
NULL);
if (hFile == INVALID_HANDLE_VALUE) { return FALSE; }
RomFileSize = GetFileSize(hFile,NULL);
MapFileContents = (BYTE*)GlobalAlloc(GPTR,RomFileSize + 1);
if (MapFileContents == NULL) {
DisplayError("Not enough memory for Map File Contents");
CloseHandle( hFile );
return FALSE;
}
SetFilePointer(hFile,0,0,FILE_BEGIN);
if (!ReadFile(hFile,MapFileContents,RomFileSize,&dwRead,NULL)) {
DisplayError("Failed to copy Map File to memory");
CloseHandle( hFile );
return FALSE;
}
CloseHandle( hFile );
if (RomFileSize != dwRead) {
DisplayError("Failed to copy Map File to memory");
return FALSE;
}
if (!ProcessMapFile(MapFileContents, RomFileSize)) {
hMem = GlobalHandle (MapFileContents);
GlobalFree(hMem);
return FALSE;
}
hMem = GlobalHandle (MapFileContents);
GlobalFree(hMem);
UpdateBP_FunctionList();
Update_r4300iCommandList();
return TRUE;
}
HGLOBAL ConstructMGXImage( LPSTR lpImageFile, LPSTR lpMaskFile )
/************************************************************************/
{
LPMGX_IMAGEHDR lpMgxHdr;
LPMGX_IMAGENAME lpMgxName;
long lDataSize, lCount, lValue;
LPSTR lpClipMem;
HGLOBAL hMemory;
lDataSize = sizeof(MGX_IMAGENAME) + lstrlen(lpImageFile) + 1 + sizeof(MGX_IMAGENAME) + lstrlen(lpMaskFile) + 1;
lCount = sizeof(MGX_IMAGEHDR) + lDataSize;
// allocate the memory to hold the MGX_IMAGE
if ( !(lpClipMem = (LPSTR)Alloc( lCount )) )
{
Message( IDS_EMEMALLOC );
return( NULL );
}
#ifdef WIN32
hMemory = GlobalHandle( lpClipMem );
#else
lValue = GlobalHandle( HIWORD(lpClipMem) );
hMemory = (HGLOBAL)LOWORD( lValue );
#endif
lpMgxHdr = (LPMGX_IMAGEHDR)lpClipMem;
lpMgxHdr->wHeaderSize = sizeof(MGX_IMAGEHDR);
lpMgxHdr->wVersion = MGX_IMAGE_VERSION;
lpMgxHdr->wImageType = MGX_IMAGEMASKTYPE;
lpMgxHdr->lDataSize = lDataSize;
lpClipMem += lpMgxHdr->wHeaderSize;
lpMgxName = (LPMGX_IMAGENAME)lpClipMem;
lpMgxName->wNameHeaderSize = sizeof(MGX_IMAGENAME);
lpMgxName->wDataType = MGX_IMAGETIFF;
lpMgxName->wNameLength = lstrlen(lpImageFile) + 1;
lpClipMem += sizeof(MGX_IMAGENAME);
lstrcpy(lpClipMem, lpImageFile);
lpClipMem += lpMgxName->wNameLength;
lpMgxName = (LPMGX_IMAGENAME)lpClipMem;
lpMgxName->wNameHeaderSize = sizeof(MGX_IMAGENAME);
lpMgxName->wDataType = MGX_MASKPP;
lpMgxName->wNameLength = lstrlen(lpMaskFile) + 1;
lpClipMem += sizeof(MGX_IMAGENAME);
lstrcpy(lpClipMem, lpMaskFile);
return( hMemory );
}
static void test_ImmGetIMCCLockCount(void)
{
HIMCC imcc;
DWORD count, g_count, ret, i;
VOID *p;
imcc = ImmCreateIMCC(sizeof(CANDIDATEINFO));
count = ImmGetIMCCLockCount(imcc);
ok(count == 0, "expect 0, returned %d\n", count);
ImmLockIMCC(imcc);
count = ImmGetIMCCLockCount(imcc);
ok(count == 1, "expect 1, returned %d\n", count);
ret = ImmUnlockIMCC(imcc);
ok(ret == FALSE, "expect FALSE, ret %d\n", ret);
count = ImmGetIMCCLockCount(imcc);
ok(count == 0, "expect 0, returned %d\n", count);
ret = ImmUnlockIMCC(imcc);
ok(ret == FALSE, "expect FALSE, ret %d\n", ret);
count = ImmGetIMCCLockCount(imcc);
ok(count == 0, "expect 0, returned %d\n", count);
p = ImmLockIMCC(imcc);
ok(GlobalHandle(p) == imcc, "expect %p, returned %p\n", imcc, GlobalHandle(p));
for (i = 0; i < GMEM_LOCKCOUNT * 2; i++)
{
ImmLockIMCC(imcc);
count = ImmGetIMCCLockCount(imcc);
g_count = GlobalFlags(imcc) & GMEM_LOCKCOUNT;
ok(count == g_count, "count %d, g_count %d\n", count, g_count);
}
count = ImmGetIMCCLockCount(imcc);
ok(count == GMEM_LOCKCOUNT, "expect GMEM_LOCKCOUNT, returned %d\n", count);
for (i = 0; i < GMEM_LOCKCOUNT - 1; i++)
GlobalUnlock(imcc);
count = ImmGetIMCCLockCount(imcc);
ok(count == 1, "expect 1, returned %d\n", count);
GlobalUnlock(imcc);
count = ImmGetIMCCLockCount(imcc);
ok(count == 0, "expect 0, returned %d\n", count);
ImmDestroyIMCC(imcc);
}
void
gpfree(generic *p)
{
#ifdef _Windows
HGLOBAL hGlobal = GlobalHandle(p);
GlobalUnlock(hGlobal);
GlobalFree(hGlobal);
#else
farfree(p);
#endif
}
void FreeMemoryOfHandle (PFP_Handle phHandle)
{
register HANDLE hToMem;
if ( phHandle != phAllFiles ) {
hToMem = GlobalHandle ( (LPSTR) (phHandle->lpwsPathName) );
GlobalUnlock ( hToMem );
GlobalFree ( hToMem );
}
hToMem = GlobalHandle ( (LPSTR) (phHandle->pfHandleData) );
GlobalUnlock ( hToMem );
GlobalFree ( hToMem );
hToMem = GlobalHandle ( (LPSTR) phHandle );
GlobalUnlock ( hToMem );
GlobalFree ( hToMem );
}
static void
free_memory (void)
{
WAVEHDR* wh;
HGLOBAL hg;
EnterCriticalSection (&cs);
wh = PlayedWaveHeaders [--PlayedWaveHeadersCount];
LeaveCriticalSection (&cs);
waveOutUnprepareHeader (dev, wh, sizeof (WAVEHDR));
hg = GlobalHandle (wh -> lpData); // Deallocate the buffer memory
GlobalUnlock (hg);
GlobalFree (hg);
hg = GlobalHandle (wh); // Deallocate the header memory
GlobalUnlock (hg);
GlobalFree (hg);
}
static void CALLBACK wave_callback (HWAVE hWave, UINT uMsg,
DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
{
WAVEHDR *wh;
HGLOBAL hg;
if (uMsg == WOM_DONE)
{
EnterCriticalSection (&critSect);
wh = (WAVEHDR *)dwParam1;
waveOutUnprepareHeader (dev, wh, sizeof (WAVEHDR));
hg = GlobalHandle (wh->lpData);
GlobalUnlock (hg);
GlobalFree (hg);
hg = GlobalHandle (wh);
GlobalUnlock (hg);
GlobalFree (hg);
nBlocks--;
LeaveCriticalSection (&critSect);
}
}
void* prim_globalHandle(void * arg1)
{ static struct {HsPtr res1;HsInt gc_failed;HsPtr gc_failstring;} gc_result;
HGLOBAL res1;int gc_failed;
char* gc_failstring;
do {res1 = GlobalHandle(arg1);
if ((gc_failed = ( res1==NULL ))) {gc_failstring = ErrorWin("GlobalHandle") ;}
else {gc_failed = 0;}
gc_result.res1 = (HGLOBAL)(res1);
gc_result.gc_failed = gc_failed;
gc_result.gc_failstring = gc_failstring;
return(&gc_result);} while(0);
}
void ResetSymbols() {
if(g_sdata.symbols) {
HGLOBAL hMem;
int i = 0;
while(g_sdata.symbols[i]) {
MemFree(g_sdata.symbols[i]);
i++;
}
hMem = GlobalHandle(g_sdata.symbols);
GlobalUnlock(hMem);
GlobalFree(hMem);
g_sdata.symbols = NULL;
}
}
void Ctl_FreeUp( LPVOID lpMemory )
/************************************************************************/
{
HGLOBAL hMemory;
if ( !lpMemory )
return;
#ifdef WIN32
if (!(hMemory = GlobalHandle(lpMemory)))
return;
#else
{
long lValue;
lValue = GlobalHandle( HIWORD(lpMemory) );
if ( HIWORD(lValue) != HIWORD(lpMemory) ) /* segment portions should match */
return;
hMemory = (HGLOBAL)LOWORD( lValue );
}
#endif
GlobalUnlock( hMemory );
GlobalFree( hMemory );
}
void
iC_efree(void * p)
{
#if defined(_LARGE_) || defined(_HUGE_)
GLOBALHANDLE hglobal;
hglobal = GlobalHandle(p); /* retrieve the handle */
GlobalUnlock(hglobal);
GlobalFree(hglobal); /* big deal */
#else
LOCALHANDLE hlocal;
hlocal = LocalHandle(p); /* retrieve the handle */
LocalUnlock(hlocal);
LocalFree(hlocal); /* big deal */
#endif
} /* iC_efree */
/*
* MemFree - free some memory
*/
void MemFree( void *ptr )
{
#ifndef __OS2_PM__
#if defined( DEBUGMEM )
GLOBALHANDLE h;
h = GlobalHandle( FP_SEG( ptr ) );
GlobalUnlock( h );
GlobalFree( h );
#else
free( ptr );
#endif
#else
free( ptr );
#endif
} /* MemFree */
static int DoFreeSeg( __segment seg )
{
#if defined(__WINDOWS_286__)
HANDLE hmem;
hmem = (HANDLE)GlobalHandle( seg );
if( hmem == NULL ) {
return( -1 );
}
GlobalUnlock( hmem );
if( GlobalFree( hmem ) == hmem ) {
return( -1 );
}
return( 0 );
#else
return( DosFreeSeg( seg ) );
#endif
}
BOOL CALLBACK IsTVWindowEngine( FPTVWNDINFO fpWndInfo, LPARAM lParam )
{
FPISTVWNDPRIVATEDATA fpPrivateData;
/* Get state of window. */
fpPrivateData = ( FPISTVWNDPRIVATEDATA ) lParam;
/* Show/Hide window. */
if( FindWndInfo( (HTVWNDINFO) GlobalHandle(SELECTOROF(fpWndInfo)), fpPrivateData->hWnd ) )
{
/* Mark it found. */
fpPrivateData->bFound = TRUE;
/* Stop enumerating. */
return FALSE;
}
/* Keep enumerating. */
return TRUE;
}
//////////////////////////
// Deallocate your memory
//////////////////////////
void Dealloc(VOIDPTR pMem)
{
HANDLE hMem;
///////////////////////////////
// Memory debugging code
///////////////////////////////
if (pMem != NULL)
{
hMem = GlobalHandle(SELECTOROF(pMem));
if (hMem != NULL)
{
GlobalUnlock(hMem);
GlobalFree(hMem);
pMem = NULL;
}
}
}
/**
** Higher-level interface: Windows Preview (-m pre or nothing)
**/
int to_emw(const GEN_PAR * pg, const OUT_PAR * po)
{
PGPO par;
PWORD p;
LPDLGTEMPLATE templ;
p = (PWORD) GlobalAlloc(GPTR, sizeof(DLGTEMPLATE) + 8);
templ = (LPDLGTEMPLATE) p;
// Memory is already zeroed so i dont set zeroes
// Start to fill in the dlgtemplate information, addressing by WORDs.
templ->style =
WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_POPUP | WS_CAPTION |
WS_SYSMENU | WS_THICKFRAME;
templ->cx = 480; // size in "dialog units"
templ->cy = 320;
// since i allocated 8 extra bytes i have menu=0 class=0 title=0
// which means no menu standard dialog and no title
// i fix title in WM_INIT and background by WM_ERASEBKGND
par.pg = pg;
par.po = po;
DialogBoxIndirectParam(0, templ, 0, Preview, (LPARAM) & par);
GlobalFree(GlobalHandle(p));
return 0;
}
return( ptr); // memory allocation okay.
}
//..........................................................................
//ppc cause access violation
void MyFree( void *UNALIGNED*p)
{
if ( p && *p )
{
#ifdef _DEBUG
FreeMemListItem( *p, NULL);
#else
HGLOBAL hMem = GlobalHandle( (HANDLE)*p);
GlobalUnlock( hMem);
GlobalFree( hMem);
#endif // _DEBUG
*p = NULL;
}
}
#ifdef _DEBUG
void FreeMemList( FILE *pfMemFile)
{
while ( pMemList )
void CDECL free (void *block)
{
HANDLE hSeg;
WORD wSeg;
SEGHEADER *Seg;
HANDLE hBlock;
#if MEMTRACE
WORD RealSize = 0;
#endif
if (FarStorage == FALSE) { /* use the local heap */
HANDLE hMem;
hMem = LocalHandle (LOWORD(block));
LocalUnlock (hMem);
LocalFree (hMem);
return;
}
wSeg = HIWORD((DWORD)block);
hSeg = LOWORD(GlobalHandle (wSeg));
SWITCH_DS(wSeg)
LocalUnlock (hBlock = LocalHandle (LOWORD(block)));
#if MEMTRACE
RealSize = LocalSize (hBlock);
#endif
LocalFree (hBlock);
RESTORE_DS
Seg = (SEGHEADER *)(MAKELONG(SEGHEADOFFSET,HIWORD(block)));
#if MEMTRACE
mtr[mtrx].m_func = MTR_FREE;
mtr[mtrx].m_ptr.m_block = block;
mtr[mtrx].m_cnt = Seg->alloc_count;
mtr[mtrx].m_size = RealSize;
mtr[mtrx++].m_optimseg = OptimumSeg;
#endif
if (--(Seg->alloc_count) == 0) { /* this segment is no longer used!
Let's get rid of it */
SEGHEADER *sp;
if (Seg == OptimumSeg) OptimumSeg = NULL;
sp = &SegList;
while (sp->next != Seg) {
sp = sp->next;
if (sp == NULL) { /* this segment is not in the list!!! */
/* this should not happen, but you never know... */
static BOOL WarningDisplayed = FALSE;
if (!WarningDisplayed) {
MessageBox (hFrameWnd,
"Please shutdown EMACS as soon as possible",
"Corrupted memory",
MB_OK | MB_ICONSTOP);
}
WarningDisplayed = TRUE;
return;
}
}
sp->next = Seg->next; /* unlink the segment */
#if MEMTRACE
mtr[mtrx].m_func = MTR_FREESEG;
mtr[mtrx].m_ptr.m_segh = Seg;
mtr[mtrx].m_cnt = Seg->alloc_count;
mtr[mtrx].m_size = GlobalSize (hSeg);
mtr[mtrx++].m_optimseg = OptimumSeg;
#endif
SWITCH_DS(wSeg)
UnlockData (0);
RESTORE_DS
GlobalUnlock (hSeg);
GlobalFree (hSeg); /* and release it */
}
else { /* segment still in use */
OptimumSeg = Seg; /* next malloc will try this segment
first */
}
} /* free */
void OpenZipMapFile(char * FileName) {
int port = 0, FoundMap;
unz_file_info info;
char zname[_MAX_PATH];
unzFile file;
file = unzOpen(FileName);
if (file == NULL) {
return;
}
port = unzGoToFirstFile(file);
FoundMap = FALSE;
while(port == UNZ_OK && FoundMap == FALSE) {
unzGetCurrentFileInfo(file, &info, zname, 128, NULL,0, NULL,0);
if (unzLocateFile(file, zname, 1) != UNZ_OK ) {
unzClose(file);
return;
}
if( unzOpenCurrentFile(file) != UNZ_OK ) {
unzClose(file);
return;
}
if (strrchr(zname,'.') != NULL) {
char *p = strrchr(zname,'.');
if (strcmp(p,".cod") == 0 || strcmp(p,".map") == 0) {
BYTE * MapFileContents;
DWORD dwRead;
HGLOBAL hMem;
MapFileContents = (BYTE*)GlobalAlloc(GPTR,info.uncompressed_size + 1);
if (MapFileContents == NULL) {
unzCloseCurrentFile(file);
unzClose(file);
DisplayError("Not enough memory for Map File Contents");
return;
}
dwRead = unzReadCurrentFile(file,MapFileContents,info.uncompressed_size);
unzCloseCurrentFile(file);
unzClose(file);
if (info.uncompressed_size != dwRead) {
hMem = GlobalHandle (MapFileContents);
GlobalFree(hMem);
DisplayError("Failed to copy Map File to memory");
return;
}
ProcessMapFile(MapFileContents, info.uncompressed_size);
hMem = GlobalHandle (MapFileContents);
GlobalFree(hMem);
UpdateBP_FunctionList();
Update_r4300iCommandList();
return;
}
}
if (FoundMap == FALSE) {
unzCloseCurrentFile(file);
port = unzGoToNextFile(file);
}
}
unzClose(file);
}
BOOL CALLBACK SettingsProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam) {
switch(msg) {
case WM_INITDIALOG:
{
int i = 0;
LRESULT rv;
for(i = (int)COMPRESSOR_SCRIPT; i <= (int)COMPRESSOR_BEST; i++) {
rv = SendDlgItemMessage(hwndDlg, IDC_COMPRESSOR, CB_ADDSTRING, 0, (LPARAM)compressor_display_names[i]);
}
rv = SendDlgItemMessage(hwndDlg, IDC_COMPRESSOR, CB_SETCURSEL, (WPARAM)g_sdata.default_compressor, (LPARAM)0);
SetSymbols(hwndDlg, g_sdata.symbols);
SetFocus(GetDlgItem(hwndDlg, IDC_SYMBOL));
break;
}
case WM_MAKENSIS_LOADSYMBOLSET:
{
char *name = (char *)wParam;
char **symbols = LoadSymbolSet(name);
HGLOBAL hMem;
SetSymbols(hwndDlg, symbols);
if(symbols) {
hMem = GlobalHandle(symbols);
GlobalUnlock(hMem);
GlobalFree(hMem);
}
break;
}
case WM_MAKENSIS_SAVESYMBOLSET:
{
char *name = (char *)wParam;
char **symbols = GetSymbols(hwndDlg);
HGLOBAL hMem;
if(symbols) {
SaveSymbolSet(name, symbols);
hMem = GlobalHandle(symbols);
GlobalUnlock(hMem);
GlobalFree(hMem);
}
break;
}
case WM_COMMAND:
{
switch (LOWORD(wParam)) {
case IDOK:
{
ResetObjects();
ResetInputScript();
ResetSymbols();
g_sdata.symbols = GetSymbols(hwndDlg);
int n = SendDlgItemMessage(hwndDlg, IDC_COMPRESSOR, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
if (n >= (int)COMPRESSOR_SCRIPT && n <= (int)COMPRESSOR_BEST) {
g_sdata.default_compressor = (NCOMPRESSOR)n;
}
else {
g_sdata.default_compressor = COMPRESSOR_SCRIPT;
}
EndDialog(hwndDlg, TRUE);
SetCompressor(g_sdata.default_compressor);
}
break;
case IDCANCEL:
EndDialog(hwndDlg, TRUE);
break;
case IDRIGHT:
{
int n = SendDlgItemMessage(hwndDlg, IDC_SYMBOL, WM_GETTEXTLENGTH, 0, 0);
if(n > 0) {
char *buf = (char *)GlobalAlloc(GPTR, (n+1)*sizeof(char));
SendDlgItemMessage(hwndDlg, IDC_SYMBOL, WM_GETTEXT, n+1, (LPARAM)buf);
if(my_strstr(buf," ") || my_strstr(buf,"\t")) {
MessageBox(hwndDlg,SYMBOLSERROR,"Error",MB_OK|MB_ICONSTOP);
GlobalFree(buf);
break;
}
n = SendDlgItemMessage(hwndDlg, IDC_VALUE, WM_GETTEXTLENGTH, 0, 0);
if(n > 0) {
char *buf2 = (char *)GlobalAlloc(GPTR, (n+1)*sizeof(char));
SendDlgItemMessage(hwndDlg, IDC_VALUE, WM_GETTEXT, n+1, (LPARAM)buf2);
char *buf3 = (char *)GlobalAlloc(GPTR, (lstrlen(buf)+lstrlen(buf2)+2)*sizeof(char));
wsprintf(buf3,"%s=%s",buf,buf2);
GlobalFree(buf);
buf = buf3;
GlobalFree(buf2);
}
SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_ADDSTRING, 0, (LPARAM)buf);
SendDlgItemMessage(hwndDlg, IDC_SYMBOL, WM_SETTEXT, 0, 0);
SendDlgItemMessage(hwndDlg, IDC_VALUE, WM_SETTEXT, 0, 0);
GlobalFree(buf);
EnableSymbolSetButtons(hwndDlg);
}
}
break;
case IDLEFT:
{
int index = SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_GETCURSEL, 0, 0);
if(index != LB_ERR) {
int n = SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_GETTEXTLEN, (WPARAM)index, 0);
if(n > 0) {
char *buf = (char *)GlobalAlloc(GPTR, (n+1)*sizeof(char));
SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_GETTEXT, (WPARAM)index, (LPARAM)buf);
char *p = my_strstr(buf,"=");
if(p) {
SendDlgItemMessage(hwndDlg, IDC_VALUE, WM_SETTEXT, 0, (LPARAM)(p+1));
*p=0;
}
SendDlgItemMessage(hwndDlg, IDC_SYMBOL, WM_SETTEXT, 0, (LPARAM)buf);
GlobalFree(buf);
SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_DELETESTRING, (WPARAM)index, 0);
EnableWindow(GetDlgItem(hwndDlg, IDLEFT), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDDEL), FALSE);
EnableSymbolSetButtons(hwndDlg);
}
}
}
break;
case IDCLEAR:
{
SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_RESETCONTENT , 0, 0);
EnableSymbolSetButtons(hwndDlg);
}
break;
case IDLOAD:
{
g_symbol_set_mode=1;
DialogBox(g_sdata.hInstance,MAKEINTRESOURCE(DLG_SYMBOLSET),hwndDlg,(DLGPROC)SymbolSetProc);
}
break;
case IDSAVE:
{
g_symbol_set_mode=2;
DialogBox(g_sdata.hInstance,MAKEINTRESOURCE(DLG_SYMBOLSET),hwndDlg,(DLGPROC)SymbolSetProc);
}
break;
case IDDEL:
{
int n = SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_GETSELCOUNT, 0, 0);
int *items = (int *)GlobalAlloc(GPTR, n*sizeof(int));
int rv = SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_GETSELITEMS, (WPARAM)n, (LPARAM)items);
int i;
for(i=n-1;i>=0;i--) {
SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_DELETESTRING, (WPARAM)items[i], 0);
}
EnableSymbolSetButtons(hwndDlg);
}
break;
case IDC_SYMBOL:
if(HIWORD(wParam) == EN_CHANGE)
{
int n = SendDlgItemMessage(hwndDlg, IDC_SYMBOL, WM_GETTEXTLENGTH, 0, 0);
if(n > 0) {
EnableWindow(GetDlgItem(hwndDlg, IDRIGHT), TRUE);
}
else {
EnableWindow(GetDlgItem(hwndDlg, IDRIGHT), FALSE);
}
}
break;
case IDC_SYMBOLS:
if(HIWORD(wParam) == LBN_SELCHANGE)
{
int n = SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_GETSELCOUNT, 0, 0);
if(n == 0) {
EnableWindow(GetDlgItem(hwndDlg, IDLEFT), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDDEL), FALSE);
}
else if(n == 1) {
EnableWindow(GetDlgItem(hwndDlg, IDLEFT), TRUE);
EnableWindow(GetDlgItem(hwndDlg, IDDEL), TRUE);
}
else if(n > 1) {
EnableWindow(GetDlgItem(hwndDlg, IDLEFT), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDDEL), TRUE);
}
}
break;
}
break;
}
}
return FALSE;
}
/*
* @implemented
*/
HANDLE
WINAPI
GetClipboardData(UINT uFormat)
{
HANDLE hData = NULL;
PVOID pData = NULL;
DWORD cbData = 0;
GETCLIPBDATA gcd;
hData = NtUserGetClipboardData(uFormat, &gcd);
if (!hData)
return NULL;
if (gcd.fGlobalHandle)
{
HANDLE hGlobal;
NtUserCreateLocalMemHandle(hData, NULL, 0, &cbData);
hGlobal = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, cbData);
pData = GlobalLock(hGlobal);
NtUserCreateLocalMemHandle(hData, pData, cbData, NULL);
hData = hGlobal;
}
if (gcd.uFmtRet != uFormat)
{
SETCLIPBDATA scd = {FALSE, FALSE};
HANDLE hNewData = NULL;
PVOID pNewData = NULL;
/* Synthesize requested format */
switch (uFormat)
{
case CF_TEXT:
if (gcd.uFmtRet == CF_UNICODETEXT)
pNewData = IntSynthesizeMultiByte(pData, cbData, uFormat == CF_OEMTEXT);
else // CF_OEMTEXT
OemToCharBuffA(pData, pData, cbData);
break;
case CF_OEMTEXT:
if (gcd.uFmtRet == CF_UNICODETEXT)
pNewData = IntSynthesizeMultiByte(pData, cbData, uFormat == CF_OEMTEXT);
else
CharToOemBuffA(pData, pData, cbData);
break;
case CF_UNICODETEXT:
pNewData = IntSynthesizeWideChar(pData, cbData, gcd.uFmtRet == CF_OEMTEXT);
break;
default:
FIXME("Format: %u != %u\n", uFormat, gcd.uFmtRet);
}
/* Is it a global handle? */
if (pNewData)
hNewData = GlobalHandle(pNewData);
if (hNewData)
{
/* Free old data */
if (pData)
{
GlobalUnlock(hData);
GlobalFree(hData);
}
hData = hNewData;
pData = pNewData;
}
/* Save synthesized format in clibboard */
if (pData)
{
HANDLE hMem;
scd.fGlobalHandle = TRUE;
hMem = NtUserConvertMemHandle(pData, GlobalSize(hData));
NtUserSetClipboardData(uFormat, hMem, &scd);
}
else if (hData)
NtUserSetClipboardData(uFormat, hData, &scd);
}
/* Unlock global handle */
if (pData)
GlobalUnlock(hData);
return hData;
}
static void test_GlobalAlloc(void)
{
ULONG memchunk;
HGLOBAL mem1,mem2,mem2a,mem2b;
UCHAR *mem2ptr;
UINT i;
BOOL error;
memchunk=100000;
SetLastError(NO_ERROR);
/* Check that a normal alloc works */
mem1=GlobalAlloc(0,memchunk);
ok(mem1!=NULL,"GlobalAlloc failed\n");
if(mem1) {
ok(GlobalSize(mem1)>=memchunk, "GlobalAlloc should return a big enough memory block\n");
}
/* Check that a 'zeroing' alloc works */
mem2=GlobalAlloc(GMEM_ZEROINIT,memchunk);
ok(mem2!=NULL,"GlobalAlloc failed: error=%d\n",GetLastError());
if(mem2) {
ok(GlobalSize(mem2)>=memchunk,"GlobalAlloc should return a big enough memory block\n");
mem2ptr=GlobalLock(mem2);
ok(mem2ptr==mem2,"GlobalLock should have returned the same memory as was allocated\n");
if(mem2ptr) {
error=FALSE;
for(i=0;i<memchunk;i++) {
if(mem2ptr[i]!=0) {
error=TRUE;
}
}
ok(!error,"GlobalAlloc should have zeroed out its allocated memory\n");
}
}
/* Check that GlobalReAlloc works */
/* Check that we can change GMEM_FIXED to GMEM_MOVEABLE */
mem2a=GlobalReAlloc(mem2,0,GMEM_MODIFY | GMEM_MOVEABLE);
if(mem2a!=NULL) {
mem2=mem2a;
mem2ptr=GlobalLock(mem2a);
ok(mem2ptr!=NULL && !GlobalUnlock(mem2a)&&GetLastError()==NO_ERROR,
"Converting from FIXED to MOVEABLE didn't REALLY work\n");
}
/* Check that ReAllocing memory works as expected */
mem2a=GlobalReAlloc(mem2,2*memchunk,GMEM_MOVEABLE | GMEM_ZEROINIT);
ok(mem2a!=NULL,"GlobalReAlloc failed\n");
if(mem2a) {
ok(GlobalSize(mem2a)>=2*memchunk,"GlobalReAlloc failed\n");
mem2ptr=GlobalLock(mem2a);
ok(mem2ptr!=NULL,"GlobalLock Failed\n");
if(mem2ptr) {
error=FALSE;
for(i=0;i<memchunk;i++) {
if(mem2ptr[memchunk+i]!=0) {
error=TRUE;
}
}
ok(!error,"GlobalReAlloc should have zeroed out its allocated memory\n");
/* Check that GlobalHandle works */
mem2b=GlobalHandle(mem2ptr);
ok(mem2b==mem2a,"GlobalHandle didn't return the correct memory handle %p/%p for %p\n",
mem2a, mem2b, mem2ptr);
/* Check that we can't discard locked memory */
mem2b=GlobalDiscard(mem2a);
if(mem2b==NULL) {
ok(!GlobalUnlock(mem2a) && GetLastError()==NO_ERROR,"GlobalUnlock Failed\n");
}
}
}
if(mem1) {
ok(GlobalFree(mem1)==NULL,"GlobalFree failed\n");
}
if(mem2a) {
ok(GlobalFree(mem2a)==NULL,"GlobalFree failed\n");
} else {
ok(GlobalFree(mem2)==NULL,"GlobalFree failed\n");
}
}
BOOL RenderToClipboard( HWND hWindow, WORD wFormat )
/************************************************************************/
{
DWORD dwValue;
HGLOBAL hMem;
LPTR lpMem;
LPFRAME lpFrame;
int iDataType, iFileType, fNative;
// This routine assumes that the 2 files to read and render
// are identified by Names.ClipImageFile and Names.ClipMaskFile
fNative = ( pOLE && (wFormat == pOLE->cfNative || !wFormat) ); // Native format is a DIB
if ( wFormat == Control.cfImage || !wFormat )
{
if ( hMem = ConstructMGXImage( Names.ClipImageFile, Names.ClipMaskFile ) )
SetClipboardData( Control.cfImage, hMem );
else return( FALSE );
}
if ( wFormat == CF_DIB || wFormat == CF_BITMAP ||
wFormat == CF_METAFILEPICT || !wFormat || fNative )
{
if ( !(lpFrame = AstralFrameLoad( Names.ClipImageFile, -1, &iDataType,
&iFileType )) )
return(FALSE);
}
else
lpFrame = NULL;
if ( wFormat == CF_DIB || !wFormat || fNative )
{
if ( lpMem = FrameToDIB( lpFrame, NULL ) )
{
#ifdef WIN32
hMem = GlobalHandle( lpMem );
#else
dwValue = GlobalHandle( HIWORD(lpMem) );
hMem = (HGLOBAL)LOWORD( dwValue );
#endif
GlobalUnlock(hMem);
if ( wFormat == CF_DIB || !wFormat )
SetClipboardData( CF_DIB, hMem );
if ( fNative )
SetClipboardData( pOLE->cfNative, hMem );
}
else
{
FrameClose( lpFrame );
return(FALSE);
}
}
if ( wFormat == CF_BITMAP || (!wFormat && Control.DoBitmap) )
{
if ( hMem = FrameToBitmap( lpFrame, NULL ) )
SetClipboardData( CF_BITMAP, hMem );
else
{
FrameClose( lpFrame );
return(FALSE);
}
}
if ( wFormat == CF_METAFILEPICT || (!wFormat && Control.DoPicture) )
{
if ( hMem = FrameToMetafile( lpFrame, NULL ) )
SetClipboardData( CF_METAFILEPICT, hMem );
else
{
FrameClose( lpFrame );
return(FALSE);
}
}
if ( lpFrame )
FrameClose( lpFrame );
if ( wFormat == CF_PALETTE || !wFormat )
{
if ( hMem = ConstructPalette( lpBltScreen->hPal ) )
SetClipboardData( CF_PALETTE, hMem );
}
return( TRUE );
}
INT_PTR CALLBACK SettingsProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam) {
switch(msg) {
case WM_INITDIALOG:
{
int i = 0;
for(i = (int)COMPRESSOR_SCRIPT; i <= (int)COMPRESSOR_BEST; i++) {
SendDlgItemMessage(hwndDlg, IDC_COMPRESSOR, CB_ADDSTRING, 0, (LPARAM)compressor_display_names[i]);
}
SendDlgItemMessage(hwndDlg, IDC_COMPRESSOR, CB_SETCURSEL, (WPARAM)g_sdata.default_compressor, (LPARAM)0);
SetSymbols(hwndDlg, g_sdata.symbols);
SetFocus(GetDlgItem(hwndDlg, IDC_SYMBOL));
break;
}
case WM_MAKENSIS_LOADSYMBOLSET:
{
TCHAR *name = (TCHAR *)wParam;
TCHAR **symbols = LoadSymbolSet(name);
HGLOBAL hMem;
SetSymbols(hwndDlg, symbols);
if(symbols) {
hMem = GlobalHandle(symbols);
GlobalUnlock(hMem);
GlobalFree(hMem);
}
break;
}
case WM_MAKENSIS_SAVESYMBOLSET:
{
TCHAR *name = (TCHAR *)wParam;
TCHAR **symbols = GetSymbols(hwndDlg);
HGLOBAL hMem;
if(symbols) {
SaveSymbolSet(name, symbols);
hMem = GlobalHandle(symbols);
GlobalUnlock(hMem);
GlobalFree(hMem);
}
break;
}
case WM_COMMAND:
{
switch (LOWORD(wParam)) {
case IDOK:
{
ResetObjects();
ResetSymbols();
g_sdata.symbols = GetSymbols(hwndDlg);
int n = SendDlgItemMessage(hwndDlg, IDC_COMPRESSOR, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
if (n >= (int)COMPRESSOR_SCRIPT && n <= (int)COMPRESSOR_BEST) {
g_sdata.default_compressor = (NCOMPRESSOR)n;
}
else {
g_sdata.default_compressor = COMPRESSOR_SCRIPT;
}
EndDialog(hwndDlg, TRUE);
SetCompressor(g_sdata.default_compressor);
}
break;
case IDCANCEL:
EndDialog(hwndDlg, TRUE);
break;
case IDC_RIGHT:
{
int n = SendDlgItemMessage(hwndDlg, IDC_SYMBOL, WM_GETTEXTLENGTH, 0, 0);
if(n > 0) {
TCHAR *buf = (TCHAR*) MemAllocZI((n+1)*sizeof(TCHAR));
SendDlgItemMessage(hwndDlg, IDC_SYMBOL, WM_GETTEXT, n+1, (LPARAM)buf);
if(_tcsstr(buf,_T(" ")) || _tcsstr(buf,_T("\t"))) {
MessageBox(hwndDlg,SYMBOLSERROR,ERRBOXTITLE,MB_OK|MB_ICONSTOP);
MemFree(buf);
break;
}
n = SendDlgItemMessage(hwndDlg, IDC_VALUE, WM_GETTEXTLENGTH, 0, 0);
if(n > 0) {
TCHAR *buf2 = (TCHAR*) MemAllocZI((n+1)*sizeof(TCHAR));
SendDlgItemMessage(hwndDlg, IDC_VALUE, WM_GETTEXT, n+1, (LPARAM)buf2);
TCHAR *buf3 = (TCHAR*) MemAllocZI((lstrlen(buf)+lstrlen(buf2)+2)*sizeof(TCHAR));
wsprintf(buf3,_T("%s=%s"),buf,buf2);
MemFree(buf);
buf = buf3;
MemFree(buf2);
}
int idx = SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_ADDSTRING, 0, (LPARAM)buf);
if (idx >= 0)
{
SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_SETSEL, FALSE, -1);
SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_SETSEL, TRUE, idx);
}
EnableSymbolEditButtons(hwndDlg);
SendDlgItemMessage(hwndDlg, IDC_SYMBOL, WM_SETTEXT, 0, 0);
SendDlgItemMessage(hwndDlg, IDC_VALUE, WM_SETTEXT, 0, 0);
MemFree(buf);
EnableSymbolSetButtons(hwndDlg);
}
}
break;
case IDC_LEFT:
{
if (SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_GETSELCOUNT, 0, 0) != 1)
break;
int index;
int num = SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_GETSELITEMS, 1, (LPARAM) &index);
if(num == 1) {
int n = SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_GETTEXTLEN, (WPARAM)index, 0);
if(n > 0) {
TCHAR *buf = (TCHAR*) MemAllocZI((n+1)*sizeof(TCHAR));
SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_GETTEXT, (WPARAM)index, (LPARAM)buf);
TCHAR *p = _tcsstr(buf,_T("="));
if(p) {
SendDlgItemMessage(hwndDlg, IDC_VALUE, WM_SETTEXT, 0, (LPARAM)(p+1));
*p=0;
}
SendDlgItemMessage(hwndDlg, IDC_SYMBOL, WM_SETTEXT, 0, (LPARAM)buf);
MemFree(buf);
SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_DELETESTRING, (WPARAM)index, 0);
EnableWindow(GetDlgItem(hwndDlg, IDC_LEFT), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_DEL), FALSE);
EnableSymbolSetButtons(hwndDlg);
}
}
}
break;
case IDC_CLEAR:
{
SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_RESETCONTENT , 0, 0);
EnableSymbolSetButtons(hwndDlg);
}
break;
case IDC_LOAD:
case IDC_SAVE:
{
g_symbol_set_mode = IDC_LOAD == LOWORD(wParam) ? 1 : 2;
DialogBox(g_sdata.hInstance,MAKEINTRESOURCE(DLG_SYMBOLSET),hwndDlg,(DLGPROC)SymbolSetProc);
}
break;
case IDC_DEL:
{
int n = SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_GETSELCOUNT, 0, 0);
int *items = (int*) MemAllocZI(n*sizeof(int));
if (items) {
SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_GETSELITEMS, (WPARAM)n, (LPARAM)items);
for(int i=n-1;i>=0;i--)
SendDlgItemMessage(hwndDlg, IDC_SYMBOLS, LB_DELETESTRING, (WPARAM)items[i], 0);
MemFree(items);
}
EnableSymbolEditButtons(hwndDlg);
EnableSymbolSetButtons(hwndDlg);
}
break;
case IDC_SYMBOL:
if(HIWORD(wParam) == EN_CHANGE)
{
int n = SendDlgItemMessage(hwndDlg, IDC_SYMBOL, WM_GETTEXTLENGTH, 0, 0);
EnableWindow(GetDlgItem(hwndDlg, IDC_RIGHT), n > 0);
}
break;
case IDC_SYMBOLS:
if (HIWORD(wParam) == LBN_SELCHANGE)
{
EnableSymbolEditButtons(hwndDlg);
}
else if (HIWORD(wParam) == LBN_DBLCLK)
{
SendDlgItemMessage(hwndDlg, IDC_LEFT, BM_CLICK, 0, 0);
}
break;
}
break;
}
}
return FALSE;
}
