static struct output *
add_output( struct d3dadapter9 *This )
{
struct adapter_group *group = &This->groups[This->ngroups-1];
if (group->noutputs >= group->noutputsalloc) {
void *r;
if (group->noutputsalloc == 0) {
group->noutputsalloc = 2;
r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
group->noutputsalloc*sizeof(struct output));
} else {
group->noutputsalloc <<= 1;
r = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, group->outputs,
group->noutputsalloc*sizeof(struct output));
}
if (!r) { return NULL; }
group->outputs = r;
}
return &group->outputs[group->noutputs++];
}
/* Renderbuffer routines */
static GLboolean
sw_bb_renderbuffer_storage(struct gl_context* ctx, struct gl_renderbuffer *rb,
GLenum internalFormat,
GLuint width, GLuint height)
{
struct swrast_renderbuffer *srb = swrast_renderbuffer(rb);
struct sw_framebuffer* fb = CONTAINING_RECORD(srb, struct sw_framebuffer, backbuffer);
UINT widthBytes = WIDTH_BYTES_ALIGN32(width, pixel_formats[fb->format_index].color_bits);
srb->Base.Format = pixel_formats[fb->format_index].mesa;
if(srb->Buffer)
srb->Buffer = HeapReAlloc(GetProcessHeap(), 0, srb->Buffer, widthBytes*height);
else
srb->Buffer = HeapAlloc(GetProcessHeap(), 0, widthBytes*height);
if(!srb->Buffer)
{
srb->Base.Format = MESA_FORMAT_NONE;
return GL_FALSE;
}
srb->Base.Width = width;
srb->Base.Height = height;
srb->RowStride = widthBytes;
return GL_TRUE;
}
void clsGlobalDataQueue::AddDataToQueue(GlobalQueue &pQueue, char * sData, const size_t &szLen) {
if(pQueue.szSize < (pQueue.szLen + szLen)) {
size_t szAllignLen = Allign256(pQueue.szLen + szLen);
char * pOldBuf = pQueue.sBuffer;
#ifdef _WIN32
pQueue.sBuffer = (char *)HeapReAlloc(clsServerManager::hLibHeap, HEAP_NO_SERIALIZE, (void *)pOldBuf, szAllignLen);
#else
pQueue.sBuffer = (char *)realloc(pOldBuf, szAllignLen);
#endif
if(pQueue.sBuffer == NULL) {
pQueue.sBuffer = pOldBuf;
AppendDebugLog("%s - [MEM] Cannot reallocate %" PRIu64 " bytes in clsGlobalDataQueue::AddDataToQueue\n", (uint64_t)szAllignLen);
return;
}
pQueue.szSize = szAllignLen-1;
}
memcpy(pQueue.sBuffer+pQueue.szLen, sData, szLen);
pQueue.szLen += szLen;
pQueue.sBuffer[pQueue.szLen] = '\0';
}
/* prepare the text mode video memory copy that is used to only
* update the video memory line that did get updated. */
static void VGA_PrepareVideoMemCopy(unsigned Xres, unsigned Yres)
{
char *p, *p2;
unsigned int i;
/*
* Allocate space for char + attr.
*/
if (vga_text_old)
vga_text_old = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
vga_text_old, Xres * Yres * 2 );
else
vga_text_old = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
Xres * Yres * 2 );
p = VGA_AlphaBuffer();
p2 = vga_text_old;
/* make sure the video mem copy contains the exact opposite of our
* actual text mode memory area to make sure the screen
* does get updated fully initially */
for (i=0; i < Xres*Yres*2; i++)
*p2++ = *p++ ^ 0xff; /* XOR it */
}
// appends data to the UserIPQueue
void clsGlobalDataQueue::UserIPStore(User * pUser) {
if(UserIPQueue.szLen == 0) {
UserIPQueue.szLen = sprintf(UserIPQueue.sBuffer, "$UserIP %s %s|", pUser->sNick, pUser->sIP);
UserIPQueue.bHaveDollars = false;
} else {
int iDataLen = sprintf(msg, "%s %s$$|", pUser->sNick, pUser->sIP);
if(CheckSprintf(iDataLen, 128, "clsGlobalDataQueue::UserIPStore") == true) {
if(UserIPQueue.bHaveDollars == false) {
UserIPQueue.sBuffer[UserIPQueue.szLen-1] = '$';
UserIPQueue.sBuffer[UserIPQueue.szLen] = '$';
UserIPQueue.bHaveDollars = true;
UserIPQueue.szLen += 2;
}
if(UserIPQueue.szSize < UserIPQueue.szLen+iDataLen) {
size_t szAllignLen = Allign256(UserIPQueue.szLen+iDataLen);
char * pOldBuf = UserIPQueue.sBuffer;
#ifdef _WIN32
UserIPQueue.sBuffer = (char *)HeapReAlloc(clsServerManager::hLibHeap, HEAP_NO_SERIALIZE, (void *)pOldBuf, szAllignLen);
#else
UserIPQueue.sBuffer = (char *)realloc(pOldBuf, szAllignLen);
#endif
if(UserIPQueue.sBuffer == NULL) {
UserIPQueue.sBuffer = pOldBuf;
AppendDebugLog("%s - [MEM] Cannot reallocate %" PRIu64 " bytes in clsGlobalDataQueue::UserIPStore\n", (uint64_t)szAllignLen);
return;
}
UserIPQueue.szSize = (uint32_t)(szAllignLen-1);
}
memcpy(UserIPQueue.sBuffer+UserIPQueue.szLen-1, msg, iDataLen);
UserIPQueue.szLen += iDataLen-1;
UserIPQueue.sBuffer[UserIPQueue.szLen] = '\0';
}
}
}
/* Helper for GDI_Bezier.
* Just handles one Bezier, so Points should point to four POINTs
*/
static void GDI_InternalBezier( POINT *Points, POINT **PtsOut, INT *dwOut,
INT *nPtsOut, INT level )
{
if(*nPtsOut == *dwOut) {
*dwOut *= 2;
*PtsOut = HeapReAlloc( GetProcessHeap(), 0, *PtsOut,
*dwOut * sizeof(POINT) );
}
if(!level || BezierCheck(level, Points)) {
if(*nPtsOut == 0) {
(*PtsOut)[0].x = BEZIERSHIFTDOWN(Points[0].x);
(*PtsOut)[0].y = BEZIERSHIFTDOWN(Points[0].y);
*nPtsOut = 1;
}
(*PtsOut)[*nPtsOut].x = BEZIERSHIFTDOWN(Points[3].x);
(*PtsOut)[*nPtsOut].y = BEZIERSHIFTDOWN(Points[3].y);
(*nPtsOut) ++;
} else {
POINT Points2[4]; /* for the second recursive call */
Points2[3]=Points[3];
BEZIERMIDDLE(Points2[2], Points[2], Points[3]);
BEZIERMIDDLE(Points2[0], Points[1], Points[2]);
BEZIERMIDDLE(Points2[1],Points2[0],Points2[2]);
BEZIERMIDDLE(Points[1], Points[0], Points[1]);
BEZIERMIDDLE(Points[2], Points[1], Points2[0]);
BEZIERMIDDLE(Points[3], Points[2], Points2[1]);
Points2[0]=Points[3];
/* do the two halves */
GDI_InternalBezier(Points, PtsOut, dwOut, nPtsOut, level-1);
GDI_InternalBezier(Points2, PtsOut, dwOut, nPtsOut, level-1);
}
}
static BOOL fetch_process_thread( DWORD flags, SYSTEM_PROCESS_INFORMATION** pspi,
ULONG* num_pcs, ULONG* num_thd)
{
NTSTATUS status;
ULONG size, offset;
PSYSTEM_PROCESS_INFORMATION spi;
*num_pcs = *num_thd = 0;
if (!(flags & (TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD))) return TRUE;
*pspi = HeapAlloc( GetProcessHeap(), 0, size = 4096 );
for (;;)
{
status = NtQuerySystemInformation( SystemProcessInformation, *pspi,
size, NULL );
switch (status)
{
case STATUS_SUCCESS:
*num_pcs = *num_thd = offset = 0;
spi = *pspi;
do
{
spi = (SYSTEM_PROCESS_INFORMATION*)((char*)spi + offset);
if (flags & TH32CS_SNAPPROCESS) (*num_pcs)++;
if (flags & TH32CS_SNAPTHREAD) *num_thd += spi->dwThreadCount;
} while ((offset = spi->NextEntryOffset));
return TRUE;
case STATUS_INFO_LENGTH_MISMATCH:
*pspi = HeapReAlloc( GetProcessHeap(), 0, *pspi, size *= 2 );
break;
default:
SetLastError( RtlNtStatusToDosError( status ) );
break;
}
}
}
/**************************************************************************
* DPA_SetPtr [COMCTL32.335]
*
* Sets a pointer in the pointer array
*
* PARAMS
* hdpa [I] handle (pointer) to the pointer array
* i [I] index of the pointer that will be set
* p [I] pointer to be set
*
* RETURNS
* Success: TRUE
* Failure: FALSE
*/
BOOL WINAPI DPA_SetPtr (const HDPA hdpa, INT i, LPVOID p)
{
LPVOID *lpTemp;
TRACE("(%p %d %p)\n", hdpa, i, p);
if (!hdpa || i < 0)
return FALSE;
if (hdpa->nItemCount <= i) {
/* within the old array */
if (hdpa->nMaxCount <= i) {
/* resize the block of memory */
INT nNewItems =
hdpa->nGrow * ((((i+1) - 1) / hdpa->nGrow) + 1);
INT nSize = nNewItems * sizeof(LPVOID);
if (hdpa->ptrs)
lpTemp = HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY, hdpa->ptrs, nSize);
else
lpTemp = HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY, nSize);
if (!lpTemp)
return FALSE;
hdpa->nMaxCount = nNewItems;
hdpa->ptrs = lpTemp;
}
hdpa->nItemCount = i+1;
}
/* put the new entry in */
hdpa->ptrs[i] = p;
return TRUE;
}
LPVOID WINAPI CryptMemRealloc(LPVOID pv, ULONG cbSize)
{
return HeapReAlloc(GetProcessHeap(), 0, pv, cbSize);
}
static HRESULT IDirectSoundCaptureBufferImpl_Create(
DirectSoundCaptureDevice *device,
IDirectSoundCaptureBufferImpl ** ppobj,
LPCDSCBUFFERDESC lpcDSCBufferDesc)
{
LPWAVEFORMATEX wfex;
IDirectSoundCaptureBufferImpl *This;
TRACE( "(%p,%p,%p)\n", device, ppobj, lpcDSCBufferDesc);
if (ppobj == NULL) {
WARN("invalid parameter: ppobj == NULL\n");
return DSERR_INVALIDPARAM;
}
*ppobj = NULL;
if (!device) {
WARN("not initialized\n");
return DSERR_UNINITIALIZED;
}
if (lpcDSCBufferDesc == NULL) {
WARN("invalid parameter: lpcDSCBufferDesc == NULL\n");
return DSERR_INVALIDPARAM;
}
if ( ((lpcDSCBufferDesc->dwSize != sizeof(DSCBUFFERDESC)) &&
(lpcDSCBufferDesc->dwSize != sizeof(DSCBUFFERDESC1))) ||
(lpcDSCBufferDesc->dwBufferBytes == 0) ||
(lpcDSCBufferDesc->lpwfxFormat == NULL) ) { /* FIXME: DSERR_BADFORMAT ? */
WARN("invalid lpcDSCBufferDesc\n");
return DSERR_INVALIDPARAM;
}
wfex = lpcDSCBufferDesc->lpwfxFormat;
TRACE("(formattag=0x%04x,chans=%d,samplerate=%d,"
"bytespersec=%d,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec,
wfex->nAvgBytesPerSec, wfex->nBlockAlign,
wfex->wBitsPerSample, wfex->cbSize);
device->pwfx = DSOUND_CopyFormat(wfex);
if ( device->pwfx == NULL )
return DSERR_OUTOFMEMORY;
This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
sizeof(IDirectSoundCaptureBufferImpl));
if ( This == NULL ) {
WARN("out of memory\n");
return DSERR_OUTOFMEMORY;
} else {
HRESULT err = DS_OK;
LPBYTE newbuf;
DWORD buflen;
This->numIfaces = 0;
This->ref = 0;
This->refn = 0;
This->device = device;
This->device->capture_buffer = This;
This->nrofnotifies = 0;
This->pdscbd = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
lpcDSCBufferDesc->dwSize);
if (This->pdscbd)
CopyMemory(This->pdscbd, lpcDSCBufferDesc, lpcDSCBufferDesc->dwSize);
else {
WARN("no memory\n");
This->device->capture_buffer = 0;
HeapFree( GetProcessHeap(), 0, This );
return DSERR_OUTOFMEMORY;
}
This->IDirectSoundCaptureBuffer8_iface.lpVtbl = &dscbvt;
This->IDirectSoundNotify_iface.lpVtbl = &dscnvt;
err = IMMDevice_Activate(device->mmdevice, &IID_IAudioClient,
CLSCTX_INPROC_SERVER, NULL, (void**)&device->client);
if(FAILED(err)){
WARN("Activate failed: %08x\n", err);
HeapFree(GetProcessHeap(), 0, This->pdscbd);
This->device->capture_buffer = 0;
HeapFree( GetProcessHeap(), 0, This );
return err;
}
err = IAudioClient_Initialize(device->client,
AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_NOPERSIST,
200 * 100000, 50000, device->pwfx, NULL);
if(FAILED(err)){
WARN("Initialize failed: %08x\n", err);
IAudioClient_Release(device->client);
device->client = NULL;
HeapFree(GetProcessHeap(), 0, This->pdscbd);
This->device->capture_buffer = 0;
HeapFree( GetProcessHeap(), 0, This );
if(err == AUDCLNT_E_UNSUPPORTED_FORMAT)
return DSERR_BADFORMAT;
return err;
}
err = IAudioClient_GetService(device->client, &IID_IAudioCaptureClient,
(void**)&device->capture);
if(FAILED(err)){
WARN("GetService failed: %08x\n", err);
IAudioClient_Release(device->client);
device->client = NULL;
HeapFree(GetProcessHeap(), 0, This->pdscbd);
This->device->capture_buffer = 0;
HeapFree( GetProcessHeap(), 0, This );
return err;
}
buflen = lpcDSCBufferDesc->dwBufferBytes;
TRACE("desired buflen=%d, old buffer=%p\n", buflen, device->buffer);
if (device->buffer)
newbuf = HeapReAlloc(GetProcessHeap(),0,device->buffer,buflen);
else
newbuf = HeapAlloc(GetProcessHeap(),0,buflen);
if (newbuf == NULL) {
IAudioClient_Release(device->client);
device->client = NULL;
IAudioCaptureClient_Release(device->capture);
device->capture = NULL;
HeapFree(GetProcessHeap(), 0, This->pdscbd);
This->device->capture_buffer = 0;
HeapFree( GetProcessHeap(), 0, This );
return DSERR_OUTOFMEMORY;
}
device->buffer = newbuf;
device->buflen = buflen;
}
IDirectSoundCaptureBuffer_AddRef(&This->IDirectSoundCaptureBuffer8_iface);
*ppobj = This;
TRACE("returning DS_OK\n");
return DS_OK;
}
void* yr_realloc(void* ptr, size_t size)
{
return (void*) HeapReAlloc(hHeap, HEAP_ZERO_MEMORY, ptr, size);
}
static INT find_joystick_devices(void)
{
INT i;
if (joystick_devices_count != -1) return joystick_devices_count;
joystick_devices_count = 0;
for (i = 0; i < MAX_JOYSTICKS; i++)
{
int fd;
struct JoyDev joydev, *new_joydevs;
BYTE axes_map[ABS_MAX + 1];
snprintf(joydev.device, sizeof(joydev.device), "%s%d", JOYDEV_NEW, i);
if ((fd = open(joydev.device, O_RDONLY)) < 0)
{
snprintf(joydev.device, sizeof(joydev.device), "%s%d", JOYDEV_OLD, i);
if ((fd = open(joydev.device, O_RDONLY)) < 0) continue;
}
strcpy(joydev.name, "Wine Joystick");
#if defined(JSIOCGNAME)
if (ioctl(fd, JSIOCGNAME(sizeof(joydev.name) - sizeof(JOYDEVDRIVER)), joydev.name) < 0)
WARN("ioctl(%s,JSIOCGNAME) failed: %s\n", joydev.device, strerror(errno));
#endif
/* Append driver name */
strcat(joydev.name, JOYDEVDRIVER);
if (device_disabled_registry(joydev.name)) {
close(fd);
continue;
}
#ifdef JSIOCGAXES
if (ioctl(fd, JSIOCGAXES, &joydev.axis_count) < 0)
{
WARN("ioctl(%s,JSIOCGAXES) failed: %s, defauting to 2\n", joydev.device, strerror(errno));
joydev.axis_count = 2;
}
#endif
#ifdef JSIOCGBUTTONS
if (ioctl(fd, JSIOCGBUTTONS, &joydev.button_count) < 0)
{
WARN("ioctl(%s,JSIOCGBUTTONS) failed: %s, defauting to 2\n", joydev.device, strerror(errno));
joydev.button_count = 2;
}
#endif
if (ioctl(fd, JSIOCGAXMAP, axes_map) < 0)
{
WARN("ioctl(%s,JSIOCGNAME) failed: %s\n", joydev.device, strerror(errno));
joydev.dev_axes_map = NULL;
}
else
if ((joydev.dev_axes_map = HeapAlloc(GetProcessHeap(), 0, joydev.axis_count * sizeof(int))))
{
INT j;
/* Remap to DI numbers */
for (j = 0; j < joydev.axis_count; j++)
if (axes_map[j] < 8)
/* Axis match 1-to-1 */
joydev.dev_axes_map[j] = j;
else if (axes_map[j] == 16 ||
axes_map[j] == 17)
/* POV axis */
joydev.dev_axes_map[j] = 8;
else
joydev.dev_axes_map[j] = -1;
}
close(fd);
if (!joystick_devices_count)
new_joydevs = HeapAlloc(GetProcessHeap(), 0, sizeof(struct JoyDev));
else
new_joydevs = HeapReAlloc(GetProcessHeap(), 0, joystick_devices,
(joystick_devices_count + 1) * sizeof(struct JoyDev));
if (!new_joydevs) continue;
TRACE("Found a joystick on %s: %s\n with %d axes and %d buttons\n", joydev.device,
joydev.name, joydev.axis_count, joydev.button_count);
joystick_devices = new_joydevs;
joystick_devices[joystick_devices_count++] = joydev;
}
return joystick_devices_count;
}
static void processRegLinesW(FILE *in)
{
WCHAR* buf = NULL; /* line read from input stream */
ULONG lineSize = REG_VAL_BUF_SIZE;
size_t CharsInBuf = -1;
WCHAR* s; /* The pointer into buf for where the current fgets should read */
WCHAR* line; /* The start of the current line */
buf = HeapAlloc(GetProcessHeap(), 0, lineSize * sizeof(WCHAR));
CHECK_ENOUGH_MEMORY(buf);
s = buf;
line = buf;
while(!feof(in)) {
size_t size_remaining;
int size_to_get;
WCHAR *s_eol = NULL; /* various local uses */
/* Do we need to expand the buffer ? */
assert (s >= buf && s <= buf + lineSize);
size_remaining = lineSize - (s-buf);
if (size_remaining < 2) /* room for 1 character and the \0 */
{
WCHAR *new_buffer;
size_t new_size = lineSize + (REG_VAL_BUF_SIZE / sizeof(WCHAR));
if (new_size > lineSize) /* no arithmetic overflow */
new_buffer = HeapReAlloc (GetProcessHeap(), 0, buf, new_size * sizeof(WCHAR));
else
new_buffer = NULL;
CHECK_ENOUGH_MEMORY(new_buffer);
buf = new_buffer;
line = buf;
s = buf + lineSize - size_remaining;
lineSize = new_size;
size_remaining = lineSize - (s-buf);
}
/* Get as much as possible into the buffer, terminated either by
* eof, error or getting the maximum amount. Abort on error.
*/
size_to_get = (size_remaining > INT_MAX ? INT_MAX : size_remaining);
CharsInBuf = fread(s, sizeof(WCHAR), size_to_get - 1, in);
s[CharsInBuf] = 0;
if (CharsInBuf == 0) {
if (ferror(in)) {
perror ("While reading input");
exit (IO_ERROR);
} else {
assert (feof(in));
*s = '\0';
/* It is not clear to me from the definition that the
* contents of the buffer are well defined on detecting
* an eof without managing to read anything.
*/
}
}
/* If we didn't read the eol nor the eof go around for the rest */
while(1)
{
const WCHAR line_endings[] = {'\r','\n',0};
s_eol = strpbrkW(line, line_endings);
if(!s_eol) {
/* Move the stub of the line to the start of the buffer so
* we get the maximum space to read into, and so we don't
* have to recalculate 'line' if the buffer expands */
MoveMemory(buf, line, (strlenW(line)+1) * sizeof(WCHAR));
line = buf;
s = strchrW(line, '\0');
break;
}
/* If it is a comment line then discard it and go around again */
if (*line == '#' || *line == ';') {
if (*s_eol == '\r' && *(s_eol+1) == '\n')
line = s_eol + 2;
else
line = s_eol + 1;
continue;
}
/* If there is a concatenating \\ then go around again */
if (*(s_eol-1) == '\\') {
WCHAR* NextLine = s_eol + 1;
if(*s_eol == '\r' && *(s_eol+1) == '\n')
NextLine++;
while(*(NextLine+1) == ' ' || *(NextLine+1) == '\t')
NextLine++;
MoveMemory(s_eol - 1, NextLine, (CharsInBuf - (NextLine - s) + 1)*sizeof(WCHAR));
CharsInBuf -= NextLine - s_eol + 1;
s_eol = 0;
continue;
}
/* Remove any line feed. Leave s_eol on the last \0 */
if (*s_eol == '\r' && *(s_eol + 1) == '\n')
*s_eol++ = '\0';
*s_eol = '\0';
processRegEntry(line, TRUE);
line = s_eol + 1;
s_eol = 0;
continue; /* That is the full virtual line */
}
}
processRegEntry(NULL, TRUE);
HeapFree(GetProcessHeap(), 0, buf);
}
void * __cdecl realloc(_Post_ptr_invalid_ void * _Memory, _In_ size_t _NewSize){
return HeapReAlloc(GetProcessHeap(), 0, _Memory, _NewSize);
}
TYPE42 *T42_download_header(PSDRV_PDEVICE *physDev, char *ps_name,
RECT *bbox, UINT emsize)
{
DWORD i, j, tablepos, nb_blocks, glyf_off = 0, loca_off = 0, cur_off;
WORD num_of_tables = sizeof(tables_templ) / sizeof(tables_templ[0]) - 1;
char *buf;
TYPE42 *t42;
static const char start[] = /* name, fontbbox */
"25 dict begin\n"
" /FontName /%s def\n"
" /Encoding 256 array 0 1 255{1 index exch /.notdef put} for\n"
" def\n"
" /PaintType 0 def\n"
" /FontMatrix [1 0 0 1 0 0] def\n"
" /FontBBox [%f %f %f %f] def\n"
" /FontType 42 def\n"
" /CharStrings 256 dict begin\n"
" /.notdef 0 def\n"
" currentdict end def\n"
" /sfnts [\n";
static const char TT_offset_table[] = "<00010000%04x%04x%04x%04x\n";
static const char TT_table_dir_entry[] = "%08x%08x%08x%08x\n";
static const char storage[] ="]\nhavetype42gdir{pop}{{string} forall}ifelse\n";
static const char end[] = "] def\n"
"havetype42gdir{/GlyphDirectory 256 dict def\n"
" sfnts 0 get dup\n"
" %d <6c6f6378000000000000000000000000> putinterval\n" /* replace loca entry with dummy locx */
" %d <676c6678000000000000000000000000> putinterval\n" /* replace glyf entry with dummy glfx */
" }if\n"
"currentdict end dup /FontName get exch definefont pop\n";
t42 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*t42));
memcpy(t42->tables, tables_templ, sizeof(tables_templ));
t42->loca_tab = t42->glyf_tab = t42->head_tab = t42->hmtx_tab = -1;
t42->emsize = emsize;
t42->num_of_written_tables = 0;
for(i = 0; i < num_of_tables; i++) {
LoadTable(physDev->hdc, t42->tables + i);
if(t42->tables[i].len > 0xffff && t42->tables[i].write) break;
if(t42->tables[i].write) t42->num_of_written_tables++;
if(t42->tables[i].MS_tag == MS_MAKE_TAG('l','o','c','a'))
t42->loca_tab = i;
else if(t42->tables[i].MS_tag == MS_MAKE_TAG('g','l','y','f'))
t42->glyf_tab = i;
else if(t42->tables[i].MS_tag == MS_MAKE_TAG('h','e','a','d'))
t42->head_tab = i;
else if(t42->tables[i].MS_tag == MS_MAKE_TAG('h','m','t','x'))
t42->hmtx_tab = i;
else if(t42->tables[i].MS_tag == MS_MAKE_TAG('m','a','x','p'))
t42->maxp_tab = i;
}
if(i < num_of_tables) {
TRACE("Table %d has length %d. Will use Type 1 font instead.\n", i, t42->tables[i].len);
T42_free(t42);
return NULL;
}
t42->glyph_sent_size = GLYPH_SENT_INC;
t42->glyph_sent = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
t42->glyph_sent_size *
sizeof(*(t42->glyph_sent)));
buf = HeapAlloc(GetProcessHeap(), 0, sizeof(start) + strlen(ps_name) +
100);
push_lc_numeric("C");
sprintf(buf, start, ps_name,
(float)bbox->left / emsize, (float)bbox->bottom / emsize,
(float)bbox->right / emsize, (float)bbox->top / emsize);
pop_lc_numeric();
PSDRV_WriteSpool(physDev, buf, strlen(buf));
t42->num_of_written_tables++; /* explicitly add glyf */
sprintf(buf, TT_offset_table, t42->num_of_written_tables,
t42->num_of_written_tables, t42->num_of_written_tables, t42->num_of_written_tables);
PSDRV_WriteSpool(physDev, buf, strlen(buf));
tablepos = 12 + t42->num_of_written_tables * 16;
cur_off = 12;
for(i = 0; i < num_of_tables; i++) {
if(!t42->tables[i].write) continue;
sprintf(buf, TT_table_dir_entry, FLIP_ORDER(t42->tables[i].MS_tag),
t42->tables[i].check, t42->tables[i].len ? tablepos : 0,
t42->tables[i].len);
PSDRV_WriteSpool(physDev, buf, strlen(buf));
tablepos += ((t42->tables[i].len + 3) & ~3);
if(t42->tables[i].MS_tag == MS_MAKE_TAG('l','o','c','a'))
loca_off = cur_off;
cur_off += 16;
}
sprintf(buf, TT_table_dir_entry, FLIP_ORDER(t42->tables[t42->glyf_tab].MS_tag),
t42->tables[t42->glyf_tab].check, tablepos, t42->tables[t42->glyf_tab].len);
PSDRV_WriteSpool(physDev, buf, strlen(buf));
PSDRV_WriteSpool(physDev, "00>\n", 4); /* add an extra byte for old PostScript rips */
glyf_off = cur_off;
for(i = 0; i < num_of_tables; i++) {
if(t42->tables[i].len == 0 || !t42->tables[i].write) continue;
PSDRV_WriteSpool(physDev, "<", 1);
for(j = 0; j < ((t42->tables[i].len + 3) & ~3); j++) {
sprintf(buf, "%02x", t42->tables[i].data[j]);
PSDRV_WriteSpool(physDev, buf, strlen(buf));
if(j % 16 == 15) PSDRV_WriteSpool(physDev, "\n", 1);
}
PSDRV_WriteSpool(physDev, "00>\n", 4); /* add an extra byte for old PostScript rips */
}
/* glyf_blocks is a 0 terminated list, holding the start offset of each block. For simplicity
glyf_blocks[0] is 0 */
nb_blocks = 2;
t42->glyf_blocks = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (nb_blocks + 1) * sizeof(DWORD));
for(i = 0; i < GET_BE_WORD(t42->tables[t42->maxp_tab].data + 4); i++) {
DWORD start, end, size;
get_glyf_pos(t42, i, &start, &end);
size = end - t42->glyf_blocks[nb_blocks-2];
if(size > 0x2000 && t42->glyf_blocks[nb_blocks-1] % 4 == 0) {
nb_blocks++;
t42->glyf_blocks = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
t42->glyf_blocks, (nb_blocks + 1) * sizeof(DWORD));
}
t42->glyf_blocks[nb_blocks-1] = end;
}
PSDRV_WriteSpool(physDev, "[ ", 2);
for(i = 1; t42->glyf_blocks[i]; i++) {
sprintf(buf,"%d ", t42->glyf_blocks[i] - t42->glyf_blocks[i-1] + 1);
/* again add one byte for old PostScript rips */
PSDRV_WriteSpool(physDev, buf, strlen(buf));
if(i % 8 == 0)
PSDRV_WriteSpool(physDev, "\n", 1);
}
PSDRV_WriteSpool(physDev, storage, sizeof(storage) - 1);
sprintf(buf, end, loca_off, glyf_off);
PSDRV_WriteSpool(physDev, buf, strlen(buf));
HeapFree(GetProcessHeap(), 0, buf);
return t42;
}
static HRESULT ID3DXFileDataImpl_Create(IDirectXFileObject *dxfile_object, ID3DXFileData **ret_iface)
{
ID3DXFileDataImpl *object;
IDirectXFileObject *data_object;
HRESULT ret;
TRACE("(%p, %p)\n", dxfile_object, ret_iface);
*ret_iface = NULL;
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
if (!object)
return E_OUTOFMEMORY;
object->ID3DXFileData_iface.lpVtbl = &ID3DXFileData_Vtbl;
object->ref = 1;
ret = IDirectXFileObject_QueryInterface(dxfile_object, &IID_IDirectXFileData, (void **)&object->dxfile_data);
if (FAILED(ret))
{
IDirectXFileDataReference *reference;
ret = IDirectXFileObject_QueryInterface(dxfile_object, &IID_IDirectXFileDataReference, (void **)&reference);
if (SUCCEEDED(ret))
{
ret = IDirectXFileDataReference_Resolve(reference, &object->dxfile_data);
if (FAILED(ret))
{
HeapFree(GetProcessHeap(), 0, object);
return E_FAIL;
}
object->reference = TRUE;
}
else
{
FIXME("Don't known what to do with binary object\n");
HeapFree(GetProcessHeap(), 0, object);
return E_FAIL;
}
}
while (SUCCEEDED(ret = IDirectXFileData_GetNextObject(object->dxfile_data, &data_object)))
{
if (object->children)
object->children = HeapReAlloc(GetProcessHeap(), 0, object->children, sizeof(ID3DXFileData*) * (object->nb_children + 1));
else
object->children = HeapAlloc(GetProcessHeap(), 0, sizeof(ID3DXFileData*));
if (!object->children)
{
ret = E_OUTOFMEMORY;
break;
}
ret = ID3DXFileDataImpl_Create(data_object, &object->children[object->nb_children]);
if (ret != S_OK)
break;
object->nb_children++;
}
if (ret != DXFILEERR_NOMOREOBJECTS)
{
(&object->ID3DXFileData_iface)->lpVtbl->Release(&object->ID3DXFileData_iface);
return ret;
}
TRACE("Found %u children\n", object->nb_children);
*ret_iface = &object->ID3DXFileData_iface;
return S_OK;
}
static HRESULT WINAPI ID3DXFileImpl_CreateEnumObject(ID3DXFile *iface, const void *source, D3DXF_FILELOADOPTIONS options, ID3DXFileEnumObject **enum_object)
{
ID3DXFileImpl *This = impl_from_ID3DXFile(iface);
ID3DXFileEnumObjectImpl *object;
IDirectXFileEnumObject *dxfile_enum_object;
void *dxfile_source;
DXFILELOADOPTIONS dxfile_options;
DXFILELOADRESOURCE dxfile_resource;
DXFILELOADMEMORY dxfile_memory;
IDirectXFileData *data_object;
HRESULT ret;
TRACE("(%p)->(%p, %x, %p)\n", iface, source, options, enum_object);
if (!enum_object)
return E_POINTER;
*enum_object = NULL;
if (options == D3DXF_FILELOAD_FROMFILE)
{
dxfile_source = (void*)source;
dxfile_options = DXFILELOAD_FROMFILE;
}
else if (options == D3DXF_FILELOAD_FROMRESOURCE)
{
D3DXF_FILELOADRESOURCE *resource = (D3DXF_FILELOADRESOURCE*)source;
dxfile_resource.hModule = resource->hModule;
dxfile_resource.lpName = resource->lpName;
dxfile_resource.lpType = resource->lpType;
dxfile_source = &dxfile_resource;
dxfile_options = DXFILELOAD_FROMRESOURCE;
}
else if (options == D3DXF_FILELOAD_FROMMEMORY)
{
D3DXF_FILELOADMEMORY *memory = (D3DXF_FILELOADMEMORY*)source;
dxfile_memory.lpMemory = memory->lpMemory;
dxfile_memory.dSize = memory->dSize;
dxfile_source = &dxfile_memory;
dxfile_options = DXFILELOAD_FROMMEMORY;
}
else
{
FIXME("Source type %u is not handled yet\n", options);
return E_NOTIMPL;
}
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
if (!object)
return E_OUTOFMEMORY;
object->ID3DXFileEnumObject_iface.lpVtbl = &ID3DXFileEnumObject_Vtbl;
object->ref = 1;
ret = IDirectXFile_CreateEnumObject(This->dxfile, dxfile_source, dxfile_options, &dxfile_enum_object);
if (ret != S_OK)
{
HeapFree(GetProcessHeap(), 0, object);
return ret;
}
/* Fill enum object with top level data objects */
while (SUCCEEDED(ret = IDirectXFileEnumObject_GetNextDataObject(dxfile_enum_object, &data_object)))
{
if (object->children)
object->children = HeapReAlloc(GetProcessHeap(), 0, object->children, sizeof(*object->children) * (object->nb_children + 1));
else
object->children = HeapAlloc(GetProcessHeap(), 0, sizeof(*object->children));
if (!object->children)
{
ret = E_OUTOFMEMORY;
break;
}
ret = ID3DXFileDataImpl_Create((IDirectXFileObject*)data_object, &object->children[object->nb_children]);
if (ret != S_OK)
break;
object->nb_children++;
}
IDirectXFileEnumObject_Release(dxfile_enum_object);
if (ret != DXFILEERR_NOMOREOBJECTS)
WARN("Cannot get all top level data objects\n");
TRACE("Found %u children\n", object->nb_children);
*enum_object = &object->ID3DXFileEnumObject_iface;
return S_OK;
}
BOOL T42_download_glyph(PSDRV_PDEVICE *physDev, DOWNLOAD *pdl, DWORD index,
char *glyph_name)
{
DWORD start, end, i;
char *buf;
TYPE42 *t42;
const char glyph_def[] =
"/%s findfont exch 1 index\n"
"havetype42gdir\n"
"{/GlyphDirectory get begin %d exch def end}\n"
"{/sfnts get 4 index get 3 index 2 index putinterval pop}\n"
"ifelse\n"
"/CharStrings get\n"
"begin\n"
" /%s %d def\n"
"end\n"
"pop pop\n";
TRACE("%d %s\n", index, glyph_name);
assert(pdl->type == Type42);
t42 = pdl->typeinfo.Type42;
if(index < t42->glyph_sent_size) {
if(t42->glyph_sent[index])
return TRUE;
} else {
t42->glyph_sent_size = (index / GLYPH_SENT_INC + 1) * GLYPH_SENT_INC;
t42->glyph_sent = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
t42->glyph_sent,
t42->glyph_sent_size * sizeof(*(t42->glyph_sent)));
}
if(!get_glyf_pos(t42, index, &start, &end)) return FALSE;
TRACE("start = %x end = %x\n", start, end);
if(GET_BE_WORD(t42->tables[t42->glyf_tab].data + start) == 0xffff) {
/* Composite glyph */
BYTE *sg_start = t42->tables[t42->glyf_tab].data + start + 10;
DWORD sg_flags, sg_index;
char sg_name[MAX_G_NAME + 1];
do {
sg_flags = GET_BE_WORD(sg_start);
sg_index = GET_BE_WORD(sg_start + 2);
TRACE("Sending subglyph %04x for glyph %04x\n", sg_index, index);
get_glyph_name(physDev->hdc, sg_index, sg_name);
T42_download_glyph(physDev, pdl, sg_index, sg_name);
sg_start += 4;
if(sg_flags & ARG_1_AND_2_ARE_WORDS)
sg_start += 4;
else
sg_start += 2;
if(sg_flags & WE_HAVE_A_SCALE)
sg_start += 2;
else if(sg_flags & WE_HAVE_AN_X_AND_Y_SCALE)
sg_start += 4;
else if(sg_flags & WE_HAVE_A_TWO_BY_TWO)
sg_start += 8;
} while(sg_flags & MORE_COMPONENTS);
}
for(i = 1; t42->glyf_blocks[i]; i++)
if(start < t42->glyf_blocks[i]) break;
buf = HeapAlloc(GetProcessHeap(), 0, sizeof(glyph_def) +
strlen(pdl->ps_name) + 100);
/* we don't have a string for the gdir and glyf tables, but we do have a
string for the TT header. So the offset we need is tables - 2 */
sprintf(buf, "%d %d\n", t42->num_of_written_tables - 2 + i, start - t42->glyf_blocks[i-1]);
PSDRV_WriteSpool(physDev, buf, strlen(buf));
PSDRV_WriteSpool(physDev, "<", 1);
for(i = start; i < end; i++) {
sprintf(buf, "%02x", *(t42->tables[t42->glyf_tab].data + i));
PSDRV_WriteSpool(physDev, buf, strlen(buf));
if((i - start) % 16 == 15)
PSDRV_WriteSpool(physDev, "\n", 1);
}
PSDRV_WriteSpool(physDev, ">\n", 2);
sprintf(buf, glyph_def, pdl->ps_name, index, glyph_name, index);
PSDRV_WriteSpool(physDev, buf, strlen(buf));
t42->glyph_sent[index] = TRUE;
HeapFree(GetProcessHeap(), 0, buf);
return TRUE;
}
/******************************************************************************
* Processes a registry file.
* Correctly processes comments (in # and ; form), line continuation.
*
* Parameters:
* in - input stream to read from
* first_chars - beginning of stream, read due to Unicode check
*/
static void processRegLinesA(FILE *in, char* first_chars)
{
LPSTR line = NULL; /* line read from input stream */
ULONG lineSize = REG_VAL_BUF_SIZE;
line = HeapAlloc(GetProcessHeap(), 0, lineSize);
CHECK_ENOUGH_MEMORY(line);
memcpy(line, first_chars, 2);
while (!feof(in)) {
LPSTR s; /* The pointer into line for where the current fgets should read */
WCHAR* lineW;
s = line;
if(first_chars)
{
s += 2;
first_chars = NULL;
}
for (;;) {
size_t size_remaining;
int size_to_get, i;
char *s_eol; /* various local uses */
/* Do we need to expand the buffer ? */
assert (s >= line && s <= line + lineSize);
size_remaining = lineSize - (s-line);
if (size_remaining < 2) /* room for 1 character and the \0 */
{
char *new_buffer;
size_t new_size = lineSize + REG_VAL_BUF_SIZE;
if (new_size > lineSize) /* no arithmetic overflow */
new_buffer = HeapReAlloc (GetProcessHeap(), 0, line, new_size);
else
new_buffer = NULL;
CHECK_ENOUGH_MEMORY(new_buffer);
line = new_buffer;
s = line + lineSize - size_remaining;
lineSize = new_size;
size_remaining = lineSize - (s-line);
}
/* Get as much as possible into the buffer, terminated either by
* eof, error, eol or getting the maximum amount. Abort on error.
*/
size_to_get = (size_remaining > INT_MAX ? INT_MAX : size_remaining);
/* get a single line. note that `i' must be one past the last
* meaningful character in `s' when this loop exits */
for(i = 0; i < size_to_get-1; ++i){
int xchar;
xchar = fgetc(in);
s[i] = xchar;
if(xchar == EOF){
if(ferror(in)){
perror("While reading input");
exit(IO_ERROR);
}else
assert(feof(in));
break;
}
if(s[i] == '\r'){
/* read the next character iff it's \n */
if(i+2 >= size_to_get){
/* buffer too short, so put back the EOL char to
* read next cycle */
ungetc('\r', in);
break;
}
s[i+1] = fgetc(in);
if(s[i+1] != '\n'){
ungetc(s[i+1], in);
i = i+1;
}else
i = i+2;
break;
}
if(s[i] == '\n'){
i = i+1;
break;
}
}
s[i] = '\0';
/* If we didn't read the eol nor the eof go around for the rest */
s_eol = strpbrk (s, "\r\n");
if (!feof (in) && !s_eol) {
s = strchr (s, '\0');
continue;
}
/* If it is a comment line then discard it and go around again */
if (line [0] == '#' || line [0] == ';') {
s = line;
continue;
}
/* Remove any line feed. Leave s_eol on the first \0 */
if (s_eol) {
if (*s_eol == '\r' && *(s_eol+1) == '\n')
*(s_eol+1) = '\0';
*s_eol = '\0';
} else
s_eol = strchr (s, '\0');
/* If there is a concatenating \\ then go around again */
if (s_eol > line && *(s_eol-1) == '\\') {
int c;
s = s_eol-1;
do
{
c = fgetc(in);
} while(c == ' ' || c == '\t');
if(c == EOF)
{
fprintf(stderr,"%s: ERROR - invalid continuation.\n",
getAppName());
}
else
{
*s = c;
s++;
}
continue;
}
lineW = GetWideString(line);
break; /* That is the full virtual line */
}
processRegEntry(lineW, FALSE);
HeapFree(GetProcessHeap(), 0, lineW);
}
processRegEntry(NULL, FALSE);
HeapFree(GetProcessHeap(), 0, line);
}
int
ODBCStringsMatrix::LoadFromRst(CODBCRecordset* pRst, int nDataId, int* pStringIds, int nCount)
{
FreeStringsArray();
if( !pRst->IsBOF() )
pRst->MoveFirst();
m_nColFields = nCount;
const int nHeapBlock = 2048;
long lData = 0;
int nLoop = 0, nIndex = 0, nItem = 0, nAddSize;
int nSize = 0, nSizeOffsets = (nCount + 1)*sizeof(int);
WORD* pStrOffsets = new WORD[nCount*2]; // (WORD)[start offset](WORD)[end offset].
// Create and allocate heap. ####################
if( !m_hHeap )
{
m_hHeap = HeapCreate(0L, nHeapBlock, 0L);
ASSERT( m_hHeap );
m_pBuffer = (BYTE*)HeapAlloc(m_hHeap, 0L, nHeapBlock);
m_nHeapAllocSize = nHeapBlock;
m_nHeapUsedSize = 0;
}
else
m_nHeapUsedSize = 0;
// ###############################################
// Fill full strings array. ##################
CString sValue;
while( !pRst->IsEOF() )
{
int nLoop1 = 2;
lData = pRst->GetLong(nDataId);
// Load field strings and build offsets array.
sValue = pRst->GetString(pStringIds[0]);
pStrOffsets[2] = 0;
pStrOffsets[3] = (WORD)sValue.GetLength();
while( nLoop1 <= nCount )
{
pStrOffsets[nLoop1*2] = pStrOffsets[nLoop1*2 - 1] + 1;
sValue += _T(" ");
sValue += pRst->GetString(pStringIds[nLoop1 - 1]);
pStrOffsets[nLoop1*2 + 1] = (WORD)sValue.GetLength();
nLoop1 ++;
}
// ########################################
// Reallocate heap memory. ################
nAddSize = nSizeOffsets + sValue.GetLength() + 1;
if( m_nHeapUsedSize + nAddSize > m_nHeapAllocSize )
{
m_pBuffer = (BYTE*)HeapReAlloc(m_hHeap, 0L, m_pBuffer, m_nHeapAllocSize + nHeapBlock);
m_nHeapAllocSize += nHeapBlock;
ASSERT( m_pBuffer );
}
// #######################################
// Add offsets array at the head of string.
memcpy(&m_pBuffer[m_nHeapUsedSize], pStrOffsets, nSizeOffsets);
m_nHeapUsedSize += nSizeOffsets;
// #######################################
// Add full string to array. #############
char* pFullString = (char*)&m_pBuffer[m_nHeapUsedSize];
strcpy(pFullString, sValue.GetBuffer());
m_arrFullStrings.Add(lData, (long)m_nHeapUsedSize);
m_nHeapUsedSize += sValue.GetLength() + 1;
// #######################################
pRst->MoveNext(); nLoop ++; nSize += sValue.GetLength() + 1;
}
// ###########################################
// Add full strings(sorted order) to array.##
m_pStringBuffer = new BYTE[nSize];
m_nOffset = 0;
m_nBuffSize = nSize;
while( nItem < nLoop )
{
lData = (long)m_arrFullStrings[nItem];
sValue = ((LPCTSTR)&m_pBuffer[m_arrFullStrings.GetData(nItem)]);
// Add string(cutted to small parts) into buffer and array. ##
AddStringToBufferArray(&sValue, lData);
// ###########################################################
nItem ++;
}
// ###########################################
pRst->Close();
m_arrSearchResult.Copy(&m_arrFullStrings);
delete pStrOffsets;
return nLoop;
}
BOOL
GetAccountSid(
LPTSTR SystemName,
LPTSTR AccountName,
PSID *Sid
)
{
LPTSTR ReferencedDomain=NULL;
LPTSTR TempReferencedDomain = NULL;
LPTSTR TempSid = NULL;
DWORD cbSid=128; // initial allocation attempt
DWORD cchReferencedDomain=16; // initial allocation size
SID_NAME_USE peUse;
BOOL bSuccess=FALSE; // assume this function will fail
__try {
//
// initial memory allocations
//
*Sid = (PSID)HeapAlloc(GetProcessHeap(), 0, cbSid);
if(*Sid == NULL) __leave;
ReferencedDomain = (LPTSTR)HeapAlloc(
GetProcessHeap(),
0,
cchReferencedDomain * sizeof(TCHAR)
);
if(ReferencedDomain == NULL) __leave;
//
// Obtain the SID of the specified account on the specified system.
//
while(!LookupAccountName(
SystemName, // machine to lookup account on
AccountName, // account to lookup
*Sid, // SID of interest
&cbSid, // size of SID
ReferencedDomain, // domain account was found on
&cchReferencedDomain,
&peUse
)) {
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
//
// reallocate memory
//
TempSid = (PSID)HeapReAlloc(
GetProcessHeap(),
0,
*Sid,
cbSid
);
if(TempSid == NULL) __leave;
*Sid = TempSid;
TempReferencedDomain = (LPTSTR)HeapReAlloc(
GetProcessHeap(),
0,
ReferencedDomain,
cchReferencedDomain * sizeof(TCHAR)
);
if(TempReferencedDomain == NULL) __leave;
ReferencedDomain = TempReferencedDomain;
}
else __leave;
}
//
// Indicate success.
//
bSuccess=TRUE;
} // try
__finally {
//
// Cleanup and indicate failure, if appropriate.
//
HeapFree(GetProcessHeap(), 0, ReferencedDomain);
if(!bSuccess) {
if(*Sid != NULL) {
HeapFree(GetProcessHeap(), 0, *Sid);
*Sid = NULL;
}
}
} // finally
return bSuccess;
}
/* find all drivers that can be loaded */
static void findAudioDrivers(void)
{
int numFound = 0;
AUDIO_DRIVER *pAudioDrv = NULL;
HCURSOR old_cursor;
/* delete an existing list */
HeapFree(GetProcessHeap(), 0, loadedAudioDrv);
loadedAudioDrv = 0;
/* change to the wait cursor because this can take a while if there is a
* misbehaving driver that takes a long time to open
*/
old_cursor = SetCursor(LoadCursor(0, IDC_WAIT));
for (pAudioDrv = sAudioDrivers; pAudioDrv->nameID; pAudioDrv++)
{
if (strlen(pAudioDrv->szDriver))
{
HDRVR hdrv;
char driver[MAX_PATH];
sprintf(driver, "wine%s.drv", pAudioDrv->szDriver);
hdrv = pAudioDrv->hDriver;
if (!pAudioDrv->hDriver && (hdrv = OpenDriverA(driver, 0, 0))) {
HMODULE lib = GetDriverModuleHandle(hdrv);
MessagePtr wodMessagePtr = (MessagePtr)GetProcAddress(lib, "wodMessage");
MessagePtr widMessagePtr = (MessagePtr)GetProcAddress(lib, "widMessage");
MessagePtr modMessagePtr = (MessagePtr)GetProcAddress(lib, "modMessage");
MessagePtr midMessagePtr = (MessagePtr)GetProcAddress(lib, "midMessage");
MessagePtr auxMessagePtr = (MessagePtr)GetProcAddress(lib, "auxMessage");
MessagePtr mxdMessagePtr = (MessagePtr)GetProcAddress(lib, "mxdMessage");
pAudioDrv->hDriver = hdrv;
if (wodMessagePtr)
wodMessagePtr(0, DRVM_INIT, 0, 0, 0);
if (widMessagePtr)
widMessagePtr(0, DRVM_INIT, 0, 0, 0);
if (modMessagePtr)
modMessagePtr(0, DRVM_INIT, 0, 0, 0);
if (midMessagePtr)
midMessagePtr(0, DRVM_INIT, 0, 0, 0);
if (auxMessagePtr)
auxMessagePtr(0, DRVM_INIT, 0, 0, 0);
if (mxdMessagePtr)
mxdMessagePtr(0, DRVM_INIT, 0, 0, 0);
}
if (hdrv)
{
if (loadedAudioDrv)
loadedAudioDrv = HeapReAlloc(GetProcessHeap(), 0, loadedAudioDrv, (numFound + 1) * sizeof(AUDIO_DRIVER));
else
loadedAudioDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(AUDIO_DRIVER));
CopyMemory(&loadedAudioDrv[numFound], pAudioDrv, sizeof(AUDIO_DRIVER));
numFound++;
}
}
}
/* restore the original cursor */
SetCursor(old_cursor);
/* terminate list with empty driver */
if (numFound) {
loadedAudioDrv = HeapReAlloc(GetProcessHeap(), 0, loadedAudioDrv, (numFound + 1) * sizeof(AUDIO_DRIVER));
CopyMemory(&loadedAudioDrv[numFound], pAudioDrv, sizeof(AUDIO_DRIVER));
} else {
loadedAudioDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(AUDIO_DRIVER));
CopyMemory(&loadedAudioDrv[0], pAudioDrv, sizeof(AUDIO_DRIVER));
}
}
void __declspec(dllexport) CreateControl(HWND hwndParent, int string_size, char *variables, stack_t **stacktop, extra_parameters *extra)
{
char *className;
char *text;
HWND hwItem;
int x, y, width, height;
DWORD style, exStyle;
size_t id;
// get info from stack
className = (char *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, g_stringsize * 2);
text = &className[g_stringsize];
if (!className)
{
pushstring("error");
return;
}
if (popstringn(className, 0))
{
pushstring("error");
HeapFree(GetProcessHeap(), 0, className);
return;
}
style = (DWORD) popint_or();
exStyle = (DWORD) popint_or();
PopPlacement(&x, &y, &width, &height);
if (popstringn(text, 0))
{
pushstring("error");
HeapFree(GetProcessHeap(), 0, className);
return;
}
// create item descriptor
id = g_dialog.controlCount;
g_dialog.controlCount++;
g_dialog.controls = (struct nsControl*) HeapReAlloc(
GetProcessHeap(),
HEAP_ZERO_MEMORY,
g_dialog.controls,
g_dialog.controlCount * sizeof(struct nsControl));
if (!lstrcmpi(className, "BUTTON"))
g_dialog.controls[id].type = NSCTL_BUTTON;
else if (!lstrcmpi(className, "EDIT"))
g_dialog.controls[id].type = NSCTL_EDIT;
else if (!lstrcmpi(className, "COMBOBOX"))
g_dialog.controls[id].type = NSCTL_COMBOBOX;
else if (!lstrcmpi(className, "LISTBOX"))
g_dialog.controls[id].type = NSCTL_LISTBOX;
else if (!lstrcmpi(className, "RichEdit"))
g_dialog.controls[id].type = NSCTL_RICHEDIT;
else if (!lstrcmpi(className, "RICHEDIT_CLASS"))
g_dialog.controls[id].type = NSCTL_RICHEDIT2;
else if (!lstrcmpi(className, "STATIC"))
g_dialog.controls[id].type = NSCTL_STATIC;
else if (!lstrcmpi(className, "LINK"))
g_dialog.controls[id].type = NSCTL_LINK;
else
g_dialog.controls[id].type = NSCTL_UNKNOWN;
// apply rtl to style
ConvertStyleToRTL(g_dialog.controls[id].type, &style, &exStyle);
// create item's window
hwItem = CreateWindowEx(
exStyle,
lstrcmpi(className, "LINK") ? className : "BUTTON",
text,
style,
x, y, width, height,
g_dialog.hwDialog,
(HMENU) (1200 + id),
g_hInstance,
NULL);
g_dialog.controls[id].window = hwItem;
// remember id
SetProp(hwItem, NSCONTROL_ID_PROP, (HANDLE) (id + 1));
// set font
SendMessage(hwItem, WM_SETFONT, SendMessage(g_dialog.hwParent, WM_GETFONT, 0, 0), TRUE);
// set the WndProc for the link control
if(g_dialog.controls[id].type == NSCTL_LINK)
g_dialog.controls[id].oldWndProc = (WNDPROC) SetWindowLong(hwItem, GWL_WNDPROC, (long) LinkWndProc);
// push back result
pushint((int) hwItem);
// done
HeapFree(GetProcessHeap(), 0, className);
}
int __stdcall AddClientDV ( LPDVINFO lpDVInfo )
{
BOOL bRet = TRUE ;
__try
{
__try
{
// Check all the parameters.
ASSERT ( NULL != lpDVInfo ) ;
ASSERT ( FALSE ==
IsBadCodePtr ( (FARPROC)lpDVInfo->pfnDump) ) ;
ASSERT ( FALSE ==
IsBadCodePtr ( (FARPROC)lpDVInfo->pfnValidate ));
ASSERT ( 0 == lpDVInfo->dwValue ) ;
if ( ( NULL == lpDVInfo ) ||
( TRUE ==
IsBadCodePtr((FARPROC)lpDVInfo->pfnDump ) )||
( TRUE ==
IsBadCodePtr((FARPROC)lpDVInfo->pfnValidate ) )||
( 0 != lpDVInfo->dwValue ) )
{
TRACE ( "Bad parameters to AddClientDV\n" );
return ( FALSE ) ;
}
// Has everything been initialized?
if ( FALSE == g_bLibInit )
{
InitializeLibrary ( ) ;
}
// Block access to the library.
EnterCriticalSection ( &g_stCritSec ) ;
// No matter what, bump up g_dwDVCount.
g_dwDVCount++ ;
// Check that this is not one bump too many.
ASSERT ( (WORD)g_dwDVCount < (WORD)0xFFFF ) ;
if ( (WORD)g_dwDVCount == (WORD)0xFFFF )
{
bRet = FALSE ;
__leave ;
}
// Generate the client block ID.
lpDVInfo->dwValue = CLIENT_BLOCK_VALUE ( g_dwDVCount ) ;
// Is this the first time through?
if ( 1 == g_dwDVCount )
{
ASSERT ( NULL == g_pstDVInfo ) ;
// Allocate the array for the first time.
g_pstDVInfo =
(LPDVINFO)HeapAlloc ( g_hHeap ,
HEAP_GENERATE_EXCEPTIONS |
HEAP_ZERO_MEMORY ,
sizeof ( DVINFO ) );
g_pstDVInfo[ 0 ] = *lpDVInfo ;
}
else
{
// This is not the first time so reallocate the array
// and tack this new puppy on the end.
g_pstDVInfo =
(LPDVINFO)HeapReAlloc ( g_hHeap ,
HEAP_GENERATE_EXCEPTIONS |
HEAP_ZERO_MEMORY ,
g_pstDVInfo ,
g_dwDVCount *
sizeof ( DVINFO));
g_pstDVInfo[ g_dwDVCount - 1 ] = *lpDVInfo ;
}
}
__except ( EXCEPTION_EXECUTE_HANDLER )
{
ASSERT ( !"Had a crash in AddClientDV!" ) ;
bRet = FALSE ;
}
}
__finally
{
LeaveCriticalSection ( &g_stCritSec ) ;
}
return ( bRet ) ;
}
/******************************************************************
* NAS_AddRingMessage
*
* Inserts a new message into the ring (should be called from DriverProc derived routines)
*/
static int NAS_AddRingMessage(MSG_RING* mr, enum win_wm_message msg, DWORD param, BOOL wait)
{
HANDLE hEvent = INVALID_HANDLE_VALUE;
EnterCriticalSection(&mr->msg_crst);
if (mr->msg_toget == ((mr->msg_tosave + 1) % mr->ring_buffer_size))
{
int old_ring_buffer_size = mr->ring_buffer_size;
mr->ring_buffer_size += NAS_RING_BUFFER_INCREMENT;
TRACE("omr->ring_buffer_size=%d\n",mr->ring_buffer_size);
mr->messages = HeapReAlloc(GetProcessHeap(),0,mr->messages, mr->ring_buffer_size * sizeof(RING_MSG));
/* Now we need to rearrange the ring buffer so that the new
buffers just allocated are in between mr->msg_tosave and
mr->msg_toget.
*/
if (mr->msg_tosave < mr->msg_toget)
{
memmove(&(mr->messages[mr->msg_toget + NAS_RING_BUFFER_INCREMENT]),
&(mr->messages[mr->msg_toget]),
sizeof(RING_MSG)*(old_ring_buffer_size - mr->msg_toget)
);
mr->msg_toget += NAS_RING_BUFFER_INCREMENT;
}
}
if (wait)
{
hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
if (hEvent == INVALID_HANDLE_VALUE)
{
ERR("can't create event !?\n");
LeaveCriticalSection(&mr->msg_crst);
return 0;
}
if (mr->msg_toget != mr->msg_tosave && mr->messages[mr->msg_toget].msg != WINE_WM_HEADER)
FIXME("two fast messages in the queue!!!!\n");
/* fast messages have to be added at the start of the queue */
mr->msg_toget = (mr->msg_toget + mr->ring_buffer_size - 1) % mr->ring_buffer_size;
mr->messages[mr->msg_toget].msg = msg;
mr->messages[mr->msg_toget].param = param;
mr->messages[mr->msg_toget].hEvent = hEvent;
}
else
{
mr->messages[mr->msg_tosave].msg = msg;
mr->messages[mr->msg_tosave].param = param;
mr->messages[mr->msg_tosave].hEvent = INVALID_HANDLE_VALUE;
mr->msg_tosave = (mr->msg_tosave + 1) % mr->ring_buffer_size;
}
LeaveCriticalSection(&mr->msg_crst);
SetEvent(mr->msg_event); /* signal a new message */
if (wait)
{
/* wait for playback/record thread to have processed the message */
WaitForSingleObject(hEvent, INFINITE);
CloseHandle(hEvent);
}
return 1;
}
/******************************************************************
* font_enum_size
*
*
*/
static int CALLBACK font_enum_size(const LOGFONT* lf, const TEXTMETRIC* tm,
DWORD FontType, LPARAM lParam)
{
struct dialog_info* di = (struct dialog_info*)lParam;
WCHAR buf[32];
static const WCHAR fmt[] = {'%','l','d',0};
WCUSER_DumpTextMetric(tm, FontType);
if (di->nFont == 0 && !(FontType & RASTER_FONTTYPE))
{
static const int sizes[] = {8,9,10,11,12,14,16,18,20,22,24,26,28,36,48,72};
int i;
di->nFont = sizeof(sizes) / sizeof(sizes[0]);
di->font = HeapAlloc(GetProcessHeap(), 0, di->nFont * sizeof(di->font[0]));
for (i = 0; i < di->nFont; i++)
{
/* drop sizes where window size wouldn't fit on screen */
if (sizes[i] * di->data->curcfg.win_height > GetSystemMetrics(SM_CYSCREEN))
{
di->nFont = i;
break;
}
di->font[i].height = sizes[i];
di->font[i].weight = 400;
lstrcpy(di->font[i].faceName, lf->lfFaceName);
wsprintf(buf, fmt, sizes[i]);
SendDlgItemMessage(di->hDlg, IDC_FNT_LIST_SIZE, LB_INSERTSTRING, i, (LPARAM)buf);
}
/* don't need to enumerate other */
return 0;
}
if (WCUSER_ValidateFontMetric(di->data, tm, FontType))
{
int idx;
/* we want the string to be sorted with a numeric order, not a lexicographic...
* do the job by hand... get where to insert the new string
*/
for (idx = 0; idx < di->nFont && tm->tmHeight > di->font[idx].height; idx++);
while (idx < di->nFont &&
tm->tmHeight == di->font[idx].height &&
tm->tmWeight > di->font[idx].weight)
idx++;
if (idx == di->nFont ||
tm->tmHeight != di->font[idx].height ||
tm->tmWeight < di->font[idx].weight)
{
/* here we need to add the new entry */
wsprintf(buf, fmt, tm->tmHeight);
SendDlgItemMessage(di->hDlg, IDC_FNT_LIST_SIZE, LB_INSERTSTRING, idx, (LPARAM)buf);
/* now grow our arrays and insert the values at the same index than in the list box */
if (di->nFont)
{
di->font = HeapReAlloc(GetProcessHeap(), 0, di->font, sizeof(*di->font) * (di->nFont + 1));
if (idx != di->nFont)
memmove(&di->font[idx + 1], &di->font[idx], (di->nFont - idx) * sizeof(*di->font));
}
else
di->font = HeapAlloc(GetProcessHeap(), 0, sizeof(*di->font));
di->font[idx].height = tm->tmHeight;
di->font[idx].weight = tm->tmWeight;
lstrcpy(di->font[idx].faceName, lf->lfFaceName);
di->nFont++;
}
}
return 1;
}
static inline LRESULT
HexEdit_Char (HEXEDIT_INFO *infoPtr, TCHAR ch)
{
INT nCaretBytePos = infoPtr->nCaretPos/2;
assert(nCaretBytePos >= 0);
/* backspace is special */
if (ch == '\b')
{
if (infoPtr->nCaretPos == 0)
return 0;
/* if at end of byte then delete the whole byte */
if (infoPtr->bFocusHex && (infoPtr->nCaretPos % 2 == 0))
{
memmove(infoPtr->pData + nCaretBytePos - 1,
infoPtr->pData + nCaretBytePos,
infoPtr->cbData - nCaretBytePos);
infoPtr->cbData--;
infoPtr->nCaretPos -= 2; /* backtrack two nibble */
}
else /* blank upper nibble */
{
infoPtr->pData[nCaretBytePos] &= 0x0f;
infoPtr->nCaretPos--; /* backtrack one nibble */
}
}
else
{
if (infoPtr->bFocusHex && hexchar_to_byte(ch) == (BYTE)-1)
{
MessageBeep(MB_ICONWARNING);
return 0;
}
if ((infoPtr->bInsert && (infoPtr->nCaretPos % 2 == 0)) || (nCaretBytePos >= infoPtr->cbData))
{
/* make room for another byte */
infoPtr->cbData++;
infoPtr->pData = HeapReAlloc(GetProcessHeap(), 0, infoPtr->pData, infoPtr->cbData + 1);
if (!infoPtr->pData) return 0;
/* move everything after caret up one byte */
memmove(infoPtr->pData + nCaretBytePos + 1,
infoPtr->pData + nCaretBytePos,
infoPtr->cbData - nCaretBytePos);
/* zero new byte */
infoPtr->pData[nCaretBytePos] = 0x0;
}
/* overwrite a byte */
assert(nCaretBytePos < infoPtr->cbData);
if (infoPtr->bFocusHex)
{
BYTE orig_byte = infoPtr->pData[nCaretBytePos];
BYTE digit = hexchar_to_byte(ch);
if (infoPtr->nCaretPos % 2) /* set low nibble */
infoPtr->pData[nCaretBytePos] = (orig_byte & 0xf0) | digit;
else /* set high nibble */
infoPtr->pData[nCaretBytePos] = (orig_byte & 0x0f) | digit << 4;
infoPtr->nCaretPos++; /* advance one nibble */
}
else
{
infoPtr->pData[nCaretBytePos] = (BYTE)ch;
infoPtr->nCaretPos += 2; /* advance two nibbles */
}
}
HexEdit_UpdateScrollbars(infoPtr);
InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
HexEdit_UpdateCaret(infoPtr);
HexEdit_EnsureVisible(infoPtr, infoPtr->nCaretPos);
return 0;
}
BOOL nulldrv_PolyDraw( PHYSDEV dev, const POINT *points, const BYTE *types, DWORD count )
{
DC *dc = get_nulldrv_dc( dev );
POINT *line_pts = NULL, *bzr_pts = NULL, bzr[4];
DWORD i;
INT num_pts, num_bzr_pts, space, size;
/* check for valid point types */
for (i = 0; i < count; i++)
{
switch (types[i])
{
case PT_MOVETO:
case PT_LINETO | PT_CLOSEFIGURE:
case PT_LINETO:
break;
case PT_BEZIERTO:
if (i + 2 >= count) return FALSE;
if (types[i + 1] != PT_BEZIERTO) return FALSE;
if ((types[i + 2] & ~PT_CLOSEFIGURE) != PT_BEZIERTO) return FALSE;
i += 2;
break;
default:
return FALSE;
}
}
space = count + 300;
line_pts = HeapAlloc( GetProcessHeap(), 0, space * sizeof(POINT) );
num_pts = 1;
line_pts[0] = dc->cur_pos;
for (i = 0; i < count; i++)
{
switch (types[i])
{
case PT_MOVETO:
if (num_pts >= 2) Polyline( dev->hdc, line_pts, num_pts );
num_pts = 0;
line_pts[num_pts++] = points[i];
break;
case PT_LINETO:
case (PT_LINETO | PT_CLOSEFIGURE):
line_pts[num_pts++] = points[i];
break;
case PT_BEZIERTO:
bzr[0].x = line_pts[num_pts - 1].x;
bzr[0].y = line_pts[num_pts - 1].y;
memcpy( &bzr[1], &points[i], 3 * sizeof(POINT) );
if ((bzr_pts = GDI_Bezier( bzr, 4, &num_bzr_pts )))
{
size = num_pts + (count - i) + num_bzr_pts;
if (space < size)
{
space = size * 2;
line_pts = HeapReAlloc( GetProcessHeap(), 0, line_pts, space * sizeof(POINT) );
}
memcpy( &line_pts[num_pts], &bzr_pts[1], (num_bzr_pts - 1) * sizeof(POINT) );
num_pts += num_bzr_pts - 1;
HeapFree( GetProcessHeap(), 0, bzr_pts );
}
i += 2;
break;
}
if (types[i] & PT_CLOSEFIGURE) line_pts[num_pts++] = line_pts[0];
}
if (num_pts >= 2) Polyline( dev->hdc, line_pts, num_pts );
HeapFree( GetProcessHeap(), 0, line_pts );
return TRUE;
}
void *globalrealloc(void *oldp,size_t newsize)
{
#if 0
void *p;
// Initialize heap
if (!hHeap)
{ hHeap = HeapCreate(0,0x10000,0);
if (!hHeap)
os_error();
}
newsize = (newsize + 3) & ~3L; // round up to dwords
if (newsize == 0)
{
if (oldp && HeapFree(hHeap,0,oldp) == FALSE)
os_error();
p = NULL;
}
else if (!oldp)
{
p = newsize ? HeapAlloc(hHeap,0,newsize) : NULL;
}
else
p = HeapReAlloc(hHeap,0,oldp,newsize);
#elif 1
MEMORY_BASIC_INFORMATION query;
void *p;
BOOL bSuccess;
if (!oldp)
p = VirtualAlloc (NULL, newsize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
else
{
VirtualQuery (oldp, &query, sizeof(query));
if (!newsize)
{
p = NULL;
goto L1;
}
else
{ newsize = (newsize + 0xFFFF) & ~0xFFFFL;
if (query.RegionSize >= newsize)
p = oldp;
else
{ p = VirtualAlloc(NULL,newsize,MEM_COMMIT | MEM_RESERVE,PAGE_READWRITE);
if (p)
memcpy(p,oldp,query.RegionSize);
L1:
bSuccess = VirtualFree(oldp,query.RegionSize,MEM_DECOMMIT);
if (bSuccess)
bSuccess = VirtualFree(oldp,0,MEM_RELEASE);
if (!bSuccess)
os_error();
}
}
}
#else
void *p;
if (!oldp)
p = (void *)GlobalAlloc (0, newsize);
else if (!newsize)
{ GlobalFree(oldp);
p = NULL;
}
else
p = (void *)GlobalReAlloc(oldp,newsize,0);
#endif
dbg_printf("globalrealloc(oldp = %p, size = x%x) = %p\n",oldp,newsize,p);
return p;
}
static int UpdateFileData(
HWND hDlg,
LPCSTR szDataToFill,
size_t OffsetToFill,
UINT FillPattern)
{
TFileTestData * pData = GetDialogData(hDlg);
LONGLONG ByteOffset;
LPBYTE WritePattern = (LPBYTE)"BAADF00D";
ULONG NewLength;
ULONG i;
size_t cchDataToFill = 0;
HWND hWndChild = GetDlgItem(hDlg, IDC_FILE_DATA);
// Get the byte offset
DlgText2Hex64(hDlg, IDC_BYTE_OFFSET, &ByteOffset);
DlgText2Hex32(hDlg, IDC_LENGTH, &NewLength);
// Clear the file data from the data editor
DataEditor_SetData(hWndChild, 0, NULL, 0);
// Determine the new length of the data
if(szDataToFill != NULL)
{
cchDataToFill = strlen(szDataToFill);
NewLength = (ULONG)(OffsetToFill + cchDataToFill);
}
// If we need to increase the buffer size, do it
if(NewLength > pData->cbFileDataMax)
{
pData->pbFileData = (LPBYTE)HeapReAlloc(g_hHeap, HEAP_ZERO_MEMORY, pData->pbFileData, NewLength);
if(pData->pbFileData == NULL)
return ERROR_NOT_ENOUGH_MEMORY;
pData->cbFileDataMax = NewLength;
}
// If we shall fill the data with custom data, do it
if(szDataToFill != NULL)
{
// Fill the gap after end of current data with zeros
if(OffsetToFill > pData->cbFileData)
memset(pData->pbFileData + pData->cbFileData, 0, OffsetToFill - pData->cbFileData);
memcpy(pData->pbFileData + OffsetToFill, szDataToFill, cchDataToFill);
}
// If the caller required us to fill the data with pattern, do it
else
{
// If the new pattern is zero, it means to fill the same pattern like before
if(FillPattern == 0)
FillPattern = pData->FillPattern;
// If the pattern is the same like before, just fill the remaining part
if(OffsetToFill < NewLength)
{
switch(FillPattern)
{
case IDC_FILL_DATA_ZEROS:
memset(pData->pbFileData + OffsetToFill, 0, NewLength - OffsetToFill);
break;
case IDC_FILL_DATA_PATTERN:
for(i = (ULONG)OffsetToFill; i < NewLength; i++)
pData->pbFileData[i] = WritePattern[i % 8];
break;
case IDC_FILL_DATA_RANDOM:
srand(GetTickCount());
for(i = (ULONG)OffsetToFill; i < NewLength; i++)
pData->pbFileData[i] = (BYTE)(rand() % 0x100);
break;
}
}
// Remember the current pattern
pData->FillPattern = FillPattern;
}
// Remember the new data length
if(NewLength != pData->cbFileData)
{
Hex2DlgText32(hDlg, IDC_LENGTH, NewLength);
pData->cbFileData = NewLength;
}
// Apply the new file data
DataEditor_SetData(hWndChild, ByteOffset, pData->pbFileData, pData->cbFileData);
return ERROR_SUCCESS;
}
