ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Assorted spelling fixes.

This commit is contained in:
Francois Gouget 2005-07-11 10:59:41 +00:00 committed by Alexandre Julliard
parent 50f7733059
commit 28dc5a8afc
16 changed files with 70 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
dlls/advapi32/lsa.c
View File

@ -104,7 +104,7 @@ NTSTATUS WINAPI LsaClose(IN LSA_HANDLE ObjectHandle)
* PolicyHandle [I] Handle to a Policy object.
* EnumerationContext [I] Pointer to an enumeration handle.
* Buffer [O] Contains the names and SIDs of trusted domains.
* PreferedMaximumLength [I] Prefered maximum size in bytes of Buffer.
* PreferredMaximumLength[I] Preferred maximum size in bytes of Buffer.
* CountReturned [O] Number of elements in Buffer.
*
* RETURNS
@ -121,11 +121,11 @@ NTSTATUS WINAPI LsaEnumerateTrustedDomains(
IN LSA_HANDLE PolicyHandle,
IN PLSA_ENUMERATION_HANDLE EnumerationContext,
OUT PVOID* Buffer,
IN ULONG PreferedMaximumLength,
IN ULONG PreferredMaximumLength,
OUT PULONG CountReturned)
{
FIXME("(%p,%p,%p,0x%08lx,%p) stub\n", PolicyHandle, EnumerationContext,
Buffer, PreferedMaximumLength, CountReturned);
Buffer, PreferredMaximumLength, CountReturned);
if (CountReturned) *CountReturned = 0;
return STATUS_SUCCESS;

2
dlls/comctl32/tests/dpa.c
View File

@ -284,7 +284,7 @@ static void test_dpa(void)
todo_wine ok(j+1 == i, "j=%d i=%d\n", j, i);
}
/* Try to get the index of a non-existent item */
/* Try to get the index of a nonexistent item */
i = pDPA_GetPtrIndex(dpa, (PVOID)7);
ok(i == DPA_ERR, "i=%d\n", i);

2
dlls/d3d8/device.c
View File

@ -4608,7 +4608,7 @@ HRESULT WINAPI IDirect3DDevice8Impl_ActiveRender(LPDIRECT3DDEVICE8 iface,
vcheckGLcall("glFlush");
#ifdef EXTRA_TRACES
/** very very usefull debug code */
/** very very useful debug code */
glXSwapBuffers(This->display, This->drawable);
printf("Hit Enter to get next frame ...\n");
getchar();

4
dlls/d3d9/stateblock.c
View File

@ -138,7 +138,9 @@ HRESULT WINAPI IDirect3DDevice9Impl_EndStateBlock(LPDIRECT3DDEVICE9 iface, IDi
TRACE("(%p) Relay\n", This);
/*Tell wineD3D to endstatablock before anything else (incase we run out of memory later and cause locking problems)*/
/* Tell wineD3D to endstatablock before anything else (in case we run out
* of memory later and cause locking problems)
*/
hr=IWineD3DDevice_EndStateBlock(This->WineD3DDevice,&wineD3DStateBlock);
if(hr!= D3D_OK){
FIXME("IWineD3DDevice_EndStateBlock returned an error\n");

2
dlls/ddraw/surface_dib.c
View File

@ -476,7 +476,7 @@ static void DoDXTCDecompression(const DDSURFACEDESC2 *sdesc, const DDSURFACEDESC
*((DWORD*)(dst+y*pitch+x*(is16?2:4))) = pixel;
}
}
#if 0 /* Usefull for debugging */
#if 0 /* Useful for debugging */
{
static int idx;
char texname[255];

2
dlls/dmime/tempotrack.c
View File

@ -117,7 +117,7 @@ static HRESULT WINAPI IDirectMusicTempoTrack_IDirectMusicTrack_InitPlay (LPDIREC
ERR(": no more memory\n");
return E_OUTOFMEMORY;
}
/** TODO real fill usefull datas */
/** TODO real fill useful datas */
pState->dummy = 0;
*ppStateData = pState;
return S_OK;

2
dlls/shell32/shlexec.c
View File

@ -743,7 +743,7 @@ UINT SHELL_FindExecutable(LPCWSTR lpPath, LPCWSTR lpFile, LPCWSTR lpOperation,
/******************************************************************
* dde_cb
*
* callback for the DDE connection. not really usefull
* callback for the DDE connection. not really useful
*/
static HDDEDATA CALLBACK dde_cb(UINT uType, UINT uFmt, HCONV hConv,
HSZ hsz1, HSZ hsz2, HDDEDATA hData,

4
dlls/shell32/tests/shlfolder.c
View File

@ -131,8 +131,8 @@ static void test_EnumObjects(IShellFolder *iFolder)
hr = IShellFolder_EnumObjects(iFolder, NULL, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS | SHCONTF_INCLUDEHIDDEN, &iEnumList);
ok(hr == S_OK, "EnumObjects failed %08lx\n", hr);
/* This is to show that, contrary to what is said on MSDN on IEnumIDList::Next,
* the filesystem shellfolders return S_OK even if less then 'celt' items are
/* This is to show that, contrary to what is said on MSDN, on IEnumIDList::Next,
* the filesystem shellfolders return S_OK even if less than 'celt' items are
* returned (in contrast to S_FALSE). We have to do it in a loop since WinXP
* only ever returns a single entry per call. */
while (IEnumIDList_Next(iEnumList, 10-i, &idlArr[i], &NumPIDLs) == S_OK)

68
dlls/wined3d/device.c
View File

@ -299,12 +299,12 @@ ULONG WINAPI IWineD3DDeviceImpl_Release(IWineD3DDevice *iface) {
/* TODO: Clean up all the surfaces and textures! */
/* FIXME: Create targets and state blocks in d3d8 */
if (((IWineD3DImpl *)This->wineD3D)->dxVersion > 8) { /*We don't create a state block in d3d8 yet*/
/* NOTE: You must release the parent if the objects was created via a callback
/* NOTE: You must release the parent if the object was created via a callback
** ***************************/
int i;
IUnknown* swapChainParent;
/* Release all of the swapchains, except the implicite swapchain (#0) */
/* Release all of the swapchains, except the implicit swapchain (#0) */
for(i = 1; i < This->numberOfSwapChains; i++){
/* TODO: don't access swapchains[x] directly! */
IWineD3DSwapChain_Release(This->swapchains[i]);
@ -315,12 +315,12 @@ ULONG WINAPI IWineD3DDeviceImpl_Release(IWineD3DDevice *iface) {
}
if (This->swapchains[0] != NULL) {
/* Swapchain 0 is special because it's created in startup with a hanging parent, so we have to release it's parent now */
/* Swapchain 0 is special because it's created in startup with a hanging parent, so we have to release its parent now */
/* TODO: don't access swapchains[x] directly!, check that there are no-more swapchains left for this device! */
IWineD3DSwapChain_GetParent(This->swapchains[0], &swapChainParent);
IUnknown_Release(swapChainParent); /* once for the get parent */
if (IUnknown_Release(swapChainParent) > 0){ /* the second time for when it was created */
FIXME("(%p) Something's still holding the implicite swapchain\n",This);
FIXME("(%p) Something's still holding the implicit swapchain\n",This);
}
}
@ -405,7 +405,7 @@ HRESULT WINAPI IWineD3DDeviceImpl_CreateStateBlock(IWineD3DDevice* iface, D3DSTA
memset(object->streamFreq, 1, sizeof(object->streamFreq));
}
/* Reset the ref and type after kluging it */
/* Reset the ref and type after kludging it */
object->wineD3DDevice = This;
object->ref = 1;
object->blockType = Type;
@ -1034,9 +1034,9 @@ HRESULT WINAPI IWineD3DDeviceImpl_CreateAdditionalSwapChain(IWineD3DDevice* ifac
{
IWineD3DSwapChain *implSwapChain;
if (D3D_OK != IWineD3DDevice_GetSwapChain(iface, 0, &implSwapChain)) {
/* The first time around we create the context that is shared with all other swapchians and render targets */
/* The first time around we create the context that is shared with all other swapchains and render targets */
object->glCtx = glXCreateContext(object->display, object->visInfo, NULL, GL_TRUE);
TRACE("Creating implicite context for vis %p, hwnd %p\n", object->display, object->visInfo);
TRACE("Creating implicit context for vis %p, hwnd %p\n", object->display, object->visInfo);
} else {
TRACE("Creating context for vis %p, hwnd %p\n", object->display, object->visInfo);
@ -1073,7 +1073,7 @@ HRESULT WINAPI IWineD3DDeviceImpl_CreateAdditionalSwapChain(IWineD3DDevice* ifac
/**
* TODO: MSDN says that we are only allowed one fullscreen swapchain per device,
* so we should really check to see if their is a fullscreen swapchain already
* I think Windows and X have differnt ideas about fullscreen, does a single head count as full screen?
* I think Windows and X have different ideas about fullscreen, does a single head count as full screen?
**************************************/
if (!*(pPresentationParameters->Windowed)) {
@ -1303,7 +1303,7 @@ HRESULT WINAPI IWineD3DDeviceImpl_CreateAdditionalSwapChain(IWineD3DDevice* ifac
return hr;
}
/** NOTE: These are ahead of the other getters and setters to save using a forward declartion **/
/** NOTE: These are ahead of the other getters and setters to save using a forward declaration **/
UINT WINAPI IWineD3DDeviceImpl_GetNumberOfSwapChains(IWineD3DDevice *iface) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
@ -1483,7 +1483,7 @@ HRESULT WINAPI IWineD3DDeviceImpl_GetStreamSourceFreq(IWineD3DDevice *iface, UI
}
/*****
* Get / Set & Multipy Transform
* Get / Set & Multiply Transform
*****/
HRESULT WINAPI IWineD3DDeviceImpl_SetTransform(IWineD3DDevice *iface, D3DTRANSFORMSTATETYPE d3dts, CONST D3DMATRIX* lpmatrix) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
@ -4797,7 +4797,7 @@ HRESULT WINAPI IWineD3DDeviceImpl_SetRenderTarget(IWineD3DDevice *iface, DWORD R
}
/* MSDN says that null disables the render target
but a device must always be associatated with a render target
but a device must always be associated with a render target
nope MSDN says that we return invalid call to a null rendertarget with an index of 0
see http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/programmingguide/AdvancedTopics/PixelPipe/MultipleRenderTarget.asp
@ -4823,16 +4823,16 @@ HRESULT WINAPI IWineD3DDeviceImpl_SetRenderTarget(IWineD3DDevice *iface, DWORD R
TRACE("clearing renderer\n");
/* IWineD3DDeviceImpl_CleanRender(iface); */
/* OpenGL doesn't support 'sharing' of the stencilBuffer so we may incure an extra memory overhead
depending on the renter target implemenattion being used.
depending on the renter target implementation being used.
A shared context implementation will share all buffers between all rendertargets (including swapchains),
implemenations that use serperate pbuffers for different swapchains or rendertargets will have to duplicate the
implementations that use separate pbuffers for different swapchains or rendertargets will have to duplicate the
stencil buffer and incure an extra memory overhead */
hr = IWineD3DDeviceImpl_ActiveRender(iface, pRenderTarget);
}
if (SUCCEEDED(hr)) {
/* Finally, reset the viewport as the MSDN states. */
/* TODO: Repalace impl usage */
/* TODO: Replace impl usage */
viewport.Height = ((IWineD3DSurfaceImpl *)This->renderTarget)->currentDesc.Height;
viewport.Width = ((IWineD3DSurfaceImpl *)This->renderTarget)->currentDesc.Width;
viewport.X = 0;
@ -4858,9 +4858,9 @@ HRESULT WINAPI IWineD3DDeviceImpl_SetDepthStencilSurface(IWineD3DDevice *iface,
TRACE("Trying to do a NOP SetRenderTarget operation\n");
}else{
/** OpenGL doesn't support 'sharing' of the stencilBuffer so we may incure an extra memory overhead
* depending on the renter target implemenattion being used.
* depending on the renter target implementation being used.
* A shared context implementation will share all buffers between all rendertargets (including swapchains),
* implemenations that use serperate pbuffers for different swapchains or rendertargets will have to duplicate the
* implementations that use separate pbuffers for different swapchains or rendertargets will have to duplicate the
* stencil buffer and incure an extra memory overhead
******************************************************/
@ -4915,7 +4915,7 @@ HRESULT WINAPI IWineD3DDeviceImpl_CleanRender(IWineD3DDevice* iface, IWineD3DSwa
glXDestroyPbuffer(swapchain->display, swapchain->drawable);
#endif
LEAVE_GL();
/* Set everything back to the way that it ws */
/* Set everything back the way it ws */
swapchain->render_ctx = swapchain->glCtx;
swapchain->drawable = swapchain->win;
}
@ -4923,8 +4923,8 @@ HRESULT WINAPI IWineD3DDeviceImpl_CleanRender(IWineD3DDevice* iface, IWineD3DSwa
}
/** FIXME: This is currently used called whenever SetRenderTarget or SetStencilBuffer are called
* the functiolaity needs splitting up so that we don't do more than we should do.
* this only seems to affect performance a little.
* the functionality needs splitting up so that we don't do more than we should do.
* this only seems to impact performance a little.
******************************/
HRESULT WINAPI IWineD3DDeviceImpl_ActiveRender(IWineD3DDevice* iface,
IWineD3DSurface *RenderSurface) {
@ -4938,10 +4938,10 @@ HRESULT WINAPI IWineD3DDeviceImpl_ActiveRender(IWineD3DDevice* iface,
* for others versions we'll have to use GLXPixmaps
*
* normally we must test GLX_VERSION_1_3 but nvidia headers are not correct
* as they implements GLX 1.3 but only define GLX_VERSION_1_2
* as they implement GLX 1.3 but only define GLX_VERSION_1_2
* so only check OpenGL version
* ..........................
* I don't belive that it is a problem with NVidia headers,
* I don't believe that it is a problem with NVidia headers,
* XFree only supports GLX1.2, nVidia (and ATI to some extent) provide 1.3 functions
* in GLX 1.2, there is no mention of the correct way to tell if the extensions are provided.
* ATI Note:
@ -4957,7 +4957,7 @@ HRESULT WINAPI IWineD3DDeviceImpl_ActiveRender(IWineD3DDevice* iface,
int nAttribs = 0;
IWineD3DSwapChain *currentSwapchain;
IWineD3DSwapChainImpl *swapchain;
/** TODO: get rid of Impl usage we should always create a zbuffer/stencil with our contexts if pussible,
/** TODO: get rid of Impl usage we should always create a zbuffer/stencil with our contexts if possible,
* but switch them off if the StencilSurface is set to NULL
** *********************************************************/
D3DFORMAT BackBufferFormat = ((IWineD3DSurfaceImpl *) RenderSurface)->resource.format;
@ -4969,7 +4969,7 @@ HRESULT WINAPI IWineD3DDeviceImpl_ActiveRender(IWineD3DDevice* iface,
IWineD3DSurface *tmp;
/**TODO:
if StencilSurface == NULL && zBufferTarget != NULL then swtich the zbuffer off,
if StencilSurface == NULL && zBufferTarget != NULL then switch the zbuffer off,
it StencilSurface != NULL && zBufferTarget == NULL switch it on
*/
@ -4978,11 +4978,11 @@ HRESULT WINAPI IWineD3DDeviceImpl_ActiveRender(IWineD3DDevice* iface,
/* PUSH2(GLX_BIND_TO_TEXTURE_RGBA_ATI, True); examples of this are few and far between (but I've got a nice working one!)*/
/** TODO: remove the reff to Impl (context manager should fis this!) **/
/** TODO: remove the reff to Impl (context manager should fix this!) **/
IWineD3DSwapChainImpl *impSwapChain;
IWineD3DDevice_GetSwapChain(iface, 0, (IWineD3DSwapChain **)&impSwapChain);
if (NULL == impSwapChain){ /* NOTE: This should NEVER fail */
ERR("(%p) Failed to get a the implicite swapchain\n", iface);
ERR("(%p) Failed to get a the implicit swapchain\n", iface);
}
ENTER_GL();
@ -5000,7 +5000,7 @@ HRESULT WINAPI IWineD3DDeviceImpl_ActiveRender(IWineD3DDevice* iface,
cfgs = glXChooseFBConfig(impSwapChain->display, DefaultScreen(impSwapChain->display),
attribs, &nCfgs);
if (!cfgs){ /* OK we didn't find the exact config, so use any reasonably match */
if (!cfgs){ /* OK we didn't find the exact config, so use any reasonable match */
/* TODO: fill in the 'requested' and 'current' depths, also make sure that's
why we failed and only show this message once! */
MESSAGE("Failed to find exact match, finding alternative but you may suffer performance issues, try changing xfree's depth to match the requested depth\n"); /**/
@ -5030,7 +5030,7 @@ HRESULT WINAPI IWineD3DDeviceImpl_ActiveRender(IWineD3DDevice* iface,
#ifdef EXTRA_TRACES
glFlush();
vcheckGLcall("glFlush");
/** This is only usefuly if the old render target was a swapchain,
/** This is only useful if the old render target was a swapchain,
* we need to supercede this with a function that displays
* the current buffer on the screen. This is easy to do in glx1.3 but
* we need to do copy-write pixels in glx 1.2.
@ -5043,7 +5043,7 @@ HRESULT WINAPI IWineD3DDeviceImpl_ActiveRender(IWineD3DDevice* iface,
}
if (IWineD3DSurface_GetContainer(This->renderTarget, &IID_IWineD3DSwapChain, (void **)&currentSwapchain) != D3D_OK){
/* the selected render target doesn't belong to a swapchain, so use the devices implicite swapchain */
/* the selected render target doesn't belong to a swapchain, so use the devices implicit swapchain */
IWineD3DDevice_GetSwapChain(iface, 0, &currentSwapchain);
}
@ -5096,21 +5096,21 @@ HRESULT WINAPI IWineD3DDeviceImpl_ActiveRender(IWineD3DDevice* iface,
|| Height > ((IWineD3DSurfaceImpl *)This->renderTarget)->currentDesc.Height))) {
/** ********************************************************************
* This code is far too leaky to be usefull IWineD3DDeviceImpl_CleanRender
* doesn't seem to work properly and creating a new context Every time is 'extream' overkill.
* This code is far too leaky to be useful. IWineD3DDeviceImpl_CleanRender
* doesn't seem to work properly and creating a new context every time is 'extremely' overkill.
* The code does however work, and should be moved to a context manager to
* manage caching of pbuffers or render to texture are appropriate.
*
* There are some real speed vs compatability issues here:
* There are some real speed vs compatibility issues here:
* we should really use a new context for every texture, but that eats ram.
* we should also be restoring the texture to the pbuffer but that eats CPU
* we can also 'reuse' the current pbuffer if the size is larger than the requested buffer,
* but if this means reusing the display backbuffer then we need to make sure that
* states are correctly preserved.
* In many cases I would expect that we can 'skip' some functions, such as preserving states,
* and gain a good performance increase at the cost of compatability.
* and gain a good performance increase at the cost of compatibility.
* I would suggest that, when this is the case, a user configurable flag be made
* available, alowing the user to choose the best emmulated experiance for them.
* available, allowing the user to choose the best emulated experience for them.
*********************************************************************/
/**
@ -5183,7 +5183,7 @@ HRESULT WINAPI IWineD3DDeviceImpl_ActiveRender(IWineD3DDevice* iface,
/** TODO: We may need to copy the bits into the buffer,
* this should !!ONLY!! be done if an operation is performed on the target
* without it being cleared and the buffer is not discardable.
* (basicly only bother preserving the contents if there's a possiblity that it will be reused)
* (basically only bother preserving the contents if there's a possibility that it will be reused)
** *********************************************************************/
impSwapChain->drawable = newDrawable;
impSwapChain->render_ctx = newContext;

4
dlls/wined3d/directx.c
View File

@ -1582,8 +1582,8 @@ HRESULT WINAPI IWineD3DImpl_CreateDevice(IWineD3D *iface, UINT Adapter, D3DDEV
IWineD3DStateBlock_AddRef((IWineD3DStateBlock*)object->updateStateBlock);
/* Setup surfaces for the backbuffer, frontbuffer and depthstencil buffer */
/* Setup the implicite swapchain */
TRACE("Creating implicite swapchain\n");
/* Setup the implicit swapchain */
TRACE("Creating implicit swapchain\n");
if (D3D_OK == D3DCB_CreateAdditionalSwapChain((IUnknown *) object->parent, pPresentationParameters, (IWineD3DSwapChain **)&swapchain) && swapchain != NULL) {

10
dlls/wined3d/drawprim.c
View File

@ -430,7 +430,7 @@ void primitiveDeclarationConvertToStridedData(IWineD3DDevice *iface, Direct3DVer
break;
case D3DDECLUSAGE_TEXCOORD:
/* For some odd reason Microsoft desided to sum usage accross all the streams,
/* For some odd reason Microsoft decided to sum usage accross all the streams,
which means we need to do a count and not just use the usage number */
strided->u.s.texCoords[textureNo].lpData = data;
@ -451,9 +451,9 @@ void primitiveDeclarationConvertToStridedData(IWineD3DDevice *iface, Direct3DVer
TRACE("Tangents\n");
break;
case D3DDECLUSAGE_BINORMAL:
/* Binormals are really bitangents perpendicular to the normal but s-aligned to the tangent, basicly they are the vectors of any two lines on the plain at right angles to the normal and at right angles to each other, like the x,y,z axis.
tangent data makes it easier to perform some calcualtions (a bit like using 2d graph paper instead of the normal of the piece of paper)
The only thing they are usefull for in fixed function would be working out normals when none are give.
/* Binormals are really bitangents perpendicular to the normal but s-aligned to the tangent, basically they are the vectors of any two lines on the plain at right angles to the normal and at right angles to each other, like the x,y,z axis.
tangent data makes it easier to perform some calculations (a bit like using 2d graph paper instead of the normal of the piece of paper)
The only thing they are useful for in fixed function would be working out normals when none are given.
*/
#if 0
strided->u.s.binormal.lpData = data;
@ -464,7 +464,7 @@ void primitiveDeclarationConvertToStridedData(IWineD3DDevice *iface, Direct3DVer
TRACE("BI-Normal\n");
break;
case D3DDECLUSAGE_TESSFACTOR:
/* a google for D3DDECLUSAGE_TESSFACTOR turns up a wopping 36 entries, 7 of which are from MSDN.
/* a google for D3DDECLUSAGE_TESSFACTOR turns up a whopping 36 entries, 7 of which are from MSDN.
*/
#if 0
strided->u.s.tessFacrot.lpData = data;

12
dlls/wined3d/surface.c
View File

@ -308,14 +308,14 @@ HRESULT WINAPI IWineD3DSurfaceImpl_LockRect(IWineD3DSurface *iface, D3DLOCKED_RE
/* Here's what we have to do:
See if the swapchain has the same context as the renderTarget or the surface is the render target.
Otherwise, see if were sharing a context with the implicite swapchain (because were using a shared context model!)
and use the fron back buffer as required.
Otherwise, see if were sharing a context with the implicit swapchain (because we're using a shared context model!)
and use the front back buffer as required.
if not, we need to switch contexts and then switchback at the end.
*/
IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapchain);
IWineD3DSurface_GetContainer(myDevice->renderTarget, &IID_IWineD3DSwapChain, (void **)&targetSwapChain);
/* NOTE: In a shared context environment the renderTarget will use the same context as the implicite swapchain (we're not in a shared environment yet! */
/* NOTE: In a shared context environment the renderTarget will use the same context as the implicit swapchain (we're not in a shared environment yet! */
if ((swapchain == targetSwapChain && targetSwapChain != NULL) || iface == myDevice->renderTarget) {
if (iface == myDevice->renderTarget || iface == swapchain->backBuffer) {
TRACE("locking back buffer\n");
@ -333,7 +333,7 @@ HRESULT WINAPI IWineD3DSurfaceImpl_LockRect(IWineD3DSurface *iface, D3DLOCKED_RE
IWineD3DSwapChainImpl *implSwapChain;
IWineD3DDevice_GetSwapChain((IWineD3DDevice *)myDevice, 0, (IWineD3DSwapChain **)&implSwapChain);
if (swapchain->glCtx == implSwapChain->render_ctx && swapchain->drawable == implSwapChain->win) {
/* This will fail for the implicite swapchain, which is why there needs to be a context manager */
/* This will fail for the implicit swapchain, which is why there needs to be a context manager */
if (iface == swapchain->backBuffer) {
glReadBuffer(GL_BACK);
}else if (iface == swapchain->frontBuffer) {
@ -376,8 +376,8 @@ HRESULT WINAPI IWineD3DSurfaceImpl_LockRect(IWineD3DSurface *iface, D3DLOCKED_RE
GLenum format = D3DFmt2GLFmt(myDevice, This->resource.format);
GLenum type = D3DFmt2GLType(myDevice, This->resource.format);
#if 0
/* Bizarly it's takes 120 millseconds to get an 800x600 region a line at a time, but only 10 to get the whole lot every time,
* This is on an ATI9600, and may be format dependant, anyhow this hack makes this demo dx9_2d_demo_game
/* Bizarly it takes 120 millseconds to get an 800x600 region a line at a time, but only 10 to get the whole lot every time,
* This is on an ATI9600, and may be format dependent, anyhow this hack makes this demo dx9_2d_demo_game
* run ten times faster!
* ************************************/
BOOL ati_performance_hack = FALSE;

8
dlls/wined3d/swapchain.c
View File

@ -145,7 +145,7 @@ HRESULT WINAPI IWineD3DSwapChainImpl_Present(IWineD3DSwapChain *iface, CONST REC
FIXME("Unable to render to a destination window %d\n", (int)hDestWindowOverride );
if(This == swapChainImpl){
/* FIXME: this will be fixed by moving to a context management system */
FIXME("Cannot change the target of the implicite swapchain\n");
FIXME("Cannot change the target of the implicit swapchain\n");
}else{
HDC hDc;
XVisualInfo template;
@ -178,7 +178,7 @@ HRESULT WINAPI IWineD3DSwapChainImpl_Present(IWineD3DSwapChain *iface, CONST REC
LEAVE_GL();
return D3DERR_NOTAVAILABLE;
}
/* Now we have problems? well not really we just need to know what the implicite context is */
/* Now we have problems? well not really we just need to know what the implicit context is */
/* now destroy the old context and create a new one (we should really copy the buffers over, and do the whole make current thing! */
/* destroy the active context?*/
TRACE("Creating new context for %p %p %p\n",This->display, This->visInfo, swapChainImpl->glCtx);
@ -189,7 +189,7 @@ HRESULT WINAPI IWineD3DSwapChainImpl_Present(IWineD3DSwapChain *iface, CONST REC
}
This->drawable = This->win;
This->render_ctx = This->glCtx;
/* SEtup some default states TODO: apply the stateblock to the new context */
/* Setup some default states TODO: apply the stateblock to the new context */
/** save current context and drawable **/
currentContext = glXGetCurrentContext();
currentDrawable = glXGetCurrentDrawable();
@ -327,7 +327,7 @@ HRESULT WINAPI IWineD3DSwapChainImpl_GetFrontBufferData(IWineD3DSwapChain *iface
TRACE("(%p) : iface(%p) pDestSurface(%p) \n", This, iface, pDestSurface);
ENTER_GL();
/* check to see if it's the backbuffer or the frontbuffer being requested (to make sureteh data is upto date) */
/* check to see if it's the backbuffer or the frontbuffer being requested (to make sure the data is up to date) */
format = D3DFmt2GLFmt(This->wineD3DDevice, surface->resource.format);
type = D3DFmt2GLType(This->wineD3DDevice, surface->resource.format);
glReadBuffer(GL_FRONT);

2
dlls/wined3d/vertexdeclaration.c
View File

@ -340,7 +340,7 @@ IWineD3DVertexDeclarationImpl *This = (IWineD3DVertexDeclarationImpl *)iface;
#if 0 /* TODO: This looks like overkill so I've removed it. */
{
D3DVERTEXELEMENT9* pIt = This->pDeclaration9;
TRACE("dumping of D3D9 Convertion:\n");
TRACE("dumping of D3D9 Conversion:\n");
while (0xFF != pIt->Stream) {
IWineD3DVertexDeclarationImpl_ParseToken9(pIt);
++pIt;

4
programs/winedbg/winedbg.man
View File

@ -32,7 +32,7 @@ mode. \fBwinedbg\fR will act as the front end for the user.
.IP \fB--auto\fR
This mode is used when \fBwinedbg\fR is setup in \fIAeDebug\fR
registry entry as the default debugger. \fBwinedbg\fR will then
display basic information about a crash. This is usefull for users
display basic information about a crash. This is useful for users
who don't want to debug a crash, but rather gather relevant
information about the crash to be sent to developers.
.IP \fB--gdb\fR
@ -45,7 +45,7 @@ Only the \fBgdb\fR proxy mode allows some options:
.PP
.IP \fI--no-start\fR \fBgdb\fR will not be automatically
started. Relevant information for starting \fBgdb\fR are printed on
screen. This is somehow usefull when not directly using \fBgdb\fR but
screen. This is somehow useful when not directly using \fBgdb\fR but
some graphical front-ends, like \fBddd\fR or \fBkgbd\fR.
.IP \fI--with-xterm\fR
This will run \fBgdb\fR in its own xterm instead of using the current