Пример #1
0
Handle NewHandle ( long size )
{
	Handle mHand;
	char *p;

	memError = noErr;

	mHand =	(Handle) GlobalAllocPtr (GHND, (sizeof (Handle) + signatureSize));

	if (mHand)
		*mHand = (Ptr) GlobalAllocPtr (GHND, size);

	if (!mHand || !(*mHand))
		{
		memError = memFullErr;
		return NULL;
		}

	// put the signature after the pointer
	p = (char *) mHand;
	p += sizeof (Handle);
	memcpy (p,cSig, signatureSize);

	return mHand;
		
}
Пример #2
0
LPPACKET PacketAllocatePacket( LPADAPTER AdapterObject, UINT Length )
{
  LPPACKET lpPacket;

  lpPacket = (LPPACKET)GlobalAllocPtr( GMEM_MOVEABLE|GMEM_ZEROINIT, sizeof(PACKET) );
  if(lpPacket==NULL) {
      D(bug("Packet32: PacketAllocatePacket: GlobalAlloc Failed\n"));
      return NULL;
  }

	lpPacket->OverLapped.hEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
	if(!lpPacket->OverLapped.hEvent) {
			D(bug("Packet32: PacketAllocatePacket: CreateEvent Failed\n"));
			GlobalFreePtr(lpPacket);
			return NULL;
	}

	lpPacket->Buffer = GlobalAllocPtr(GMEM_MOVEABLE,2048); // 1514
	if(!lpPacket->Buffer) {
      D(bug("Packet32: PacketAllocatePacket: GlobalAllocPtr Failed\n"));
		  if(lpPacket->OverLapped.hEvent) CloseHandle(lpPacket->OverLapped.hEvent);
      GlobalFreePtr(lpPacket);
      return NULL;
	}

  lpPacket->OverLapped.Offset = 0;
  lpPacket->OverLapped.OffsetHigh = 0;
	lpPacket->Length = Length;
	lpPacket->BytesReceived	= 0;
	lpPacket->bIoComplete	= FALSE;
	lpPacket->free = TRUE;

  return lpPacket;
}
Пример #3
0
int PASCAL WinMain( HANDLE hInstance, HANDLE hPrevInstance,
                    LPSTR lpszCmdLine, int nCmdShow )
{
    TIMERINFO ti;
    DWORD beforeTickCountFast, afterTickCountFast;
    DWORD beforeTickCountSlow, afterTickCountSlow, i;
    BYTE __huge *hpvSrc;
    BYTE __huge *hpvDest;
    char szBuffer[256];
    
    hpvSrc = GlobalAllocPtr( GMEM_MOVEABLE, BLOCK_SIZE );
    hpvDest = GlobalAllocPtr( GMEM_MOVEABLE, BLOCK_SIZE );
    if ( !hpvSrc || !hpvDest )
    {
        MessageBox(0, "Couldn't allocate src/dest segs", 0, MB_OK);
        return 0;
    }

    // Call the 32 bit function once without timing it to let it switch
    // to a 32 bit segment.
    memcpy32( SELECTOROF(hpvDest), OFFSETOF(hpvDest),
              SELECTOROF(hpvSrc), OFFSETOF(hpvSrc),
              BLOCK_SIZE );

    ti.dwSize = sizeof(ti);
    TimerCount(&ti);
    beforeTickCountFast = ti.dwmsThisVM;

    // Now call the 32 bit function again, this time timing it.
    memcpy32( SELECTOROF(hpvDest), OFFSETOF(hpvDest),
              SELECTOROF(hpvSrc), OFFSETOF(hpvSrc),
              BLOCK_SIZE );
          
    TimerCount( &ti );
    afterTickCountFast = ti.dwmsThisVM;
    
    TimerCount(&ti);
    beforeTickCountSlow = ti.dwmsThisVM;

    for ( i=0; i < BLOCK_SIZE; i++)
        *hpvDest++ = *hpvSrc++;
        
    TimerCount( &ti );
    afterTickCountSlow = ti.dwmsThisVM;
    
    wsprintf(szBuffer,
            "32 bit move:       %lu milliseconds\r\n"
            "huge pointer move: %lu milliseconds",
            afterTickCountFast - beforeTickCountFast,
            afterTickCountSlow - beforeTickCountSlow);
    MessageBox( 0, szBuffer, "MIX1632 - Matt Pietrek 1994", MB_OK );

    return 0;
}
Пример #4
0
void LuminanceChrominance(SImageRGB ImageRGB, SImage Y, SImage C0, SImage C1)
{   
	rgb RGB;                                                        
	long l = 0;
    int lum;
    long i,j;

    unsigned char   * ImY = (unsigned char   *) Y.Image;   
    unsigned char   * ImC0 = (unsigned char   *) C0.Image;   
    unsigned char   * ImC1 = (unsigned char   *) C1.Image;   
    
    int  * Chromi0  = (int  * ) GlobalAllocPtr(GMEM_FIXED | GMEM_ZEROINIT,(ImageRGB.Lmax-ImageRGB.Lmin+1)*(ImageRGB.Hmax-ImageRGB.Hmin+1)*sizeof(int));
    int  * Chromi1  = (int  *) GlobalAllocPtr(GMEM_FIXED | GMEM_ZEROINIT,(ImageRGB.Lmax-ImageRGB.Lmin+1)*(ImageRGB.Hmax-ImageRGB.Hmin+1)*sizeof(int));
      
    int MaxRouge=-255,MaxBleu=-255;
    int MinRouge=255,MinBleu=255;
    for (j= ImageRGB.Hmin;j<=ImageRGB.Hmax;j++) 
	{                              
		for (i=ImageRGB.Lmin;i<=ImageRGB.Lmax;i++) 
		{                              
	    		RGB = ImageRGB.Image[j*ImageRGB.Larg+i]; 
	    		lum =  (int)(0.3*RGB.r + 0.59*RGB.g + 0.11*RGB.b);
				((unsigned char   * )ImY)[l] = (unsigned char) lum; 
				Chromi0[l] = (int)RGB.r-lum;
				Chromi1[l] = (int)RGB.b-lum;
				if (Chromi0[l] 	> MaxRouge) MaxRouge =Chromi0[l];
				if (Chromi1[l]  > MaxBleu) MaxBleu = Chromi1[l] ;
				if (Chromi0[l]  < MinRouge) MinRouge = Chromi0[l] ;
				if (Chromi1[l]  < MinBleu) MinBleu = Chromi1[l] ;
				l++;
		}
	} 
	l = 0;   
	// normalisation des chrominances 
	int normR,normB,norm; 
	if (MaxRouge==MinRouge) normR= 1; else normR = (MaxRouge-MinRouge)/255;
	if (MaxBleu==MinBleu) normB= 1; else normB = (MaxBleu-MinBleu)/255;      
	if (normR>normB) norm = normR; else norm = normB;   
	for (j= ImageRGB.Hmin;j<=ImageRGB.Hmax;j++) 
	{                              
		for (i=ImageRGB.Lmin;i<=ImageRGB.Lmax;i++) 
		{                              
	    		RGB = ImageRGB.Image[j*ImageRGB.Larg+i]; 
				((unsigned char   * )ImC0)[l] = (unsigned char) (Chromi0[l]-MinRouge)/norm;
				((unsigned char   * )ImC1)[l] = (unsigned char) (Chromi1[l] -MinBleu)/norm;
				l++;
		}
	}

	GlobalFreePtr(Chromi0);	
	GlobalFreePtr(Chromi1);	
}
Пример #5
0
void CDib::LoadStream(IStream *pStr)
{
    BITMAPFILEHEADER bitmapFileHeader;
    ULONG ReadSize = 0;
    HRESULT hr = S_OK;

    hr = pStr->Read((void*)&bitmapFileHeader,sizeof(BITMAPFILEHEADER),&ReadSize);
    if (SUCCEEDED(hr)&&(bitmapFileHeader.bfType == 0x4d42))
    {
        DWORD fileLength = bitmapFileHeader.bfSize;
        DWORD size = fileLength - sizeof(BITMAPFILEHEADER);
        BYTE* pDib = (BYTE*)GlobalAllocPtr(GMEM_MOVEABLE, size);
        hr = pStr->Read((void*)pDib, size,&ReadSize);
        if(SUCCEEDED(hr))
        {
            m_pBitmapInfo = (BITMAPINFO*)pDib;
            m_pBitmapInfoHeader = (BITMAPINFOHEADER*) pDib;
            m_pRGB = (RGBQUAD*)(pDib + m_pBitmapInfoHeader->biSize);
            int m_numberOfColors = GetNumberOfColors();
            if (m_pBitmapInfoHeader->biClrUsed == 0)
                m_pBitmapInfoHeader->biClrUsed = m_numberOfColors;
            DWORD colorTableSize = m_numberOfColors * sizeof(RGBQUAD);
            m_pData = pDib + m_pBitmapInfoHeader->biSize + colorTableSize;
            if (m_pRGB == (RGBQUAD*)m_pData) // No color table
                m_pRGB = NULL;
            m_pBitmapInfoHeader->biSizeImage = GetSize();
            m_valid = TRUE;
            return ;
        }
    }
    m_valid = FALSE;
#ifdef _DEVELOVER_VERSION_L1
    AfxMessageBox(_T("This isn't a bitmap file in Stream!"));
#endif
}
Пример #6
0
void CDib::LoadFile(const char* dibFileName)
{
	strcpy(m_fileName,dibFileName);
    CFile dibFile(m_fileName, CFile::modeRead);
    dibFile.Read((void*)&bitmapFileHeader,sizeof(BITMAPFILEHEADER));
    if (bitmapFileHeader.bfType == 0x4d42)
    {
        DWORD fileLength = dibFile.GetLength();    
		size = fileLength -sizeof(BITMAPFILEHEADER);
		pDib =(BYTE*)GlobalAllocPtr(GMEM_MOVEABLE, size);
        dibFile.Read((void*)pDib, size);
        dibFile.Close();
        m_pBitmapInfo = (BITMAPINFO*) pDib;
        m_pBitmapInfoHeader = (BITMAPINFOHEADER*) pDib;
        m_pRGB = (RGBQUAD*)(pDib +
			m_pBitmapInfoHeader->biSize);
        int m_numberOfColors = GetNumberOfColors();
        if (m_pBitmapInfoHeader->biClrUsed == 0)
            m_pBitmapInfoHeader->biClrUsed =
			m_numberOfColors;
        DWORD colorTableSize = m_numberOfColors *
            sizeof(RGBQUAD);
        m_pData = pDib + m_pBitmapInfoHeader->biSize
            + colorTableSize;
		if (m_pRGB == (RGBQUAD*)m_pData) // No color table
			m_pRGB = NULL;
        m_pBitmapInfoHeader->biSizeImage = GetSize();
		m_valid = TRUE;
    }    
    else
    {
        m_valid = FALSE;
        AfxMessageBox("This isn't a bitmap file!");
    }
}
Пример #7
0
CModelFrame::CModelFrame()
{
	m_Limited=600;
	m_iDem=512;
	m_bArroy=new BYTE[m_iDem];
	Pallete=(LPBITMAPINFO)GlobalAllocPtr(GHND,
		(sizeof (BITMAPINFO)+
		(sizeof (RGBQUAD)*255 )));
	Pallete->bmiHeader.biSize		= 40;
	Pallete->bmiHeader.biWidth		= m_iDem;
	Pallete->bmiHeader.biHeight		= m_iDem;
	Pallete->bmiHeader.biPlanes		= 1;
	Pallete->bmiHeader.biBitCount	= 8;
	Pallete->bmiHeader.biCompression=BI_RGB;
	Pallete->bmiHeader.biSizeImage  = 0;
	Pallete->bmiHeader.biXPelsPerMeter = 0;
	Pallete->bmiHeader.biYPelsPerMeter = 0;
	Pallete->bmiHeader.biClrUsed       = 0;
	Pallete->bmiHeader.biClrImportant  = 0;
	
	for(int i=0;i<256;i++)
	{
		Pallete->bmiColors[i].rgbRed =
			Pallete->bmiColors[i].rgbGreen =
			Pallete->bmiColors[i].rgbBlue = i;
	}
	GetModel();
}
Пример #8
0
///////////////////////////////////////
// member function CreateBITMAPINFO
///////////////////////////////////////
BOOL CDib::CreateBITMAPINFO()
{
    UINT biSize;

	// determine the amount of memory needed to hold BITMAPINFO
    biSize = GetBITMAPINFOSize();

    // Allocate the BITMAPINFO data structure
	if (lpbinfo != NULL)
	  GlobalFreePtr(lpbinfo);

    lpbinfo = (LPBITMAPINFO) GlobalAllocPtr(GMEM_MOVEABLE,biSize);

    if (lpbinfo == NULL) 
    {
		SetCDibState(FAIL_LPBI_ALLOC);
		return FALSE;

    }

	// initialize the values to ZERO
    memset(lpbinfo, 0, biSize);

   return TRUE;
}
Пример #9
0
//---------------------------------------------------------------------------
BOOLEAN PacketGetNetType (LPADAPTER AdapterObject,NetType *type)
{
	BOOLEAN Status;
    ULONG IoCtlBufferLength = (sizeof (PACKET_OID_DATA) + sizeof (ULONG) - 1);
    PPACKET_OID_DATA OidData;

	ODS ("Packet32: PacketSetFilter\n");
	_ASSERTE (AdapterObject != NULL);
    OidData = GlobalAllocPtr (
			       GMEM_MOVEABLE | GMEM_ZEROINIT,
			       IoCtlBufferLength
      );
    if (OidData == NULL)
	{
		return FALSE;
	}
	//get the link-layer type
    OidData->Oid = OID_GEN_MEDIA_IN_USE;
    OidData->Length = sizeof (ULONG);
    Status = PacketRequest(AdapterObject,FALSE,OidData);
	if(Status==FALSE)return FALSE;

    type->LinkType=*((UINT*)OidData->Data);

	//get the link-layer speed
    OidData->Oid = OID_GEN_LINK_SPEED;
    OidData->Length = sizeof (ULONG);
    Status = PacketRequest(AdapterObject,FALSE,OidData);
	type->LinkSpeed=*((UINT*)OidData->Data)*100;
    GlobalFreePtr (OidData);
    return Status;
}
Пример #10
0
// This basically allocates our "instance info" (that struct defined
// at the beginning of this file).
static LONG NEAR PASCAL AVIDrawOpen(ICOPEN FAR * icopen)
{
	PINSTINFO pinst;

	if (icopen->fccType != streamtypeVIDEO)
	{
		return 0;
	}
	if (icopen->dwFlags == ICMODE_COMPRESS)
	{
		return 0;
	}
	if (icopen->dwFlags == ICMODE_DECOMPRESS)
	{
		return 0;
	}
	pinst = (PINSTINFO)GlobalAllocPtr(GHND, sizeof(INSTINFO));
	if (!pinst)
	{
		icopen->dwError = ICERR_MEMORY;
		return NULL;
	}
	pinst->hdd = DrawDibOpen();
	pinst->hddb = NULL;
	icopen->dwError = ICERR_OK;
	return (LONG) pinst;
}
Пример #11
0
signed char* CSoundFile::AllocateSample(UINT nbytes)
//-------------------------------------------
{
	signed char * p = (signed char *)GlobalAllocPtr(GHND, (nbytes+39) & ~7);
	if (p) p += 16;
	return p;
}
Пример #12
0
LPADAPTER PacketOpenAdapter( LPCTSTR AdapterName, int16 mode )
{
  LPADAPTER  lpAdapter;
  BOOLEAN    Result = TRUE;

  D(bug("Packet32: PacketOpenAdapter\n"));

  // May fail if user is not an Administrator.
  StartPacketDriver( TEXT("B2ether") );

  lpAdapter = (LPADAPTER)GlobalAllocPtr( GMEM_MOVEABLE|GMEM_ZEROINIT, sizeof(ADAPTER) );
  if (lpAdapter==NULL) {
      D(bug("Packet32: PacketOpenAdapter GlobalAlloc Failed\n"));
      return NULL;
  }

	TCHAR device_name[256];
	_sntprintf(lpAdapter->SymbolicLink, lengthof(lpAdapter->SymbolicLink), TEXT("\\\\.\\B2ether_%s"), AdapterName );
	_sntprintf(device_name, lengthof(device_name), TEXT("\\Device\\B2ether_%s"), AdapterName );

	// Work around one subtle NT4 bug.
	DefineDosDevice(
			DDD_REMOVE_DEFINITION,
			&lpAdapter->SymbolicLink[4],
			NULL
	);
	DefineDosDevice(
			DDD_RAW_TARGET_PATH,
			&lpAdapter->SymbolicLink[4],
			device_name
	);

	packet_filter = NDIS_PACKET_TYPE_DIRECTED |
									NDIS_PACKET_TYPE_MULTICAST |
									NDIS_PACKET_TYPE_BROADCAST;

	if(mode == ETHER_MULTICAST_ALL) packet_filter |= NDIS_PACKET_TYPE_ALL_MULTICAST;
	if(mode == ETHER_MULTICAST_PROMISCUOUS) packet_filter |= NDIS_PACKET_TYPE_PROMISCUOUS;

  if (Result) {
    lpAdapter->hFile = CreateFile(lpAdapter->SymbolicLink,
                         GENERIC_WRITE | GENERIC_READ,
                         0,
                         NULL,
												 // (os == VER_PLATFORM_WIN32_NT) ? CREATE_ALWAYS : OPEN_EXISTING,
												 OPEN_EXISTING,
                         FILE_FLAG_OVERLAPPED,
                         0
                         );
    if (lpAdapter->hFile != INVALID_HANDLE_VALUE) {
			if(*AdapterName && _tcscmp(AdapterName,TEXT("<None>")) != 0) {
				PacketSetFilter( lpAdapter, packet_filter );
			}
      return lpAdapter;
    }
  }
  D(bug("Packet32: PacketOpenAdapter Could not open adapter\n"));
  GlobalFreePtr( lpAdapter );
  return NULL;
}
Пример #13
0
BOOL riffCopyChunk(HMMIO hmmioSrc, HMMIO hmmioDst, const LPMMCKINFO lpck) 
{ 
	MMCKINFO ck; 
	HPSTR hpBuf; 

	hpBuf = (HPSTR)GlobalAllocPtr(GHND, lpck->cksize);

	if (!hpBuf) return (FALSE); 

	ck.ckid = lpck->ckid; 
	ck.cksize = lpck->cksize;

	if (mmioCreateChunk(hmmioDst, &ck, 0)) goto rscc_Error; 

	if (mmioRead(hmmioSrc, hpBuf, lpck->cksize) != (LONG)lpck->cksize) goto rscc_Error; 

	if (mmioWrite(hmmioDst, hpBuf, lpck->cksize) != (LONG)lpck->cksize) goto rscc_Error; 

	if (mmioAscend(hmmioDst, &ck, 0)) goto rscc_Error; 

	if (hpBuf) GlobalFreePtr(hpBuf); 

	return (TRUE); 

rscc_Error: 

	if (hpBuf) GlobalFreePtr(hpBuf); 

	return (FALSE); 
} /* RIFFSupCopyChunk() */ 
Пример #14
0
static LPOLDGLOBALS NewGlobal(HWND hWnd)
{
  LPOLDGLOBALS lp=(LPOLDGLOBALS)GlobalAllocPtr(GHND, sizeof(OLD_GLOBALS));
  if (lp)
    {
    lp->hWnd=hWnd;
    lp->lpfnOldFarProc=NULL;
    lp->pNext=NULL;
    if (!lpFirstOldGlobals)
      {
      lpFirstOldGlobals=lp;
      }
    else
      {
      LPOLDGLOBALS lp2;
      for (lp2=lpFirstOldGlobals;lp2;lp2=lp2->pNext)
        {
        if (!lp2->pNext)
          {
          lp2->pNext=lp;
          break;
          }
        }
      }
    }
  return lp;
}
Пример #15
0
//*************************************************************
//
//  PlaceMenuMRUItem()
//
//  Purpose:
//              Add MRU at the end of a menu
//
//  Parameters:
//      LPMRUMENU lpMruMenu -      pointer on MRUMENU
//      HMENU hMenu -              Handle of menu where MRU must be added
//      UINT uiItem -              Item of menu entry where MRU must be added
//
//  Return: void
//
//
//  Comments:
//      Used MRU is modified, for refresh the File menu
//
//  History:    Date       Author       Comment
//              09/24/94   G. Vollant   Created
//
//*************************************************************
void PlaceMenuMRUItem( LPMRUMENU lpMruMenu, HMENU hMenu, UINT uiItem )
{
    int  i;
    WORD wNbShow;
    if ( lpMruMenu == NULL )
        return;
    // remove old MRU in menu
    for ( i = 0; i <= ( int )( lpMruMenu->wNbLruMenu ); i++ )
        RemoveMenu( hMenu, i + lpMruMenu->wIdMru, MF_BYCOMMAND );

    if ( lpMruMenu->wNbItemFill == 0 )
        return;

    // If they are item, insert a separator before the files
    InsertMenu( hMenu, uiItem, MF_SEPARATOR, lpMruMenu->wIdMru, NULL );

    wNbShow = min( lpMruMenu->wNbItemFill, lpMruMenu->wNbLruShow );
    for ( i = ( int )wNbShow - 1; i >= 0; i-- )
    {
        LPSTR lpTxt;
        if ( lpTxt = ( LPSTR )GlobalAllocPtr( GHND, lpMruMenu->wMaxSizeLruItem + 20 ) )
        {
            wsprintf( lpTxt, "&%lu %s",
                      ( DWORD )( i + 1 ), lpMruMenu->lpMRU + ( lpMruMenu->wMaxSizeLruItem * ( UINT )i ) );
            InsertMenu( hMenu, ( ( ( WORD )i ) != ( wNbShow - 1 ) ) ? ( lpMruMenu->wIdMru + i + 2 ) : lpMruMenu->wIdMru,
                        MF_STRING, lpMruMenu->wIdMru + i + 1, lpTxt );
            GlobalFreePtr( lpTxt );
        }
    }

}
Пример #16
0
//*************************************************************
//
//  SaveMruInReg()
//
//  Purpose:
//              Save MRU in the registry
//
//  Parameters:
//      LPMRUMENU lpMruMenu -      pointer on MRUMENU
//      LPSTR lpszKey  -           Points to a null-terminated string
//                                      specifying  the name of a key that
//                                      this function opens or creates.
//
//  Return: (BOOL)
//      TRUE  - Function run successfully
//      FALSE - Function don't run successfully
//
//
//  Comments:
//      Win32 function designed for Windows NT and Windows 95
//      See RegCreateKeyEx API for more info on lpszKey
//
//  History:    Date       Author       Comment
//              09/24/94   G. Vollant   Created
//
//*************************************************************
BOOL SaveMruInReg( LPMRUMENU lpMruMenu, LPSTR lpszKey )
{
    LPSTR lpTxt;
    WORD i;
    HKEY hCurKey;
    DWORD dwDisp;

    lpTxt = ( LPSTR )GlobalAllocPtr( GHND, lpMruMenu->wMaxSizeLruItem + 20 );
    if ( lpTxt == NULL )
        return FALSE;

    RegCreateKeyEx( HKEY_CURRENT_USER, lpszKey, 0, NULL,
                    REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hCurKey, &dwDisp );

    for ( i = 0; i < lpMruMenu->wNbLruMenu; i++ )
    {
        char szEntry[16];
        wsprintf( szEntry, "File%lu", ( DWORD )i + 1 );
        if ( !GetMenuItem( lpMruMenu, i, FALSE, lpTxt, lpMruMenu->wMaxSizeLruItem + 10 ) )
            *lpTxt = '\0';
        RegSetValueEx( hCurKey, szEntry, 0, REG_SZ, ( unsigned char* )lpTxt, lstrlen( lpTxt ) );
    }
    RegCloseKey( hCurKey );
    GlobalFreePtr( lpTxt );
    return TRUE;
}
Пример #17
0
//*************************************************************
//
//  LoadMruInReg()
//
//  Purpose:
//              Load MRU from the registry
//
//  Parameters:
//      LPMRUMENU lpMruMenu -      pointer on MRUMENU
//      LPSTR lpszKey  -           Points to a null-terminated string
//                                      specifying  the name of a key that
//                                      this function opens or creates.
//
//  Return: (BOOL)
//      TRUE  - Function run successfully
//      FALSE - Function don't run successfully
//
//
//  Comments:
//      Win32 function designed for Windows NT and Windows 95
//      See RegOpenKeyEx API for more info on lpszKey
//
//  History:    Date       Author       Comment
//              09/24/94   G. Vollant   Created
//
//*************************************************************
BOOL LoadMruInReg( LPMRUMENU lpMruMenu, LPSTR lpszKey )
{
    LPSTR lpTxt;
    WORD i;
    HKEY hCurKey;
    DWORD dwType;
    lpTxt = ( LPSTR )GlobalAllocPtr( GHND, lpMruMenu->wMaxSizeLruItem + 20 );
    if ( lpTxt == NULL )
        return FALSE;

    RegOpenKeyEx( HKEY_CURRENT_USER, lpszKey, 0, KEY_READ, &hCurKey );


    for ( i = 0; i < lpMruMenu->wNbLruMenu; i++ )
    {
        char szEntry[16];
        DWORD dwSizeBuf;
        wsprintf( szEntry, "File%lu", ( DWORD )i + 1 );
        *lpTxt = '\0';
        dwSizeBuf = lpMruMenu->wMaxSizeLruItem + 10;
        RegQueryValueEx( hCurKey, szEntry, NULL, &dwType, ( LPBYTE )lpTxt, &dwSizeBuf );
        *( lpTxt + dwSizeBuf ) = '\0';
        if ( *lpTxt == '\0' )
            break;
        SetMenuItem( lpMruMenu, i, lpTxt );
    }
    RegCloseKey( hCurKey );
    GlobalFreePtr( lpTxt );
    return TRUE;
}
Пример #18
0
//---------------------------------------------------------------------------
BOOLEAN PacketSetMaxLookaheadsize (LPADAPTER AdapterObject)
{
	BOOLEAN Status;
    ULONG IoCtlBufferLength = (sizeof (PACKET_OID_DATA) + sizeof (ULONG) - 1);
    PPACKET_OID_DATA OidData;

	ODS ("Packet32: PacketSetFilter\n");
	_ASSERTE (AdapterObject != NULL);
    OidData = GlobalAllocPtr (
			       GMEM_MOVEABLE | GMEM_ZEROINIT,
			       IoCtlBufferLength
      );
    if (OidData == NULL)
	{
		return FALSE;
	}
	//set the size of the lookahead buffer to the maximum available by the the NIC driver
    OidData->Oid=OID_GEN_MAXIMUM_LOOKAHEAD;
    OidData->Length=sizeof(ULONG);
    Status=PacketRequest(AdapterObject,FALSE,OidData);
    OidData->Oid=OID_GEN_CURRENT_LOOKAHEAD;
    Status=PacketRequest(AdapterObject,TRUE,OidData);
    GlobalFreePtr(OidData);
    return Status;
}
Пример #19
0
//---------------------------------------------------------------------------
BOOLEAN PacketSetHwFilter (LPADAPTER AdapterObject,
				      ULONG Filter)
{
	BOOLEAN Status;
    ULONG IoCtlBufferLength = (sizeof (PACKET_OID_DATA) + sizeof (ULONG) - 1);
    PPACKET_OID_DATA OidData;

	ODS ("Packet32: PacketSetFilter\n");
	_ASSERTE (AdapterObject != NULL);
    OidData = GlobalAllocPtr (
			       GMEM_MOVEABLE | GMEM_ZEROINIT,
			       IoCtlBufferLength
      );
    if (OidData == NULL)
	{
		return FALSE;
	}
    OidData->Oid = OID_GEN_CURRENT_PACKET_FILTER;
    OidData->Length = sizeof (ULONG);
    *((PULONG) OidData->Data) = Filter;
    Status = PacketRequest (
			     AdapterObject,
			     TRUE,
			     OidData
      );
    GlobalFreePtr (OidData);
    return Status;
}
Пример #20
0
//---------------------------------------------------------------------------
LPPACKET PacketAllocatePacket (void)
{
	LPPACKET lpPacket;

    lpPacket = (LPPACKET) GlobalAllocPtr (
					   GMEM_MOVEABLE | GMEM_ZEROINIT,
					   sizeof (PACKET));
    if (lpPacket == NULL)
	{
		ODS ("Packet32: PacketAllocatePacket: GlobalAlloc Failed\n");
		return NULL;
	}
    lpPacket->OverLapped.hEvent = CreateEvent (NULL,
						FALSE,
						FALSE,
						NULL);
    if (lpPacket->OverLapped.hEvent == NULL)
    {
		ODS ("Packet32: PacketAllocatePacket: CreateEvent Failed\n");
		GlobalFreePtr (lpPacket);
		return NULL;
    }
	lpPacket->Buffer=NULL;
	lpPacket->Length=0;
	lpPacket->ulBytesReceived	= 0;
	lpPacket->bIoComplete		= FALSE;

    return lpPacket;
}
Пример #21
0
void CSpectrumFrame::CreatePallete()
{
	Pallete=(LPBITMAPINFO)GlobalAllocPtr(GHND,
		(sizeof (BITMAPINFO)+
		(sizeof (RGBQUAD)*255 )));
	Pallete->bmiHeader.biSize		= 40;
	Pallete->bmiHeader.biWidth		= m_iDem;
	Pallete->bmiHeader.biHeight		= m_iDem;
	Pallete->bmiHeader.biPlanes		= 1;
	Pallete->bmiHeader.biBitCount	= 8;
	Pallete->bmiHeader.biCompression=BI_RGB;
	Pallete->bmiHeader.biSizeImage  = 0;
	Pallete->bmiHeader.biXPelsPerMeter = 0;
	Pallete->bmiHeader.biYPelsPerMeter = 0;
	Pallete->bmiHeader.biClrUsed       = 0;
	Pallete->bmiHeader.biClrImportant  = 0;
	
	for(int i=0;i<256;i++)
	{
		Pallete->bmiColors[i].rgbRed =
			Pallete->bmiColors[i].rgbGreen =
			Pallete->bmiColors[i].rgbBlue = i;
	}
	
}
Пример #22
0
void AllocLocalCompressFormat() {

	if (pwfxLocal) {

		//Do nothing....already allocated

	}
	else {

		MMRESULT mmresult = acmMetrics(NULL, ACM_METRIC_MAX_SIZE_FORMAT, &cbwfxLocal);
		if (MMSYSERR_NOERROR != mmresult)
		{

			CString msgstr;
			msgstr.Format("Metrics failed mmresult=%u!", mmresult);
            ::MessageBox(NULL,msgstr,"Note", MB_OK | MB_ICONEXCLAMATION);
			return ;
		}

		if (cbwfxLocal < cbwfx) cbwfxLocal = cbwfx;

		pwfxLocal = (LPWAVEFORMATEX)GlobalAllocPtr(GHND, cbwfxLocal);
		if (NULL == pwfxLocal)
		{

			CString msgstr;
			msgstr.Format("GlobalAllocPtr(%lu) failed!", cbwfxLocal);
            ::MessageBox(NULL,msgstr,"Note", MB_OK | MB_ICONEXCLAMATION);
			return ;
		}

	}

}
Пример #23
0
/*
** PR_MD_malloc() -- exported as malloc()
**
*/
void *PR_MD_malloc( size_t size )
{
    if( _pr_callback_funcs ) {
        return (*_pr_callback_funcs->malloc)( size );
    } else {
        return GlobalAllocPtr(GPTR, (DWORD)size);
    }
} /* end malloc() */
Пример #24
0
LPMRUMENU CreateMruMenu( WORD wNbLruShowInit,
						 WORD wNbLruMenuInit, WORD wMaxSizeLruItemInit, WORD wIdMruInit ) {
	LPMRUMENU lpMruMenu;
	lpMruMenu = ( LPMRUMENU )GlobalAllocPtr( GHND, sizeof( MRUMENU ) );
	lpMruMenu->wNbItemFill = 0;
	lpMruMenu->wNbLruMenu = wNbLruMenuInit;
	lpMruMenu->wNbLruShow = wNbLruShowInit;
	lpMruMenu->wIdMru = wIdMruInit;
	lpMruMenu->wMaxSizeLruItem = wMaxSizeLruItemInit;
	lpMruMenu->lpMRU = ( LPSTR )GlobalAllocPtr( GHND,
					   lpMruMenu->wNbLruMenu * ( UINT )lpMruMenu->wMaxSizeLruItem );
	if( lpMruMenu->lpMRU == NULL ) {
		GlobalFreePtr( lpMruMenu );
		lpMruMenu =  NULL;
	}
	return lpMruMenu;
}
/*****
* Retrieve all items from the file listbox in the main window.
* This routine discards any preloaded list of files.
* As a consequence of that, it also discards any flowgraph generated from 
* that filelist.
*
* Returns 0 if there are no files else returns 1.
*****/
static int
get_files_to_scan(HWND hDlg)
{
	int i;
	char szBuf[MAXPATHLEN];
	HWND hwndList = GetDlgItem(hDlg, IDC_MAIN_LISTBOX);

	if(num_files != 0 && !file_sel_changed)
		return(1);
	/* clear previous list */
	destroy_filelist();

	/* get no of items in the list */
	num_files = (int)SendMessage(hwndList, LB_GETCOUNT, 0, 0L);

	/* return if no files in list */
	if(num_files == 0)
		return(0);

	/* allocate memory for this list */
	file_list = (char**)GlobalAllocPtr(GPTR, (num_files+1)*sizeof(char*));
	if(file_list == NULL)
	{
		ErrHandler(hDlg, R_ERROR, RB_OK1, "Out of memory: Failed to "
			"allocate %i bytes for filelist",
			num_files*sizeof(char*));
		exit(4);
	}
	/* get the items in the list */
	for(i = 0; i < num_files; i++)
	{
		SendMessage(hwndList, LB_GETTEXT, i, (LONG)(LPSTR)szBuf);
		file_list[i]=(char*)GlobalAllocPtr(GPTR,
			(strlen(szBuf)+1)*sizeof(char));
		if(file_list[i] == NULL)
		{
			ErrHandler(hDlg, R_ERROR, RB_OK1, "Out of memory: "
				"Failed to allocate %i bytes for file %i",
				(strlen(szBuf)+1)*sizeof(char), szBuf);
			exit(4);
		}
		strcpy(file_list[i], szBuf);
	}
	file_sel_changed = 0;
	return(1);
}
Пример #26
0
CBitArray::CBitArray(int nBitsMin, int nBitsMax) // minimum is inclusive, maximum is exclusive
{
  m_nMin = nBitsMin;
  m_nBits = nBitsMax - nBitsMin;
  m_cElemsPerRow = (m_nBits - 1) / (8 * sizeof (*m_pargBits)) + 1;
  m_pargBits = (unsigned int *) GlobalAllocPtr(GMEM_MOVEABLE | GMEM_ZEROINIT,
                                              m_cElemsPerRow * sizeof (*m_pargBits) * m_nBits);
}
Пример #27
0
/****************************************************************************
 *                                                                          *
 * Function: PlayNavigatingSound                                            *
 *                                                                          *
 * Purpose : Play system navigating sound.                                  *
 *                                                                          *
 * History : Date      Reason                                               *
 *           00/00/00  Created                                              *
 *                                                                          *
 ****************************************************************************/
static void PlayNavigatingSound(void)
{
	HKEY hKey = NULL;
	ULONG ulBufferSize = MAX_PATH + sizeof(TCHAR);
	LPTSTR lpszBuffer = GlobalAllocPtr(GPTR, ulBufferSize);
	LPTSTR lpszSoundPath = GlobalAllocPtr(GPTR, ulBufferSize);

	if (RegOpenKeyEx(HKEY_CURRENT_USER, _T("AppEvents\\Schemes\\Apps\\Explorer\\Navigating\\.Current"), 0, KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS) {
		if (RegQueryValueEx(hKey, NULL, 0, NULL, (LPBYTE) lpszBuffer, &ulBufferSize) == ERROR_SUCCESS) {
			ExpandEnvironmentStrings(lpszBuffer, lpszSoundPath, ulBufferSize);
			PlaySound(lpszSoundPath, NULL, SND_ASYNC | SND_NODEFAULT | SND_NOWAIT);
		}
   		if(hKey) RegCloseKey(hKey);
	}

	if(lpszBuffer) GlobalFreePtr(lpszBuffer);
	if(lpszSoundPath) GlobalFreePtr(lpszSoundPath);
}
Пример #28
0
bool CBitmapShow::InitialBitmap(int width,int height)
{
     if((Width==width)&&(Height==height)) return true;
	 Width=width;
	 Height=height;
	 if(m_lpBitmapInfo!=NULL) GlobalFreePtr(m_lpBitmapInfo);
	 int colors=GetNumberColors();
	 if(colors==0) colors=256;
	 m_lpBitmapInfo = (LPBITMAPINFO) GlobalAllocPtr(GHND,sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * colors);
	 m_lpBitmapInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	 m_lpBitmapInfo->bmiHeader.biWidth = Width;
	 m_lpBitmapInfo->bmiHeader.biHeight = Height;
	 m_lpBitmapInfo->bmiHeader.biCompression=GetCompressionKind();
	 m_lpBitmapInfo->bmiHeader.biSizeImage = 0;
	 m_lpBitmapInfo->bmiHeader.biXPelsPerMeter = 0;
	 m_lpBitmapInfo->bmiHeader.biYPelsPerMeter = 0;
	 m_lpBitmapInfo->bmiHeader.biPlanes = 1;
	 m_lpBitmapInfo->bmiHeader.biBitCount =GetBitCount();
	 m_lpBitmapInfo->bmiHeader.biClrUsed = 0;
	 m_lpBitmapInfo->bmiHeader.biClrImportant = 0;
	 ILineBytes=WIDTHBYTES(Width*GetBitCount());
	 m_lpBitmapInfo->bmiHeader.biSizeImage=ILineBytes*Height;
     for(int k=0;k<colors;k++) m_lpBitmapInfo->bmiColors[k].rgbRed=m_lpBitmapInfo->bmiColors[k].rgbGreen=m_lpBitmapInfo->bmiColors[k].rgbBlue=k;
	 if(!CreateDIBPalette())
	 {
         if(m_lpBitmapInfo!=NULL) GlobalFreePtr(m_lpBitmapInfo);
         m_lpBitmapInfo=NULL;
		 return false;
	 }
	 if(lpDIBBits!=NULL) GlobalFreePtr(lpDIBBits);
     lpDIBBits=NULL;
     lpDIBBits=(unsigned char*)GlobalAllocPtr(GHND,ILineBytes*Height);
	 if(lpDIBBits==NULL)
	 {
         if(m_lpBitmapInfo!=NULL) GlobalFreePtr(m_lpBitmapInfo);
         m_lpBitmapInfo=NULL;
         if(Palette!=NULL) delete Palette;
		 Palette=NULL;
		 return false;
	 }
	 return true;
}
Пример #29
0
bool DISKS::AddDisk(const char* szFileName)
{
    if (nDiskCount >= N)
        return false;
    fName[nDiskCount] = (char*)GlobalAllocPtr(GPTR, strlen(szFileName) + 1);
    if (fName[nDiskCount] == INVALID_HANDLE_VALUE || fName[nDiskCount] == NULL)
        return false;
    strcpy(fName[nDiskCount], szFileName);

    nDiskCount++;
    return true;
}
Пример #30
0
LPPACKET DimesPacketAllocatePacket(void)
{

    LPPACKET    lpPacket;
    lpPacket=(LPPACKET)GlobalAllocPtr(GMEM_MOVEABLE | GMEM_ZEROINIT,sizeof(PACKET));
    if (lpPacket==NULL)
    {
        ODS("PacketAllocatePacket: GlobalAlloc Failed\n");
        return NULL;
    }
    return lpPacket;
}