[greatlrd] 23043: 1. Remove guithreadinfo from the make file. for it not longer builds. 2. Adding a test apps for starting directdraw hal interface, that I have keep within few ros devs, and one wine devs, it also being using in 2-3 diffent company same code. I known which company that using it with my written premitions I give them on icq or email. But u need a document how to use kernel, d3d, mocomp interface, and some more how to access them. I only show how to start dx hal the interface and
Author: greatlrd Date: Thu Jul 13 23:00:05 2006 New Revision: 23043
URL: http://svn.reactos.org/svn/reactos?rev=23043&view=rev Log: 1. Remove guithreadinfo from the make file. for it not longer builds.
2. Adding a test apps for starting directdraw hal interface, that I have keep within few ros devs, and one wine devs, it also being using in 2-3 diffent company same code. I known which company that using it with my written premitions I give them on icq or email. But u need a document how to use kernel, d3d, mocomp interface,and some more how to access them. I only show how to start dx hal the interface and using so call IDrawDraw interface. in this apps.
Added: trunk/rosapps/tests/DxHalTest/ trunk/rosapps/tests/DxHalTest/DxHalTest.rbuild (with props) trunk/rosapps/tests/DxHalTest/main.c (with props) trunk/rosapps/tests/DxHalTest/main.h (with props) Modified: trunk/rosapps/tests/directory.xml
Added: trunk/rosapps/tests/DxHalTest/DxHalTest.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/rosapps/tests/DxHalTest/DxHalTest.r... ============================================================================== --- trunk/rosapps/tests/DxHalTest/DxHalTest.rbuild (added) +++ trunk/rosapps/tests/DxHalTest/DxHalTest.rbuild Thu Jul 13 23:00:05 2006 @@ -1,0 +1,8 @@ +<module name="dxhaltest" type="win32cui" installbase="bin" installname="dxhaltest.exe"> + <define name="_WIN32_IE">0x0501</define> + <define name="_WIN32_WINNT">0x0501</define> + <define name="__USE_W32API" /> + <library>kernel32</library> + <library>gdi32</library> + <file>main.c</file> +</module>
Propchange: trunk/rosapps/tests/DxHalTest/DxHalTest.rbuild ------------------------------------------------------------------------------ svn:eol-style = native
Added: trunk/rosapps/tests/DxHalTest/main.c URL: http://svn.reactos.org/svn/reactos/trunk/rosapps/tests/DxHalTest/main.c?rev=... ============================================================================== --- trunk/rosapps/tests/DxHalTest/main.c (added) +++ trunk/rosapps/tests/DxHalTest/main.c Thu Jul 13 23:00:05 2006 @@ -1,0 +1,665 @@ +#include <stdio.h> +#include "main.h" + + +// TODO: +// +// - free memory +// - Check if we ran out of memory (HeapAlloc == NULL) + HDC hdc; + DDRAWI_DIRECTDRAW_GBL mDDrawGlobal; + DDRAWI_DIRECTDRAW_LCL mDDrawLocal; + DDHALINFO mHALInfo; + + DDHAL_CALLBACKS mCallbacks; + DDHAL_DDEXEBUFCALLBACKS mD3dBufferCallbacks; + D3DHAL_CALLBACKS mD3dCallbacks; + D3DHAL_GLOBALDRIVERDATA mD3dDriverData; + + UINT mcModeInfos; + DDHALMODEINFO *mpModeInfos; + + UINT mcvmList; + VIDMEM *mpvmList; + + UINT mcFourCC; + DWORD *mpFourCC; + + UINT mcTextures; + DDSURFACEDESC *mpTextures; + + /* Surface */ + DDRAWI_DDRAWSURFACE_GBL mPrimaryGlobal; + DDRAWI_DDRAWSURFACE_MORE mPrimaryMore; + DDRAWI_DDRAWSURFACE_LCL mPrimaryLocal; + DDRAWI_DDRAWSURFACE_LCL *mpPrimaryLocals[1]; + DDRAWI_DDRAWCLIPPER_LCL mPrimaryClipperLocal; + DDRAWI_DDRAWCLIPPER_GBL mPrimaryClipperGlobal; + //DDRAWI_DDRAWCLIPPER_INT mPrimaryClipperInterface; + DDSURFACEDESC mddsdPrimary; + DDSURFACEDESC mddsdOverlay; + + DDRAWI_DDRAWSURFACE_GBL mOverlayGlobal; + DDRAWI_DDRAWSURFACE_LCL mOverlayLocal[6]; + DDRAWI_DDRAWSURFACE_LCL *mpOverlayLocals[6]; + DDRAWI_DDRAWSURFACE_MORE mOverlayMore[6]; + + DDHAL_BLTDATA mDdBlt; + + +typedef struct _DD_GETDRIVERINFODATA { + VOID *dhpdev; + DWORD dwSize; + DWORD dwFlags; + GUID guidInfo; + DWORD dwExpectedSize; + PVOID lpvData; + DWORD dwActualSize; + HRESULT ddRVal; + ULONG_PTR dwContext; +} DD_GETDRIVERINFODATA, *PDD_GETDRIVERINFODATA; + + +typedef struct _DD_MISCELLANEOUSCALLBACKS { + DWORD dwSize; + DWORD dwFlags; + PVOID GetAvailDriverMemory; +} DD_MISCELLANEOUSCALLBACKS; + + +int WINAPI WinMain (HINSTANCE hInst, HINSTANCE hPrevInst, + LPSTR lpCmdLine, int nCmdShow) +{ + /* get the functions we need */ +// DD_GETDRIVERINFODATA drv; + HMODULE lib = LoadLibrary("gdi32.dll"); + DdCreateDirectDrawObject = (BOOL (APIENTRY*)(LPDDRAWI_DIRECTDRAW_GBL, HDC))GetProcAddress(lib, "GdiEntry1"); + DdQueryDirectDrawObject = (BOOL (APIENTRY*)(LPDDRAWI_DIRECTDRAW_GBL, LPDDHALINFO,LPDDHAL_DDCALLBACKS,LPDDHAL_DDSURFACECALLBACKS,LPDDHAL_DDPALETTECALLBACKS,LPD3DHAL_CALLBACKS,LPD3DHAL_GLOBALDRIVERDATA,LPDDHAL_DDEXEBUFCALLBACKS,LPDDSURFACEDESC,LPDWORD,LPVIDMEM))GetProcAddress(lib, "GdiEntry2"); + DdAttachSurface = (BOOL (APIENTRY*)(LPDDRAWI_DDRAWSURFACE_LCL, LPDDRAWI_DDRAWSURFACE_LCL))GetProcAddress(lib, "GdiEntry11"); + DdResetVisrgn = (BOOL (APIENTRY*)(LPDDRAWI_DDRAWSURFACE_LCL, HWND))GetProcAddress(lib, "GdiEntry6"); + + /* HAL Startup process */ + DEVMODE devmode; + HBITMAP hbmp; + const UINT bmiSize = sizeof(BITMAPINFOHEADER) + 0x10; + UCHAR *pbmiData; + BITMAPINFO *pbmi; + + DWORD *pMasks; + //BOOL newmode = FALSE; + //DWORD Status; /* for create surface */ + UINT i; + UINT j; + + + printf("This apps showing how to start up directx draw/d3d interface and some other as well\n"); + printf("This code have been releae to some close applactons with my premtions, if any company\n"); + printf("want use part or whole code, you need contact the orginal author to ask for premtions\n"); + printf("This code are release under alot of diffent licen\n"); + printf("All GPL and LGPL project have right use and studing this code.\n"); + printf("This code maybe need more comment to known how stuff working and maybe looking bit mesy\n"); + printf("Bestreagds Magnus Olsen magnus@greatlord.com or greatlord@reactos.org\n"); + printf("Copyright 2006 by Magnus Olsen\n\n"); + printf("This demo showing how to start dx draw hal and create a primary surface,\n"); + printf("and a overlay sufrace and blt to the primary surface\n"); + + + /* + Get and Create mode info + */ + mcModeInfos = 1; + mpModeInfos = (DDHALMODEINFO*)HeapAlloc(GetProcessHeap(), + HEAP_ZERO_MEMORY, + mcModeInfos * sizeof(DDHALMODEINFO)); + + if (mpModeInfos == NULL) + { + printf("Fail to alloc mpModeInfos\n"); + return DD_FALSE; + } + + + EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &devmode); + + mpModeInfos[0].dwWidth = devmode.dmPelsWidth; + mpModeInfos[0].dwHeight = devmode.dmPelsHeight; + mpModeInfos[0].dwBPP = devmode.dmBitsPerPel; + mpModeInfos[0].lPitch = (devmode.dmPelsWidth*devmode.dmBitsPerPel)/8; + mpModeInfos[0].wRefreshRate = (WORD)devmode.dmDisplayFrequency; + + /* + Setup HDC and mDDrawGlobal right + */ + hdc = CreateDCW(L"DISPLAY",L"DISPLAY",NULL,NULL); + + if (hdc == NULL) + { + printf("Fail to create HDC\n"); + return DD_FALSE; + } + + /* + Dectect RGB bit mask + */ + hbmp = CreateCompatibleBitmap(hdc, 1, 1); + if (hbmp==NULL) + { + HeapFree(GetProcessHeap(), 0, mpModeInfos); + DeleteDC(hdc); + printf("Fail to Create Compatible Bitmap\n"); + return DD_FALSE; + } + + pbmiData = (UCHAR *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, bmiSize); + pbmi = (BITMAPINFO*)pbmiData; + + if (pbmiData==NULL) + { + HeapFree(GetProcessHeap(), 0, mpModeInfos); + free(mpModeInfos); + DeleteDC(hdc); + DeleteObject(hbmp); + printf("Fail to Alloc pbmiData\n"); + return DDERR_UNSUPPORTED; + } + + pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); + pbmi->bmiHeader.biBitCount = (WORD)devmode.dmBitsPerPel; + pbmi->bmiHeader.biCompression = BI_BITFIELDS; + pbmi->bmiHeader.biWidth = 1; + pbmi->bmiHeader.biHeight = 1; + + GetDIBits(hdc, hbmp, 0, 0, NULL, pbmi, 0); + DeleteObject(hbmp); + + pMasks = (DWORD*)(pbmiData + sizeof(BITMAPINFOHEADER)); + mpModeInfos[0].dwRBitMask = pMasks[0]; + mpModeInfos[0].dwGBitMask = pMasks[1]; + mpModeInfos[0].dwBBitMask = pMasks[2]; + mpModeInfos[0].dwAlphaBitMask = pMasks[3]; + + HeapFree(GetProcessHeap(), 0, pbmiData); + + /* + prepare start up the DX Draw HAL interface now + */ + + memset(&mDDrawGlobal, 0, sizeof(DDRAWI_DIRECTDRAW_GBL)); + memset(&mHALInfo, 0, sizeof(DDHALINFO)); + memset(&mCallbacks, 0, sizeof(DDHAL_CALLBACKS)); + + /* + Startup DX HAL step one of three + */ + if (!DdCreateDirectDrawObject(&mDDrawGlobal, hdc)) + { + HeapFree(GetProcessHeap(), 0, mpModeInfos); + DeleteDC(hdc); + DeleteObject(hbmp); + printf("Fail to Create Direct DrawObject\n"); + return DD_FALSE; + } + + mDDrawGlobal.dwRefCnt = 1; //addref / remove ref + + // Do not relase HDC it have been map in kernel mode + // DeleteDC(hdc); + + /* we need reanable it if screen res have changes, and some bad drv need be reanble very few + to contiune */ + /* + if (!DdReenableDirectDrawObject(&mDDrawGlobal, &newmode)) + { + HeapFree(GetProcessHeap(), 0, mpModeInfos); + DeleteDC(hdc); + DeleteObject(hbmp); + return DD_FALSE; + }*/ + + /* + Setup the DirectDraw Local + */ + + mDDrawLocal.lpDDCB = &mCallbacks; + mDDrawLocal.lpGbl = &mDDrawGlobal; + mDDrawLocal.dwProcessId = GetCurrentProcessId(); + + mDDrawGlobal.lpDDCBtmp = &mCallbacks; + mDDrawGlobal.lpExclusiveOwner = &mDDrawLocal; + //mDDrawLocal.dwLocalFlags = DDRAWILCL_DIRECTDRAW7; + + + /* + Startup DX HAL step two of three + */ + + if (!DdQueryDirectDrawObject(&mDDrawGlobal, + &mHALInfo, + &mCallbacks.HALDD, + &mCallbacks.HALDDSurface, + &mCallbacks.HALDDPalette, + &mD3dCallbacks, + &mD3dDriverData, + &mD3dBufferCallbacks, + NULL, + NULL, + NULL)) + { + HeapFree(GetProcessHeap(), 0, mpModeInfos); + DeleteDC(hdc); + DeleteObject(hbmp); + // FIXME Close DX fristcall and second call + return DD_FALSE; + } + + mcvmList = mHALInfo.vmiData.dwNumHeaps; + mpvmList = (VIDMEM*) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(VIDMEM) * mcvmList); + if (mpvmList == NULL) + { + HeapFree(GetProcessHeap(), 0, mpModeInfos); + DeleteDC(hdc); + DeleteObject(hbmp); + // FIXME Close DX fristcall and second call + printf("Fail to QueryDirect Draw Object frist pass\n"); + return DD_FALSE; + } + + mcFourCC = mHALInfo.ddCaps.dwNumFourCCCodes; + mpFourCC = (DWORD *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DWORD) * mcFourCC); + if (mpFourCC == NULL) + { + HeapFree(GetProcessHeap(), 0, mpvmList); + HeapFree(GetProcessHeap(), 0, mpModeInfos); + DeleteDC(hdc); + DeleteObject(hbmp); + // FIXME Close DX fristcall and second call + return DD_FALSE; + } + + mcTextures = mD3dDriverData.dwNumTextureFormats; + mpTextures = (DDSURFACEDESC*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DDSURFACEDESC) * mcTextures); + if (mpTextures == NULL) + { + HeapFree(GetProcessHeap(), 0, mpFourCC); + HeapFree(GetProcessHeap(), 0, mpvmList); + HeapFree(GetProcessHeap(), 0, mpModeInfos); + DeleteDC(hdc); + DeleteObject(hbmp); + // FIXME Close DX fristcall and second call + printf("Fail QueryDirect Draw Object to Alloc mpTextures \n"); + return DD_FALSE; + } + + mHALInfo.vmiData.pvmList = mpvmList; + mHALInfo.lpdwFourCC = mpFourCC; + mD3dDriverData.lpTextureFormats = mpTextures; + + if (!DdQueryDirectDrawObject( + &mDDrawGlobal, + &mHALInfo, + &mCallbacks.HALDD, + &mCallbacks.HALDDSurface, + &mCallbacks.HALDDPalette, + &mD3dCallbacks, + &mD3dDriverData, + &mCallbacks.HALDDExeBuf, + mpTextures, + mpFourCC, + mpvmList)) + + { + HeapFree(GetProcessHeap(), 0, mpTextures); + HeapFree(GetProcessHeap(), 0, mpFourCC); + HeapFree(GetProcessHeap(), 0, mpvmList); + HeapFree(GetProcessHeap(), 0, mpModeInfos); + DeleteDC(hdc); + DeleteObject(hbmp); + printf("Fail to QueryDirect Draw Object second pass\n"); + return DD_FALSE; + } + + /* + Copy over from HalInfo to DirectDrawGlobal + */ + + // this is wrong, cDriverName need be in ASC code not UNICODE + //memcpy(mDDrawGlobal.cDriverName, mDisplayAdapter, sizeof(wchar)*MAX_DRIVER_NAME); + + memcpy(&mDDrawGlobal.vmiData, &mHALInfo.vmiData,sizeof(VIDMEMINFO)); + memcpy(&mDDrawGlobal.ddCaps, &mHALInfo.ddCaps,sizeof(DDCORECAPS)); + + mHALInfo.dwNumModes = mcModeInfos; + mHALInfo.lpModeInfo = mpModeInfos; + mHALInfo.dwMonitorFrequency = mpModeInfos[0].wRefreshRate; + + mDDrawGlobal.dwMonitorFrequency = mHALInfo.dwMonitorFrequency; + mDDrawGlobal.dwModeIndex = mHALInfo.dwModeIndex; + mDDrawGlobal.dwNumModes = mHALInfo.dwNumModes; + mDDrawGlobal.lpModeInfo = mHALInfo.lpModeInfo; + mDDrawGlobal.hInstance = mHALInfo.hInstance; + + mDDrawGlobal.lp16DD = &mDDrawGlobal; + + + + /* Hal insate is down now */ + + /* cleare surface code now*/ + + // memset(&mGlobal, 0, sizeof(DDRAWI_DDRAWSURFACE_GBL)); + // memset(&mMore, 0, sizeof(DDRAWI_DDRAWSURFACE_MORE)); + + /* mLocal.lpSurfMore = &mMore; + memset(mMore, 0, sizeof(DDRAWI_DDRAWSURFACE_MORE)); + mMore.dwSize = sizeof(DDRAWI_DDRAWSURFACE_MORE);*/ + + mPrimaryLocal.lpSurfMore = &mPrimaryMore; + + /* cleare surface ends now */ + + /* create primare surface now */ + + memset(&mddsdPrimary, 0, sizeof(DDSURFACEDESC)); + mddsdPrimary.dwSize = sizeof(DDSURFACEDESC); + mddsdPrimary.dwFlags = DDSD_CAPS; + mddsdPrimary.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_VIDEOMEMORY | DDSCAPS_VISIBLE; + + DDHAL_CANCREATESURFACEDATA mDdCanCreateSurface; + mDdCanCreateSurface.lpDD = &mDDrawGlobal; + mDdCanCreateSurface.CanCreateSurface = mCallbacks.HALDD.CanCreateSurface; + mDdCanCreateSurface.bIsDifferentPixelFormat = FALSE; //isDifferentPixelFormat; + mDdCanCreateSurface.lpDDSurfaceDesc = &mddsdPrimary; // pDDSD; + + if (mHALInfo.lpDDCallbacks->CanCreateSurface(&mDdCanCreateSurface)== DDHAL_DRIVER_NOTHANDLED) + { + printf("Fail to mDdCanCreateSurface DDHAL_DRIVER_NOTHANDLED\n"); + return DDERR_NOTINITIALIZED; + } + + if (mDdCanCreateSurface.ddRVal != DD_OK) + { + printf("Fail to mDdCanCreateSurface mDdCanCreateSurface.ddRVal = %d:%s\n",(int)mDdCanCreateSurface.ddRVal,DDErrorString(mDdCanCreateSurface.ddRVal)); + return DDERR_NOTINITIALIZED; + } + + memset(&mPrimaryGlobal, 0, sizeof(DDRAWI_DDRAWSURFACE_GBL)); + mPrimaryGlobal.dwGlobalFlags = DDRAWISURFGBL_ISGDISURFACE; + mPrimaryGlobal.lpDD = &mDDrawGlobal; + mPrimaryGlobal.lpDDHandle = &mDDrawGlobal; + mPrimaryGlobal.wWidth = (WORD)mpModeInfos[0].dwWidth; + mPrimaryGlobal.wHeight = (WORD)mpModeInfos[0].dwHeight; + mPrimaryGlobal.lPitch = mpModeInfos[0].lPitch; + + memset(&mPrimaryMore, 0, sizeof(DDRAWI_DDRAWSURFACE_MORE)); + mPrimaryMore.dwSize = sizeof(DDRAWI_DDRAWSURFACE_MORE); + + + //mPrimaryMore. = mpr + + memset(&mPrimaryLocal, 0, sizeof(DDRAWI_DDRAWSURFACE_LCL)); + mPrimaryLocal.lpGbl = &mPrimaryGlobal; + mPrimaryLocal.lpSurfMore = &mPrimaryMore; + mPrimaryLocal.dwProcessId = GetCurrentProcessId(); + mPrimaryLocal.dwFlags = DDRAWISURF_PARTOFPRIMARYCHAIN|DDRAWISURF_HASOVERLAYDATA; + mPrimaryLocal.ddsCaps.dwCaps = mddsdPrimary.ddsCaps.dwCaps; + + mpPrimaryLocals[0] = &mPrimaryLocal; + + DDHAL_CREATESURFACEDATA mDdCreateSurface; + mDdCreateSurface.lpDD = &mDDrawGlobal; + mDdCreateSurface.CreateSurface = mCallbacks.HALDD.CreateSurface; + mDdCreateSurface.lpDDSurfaceDesc = &mddsdPrimary;//pDDSD; + mDdCreateSurface.lplpSList = mpPrimaryLocals; //cSurfaces; + mDdCreateSurface.dwSCnt = 1 ; //ppSurfaces; + + if (mHALInfo.lpDDCallbacks->CreateSurface(&mDdCreateSurface) == DDHAL_DRIVER_NOTHANDLED) + { + printf("Fail to mDdCreateSurface DDHAL_DRIVER_NOTHANDLED \n"); + return DDERR_NOTINITIALIZED; + } + + + if (mDdCreateSurface.ddRVal != DD_OK) + { + printf("Fail to mDdCanCreateSurface mDdCreateSurface.ddRVal = %d:%s\n",(int)mDdCreateSurface.ddRVal,DDErrorString(mDdCreateSurface.ddRVal)); + return mDdCreateSurface.ddRVal; + } + + // -- Setup Clipper --------------------------------------------------------- + memset(&mPrimaryClipperGlobal, 0, sizeof(DDRAWI_DDRAWCLIPPER_GBL)); + mPrimaryClipperGlobal.dwFlags = DDRAWICLIP_ISINITIALIZED; + mPrimaryClipperGlobal.dwProcessId = GetCurrentProcessId(); + //mPrimaryClipperGlobal.hWnd = (ULONG_PTR)hwnd; + mPrimaryClipperGlobal.hWnd = (ULONG_PTR)GetDesktopWindow(); + mPrimaryClipperGlobal.lpDD = &mDDrawGlobal; + mPrimaryClipperGlobal.lpStaticClipList = NULL; + + memset(&mPrimaryClipperLocal, 0, sizeof(DDRAWI_DDRAWCLIPPER_LCL)); + mPrimaryClipperLocal.lpGbl = &mPrimaryClipperGlobal; + + //memset(&mPrimaryClipperInterface, 0, sizeof(DDRAWI_DDRAWCLIPPER_INT)); + //mPrimaryClipperInterface.lpLcl = &mPrimaryClipperLocal; + //mPrimaryClipperInterface.dwIntRefCnt = 1; + //mPrimaryClipperInterface.lpLink = null; + //mPrimaryClipperInterface.lpVtbl = null; + + mPrimaryLocal.lpDDClipper = &mPrimaryClipperLocal; + //mPrimaryMore.lpDDIClipper = &mPrimaryClipperInterface; + + mDdBlt.lpDDDestSurface = mpPrimaryLocals[0]; + + + /* create primare surface is down now */ + + /* create overlay surface now */ + + memset(&mddsdOverlay, 0, sizeof(DDSURFACEDESC)); + mddsdOverlay.dwSize = sizeof(DDSURFACEDESC); + mddsdOverlay.dwFlags = DDSD_CAPS | DDSD_PIXELFORMAT | DDSD_BACKBUFFERCOUNT | DDSD_WIDTH | DDSD_HEIGHT; + + mddsdOverlay.ddsCaps.dwCaps = DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM | DDSCAPS_COMPLEX | DDSCAPS_FLIP; + + mddsdOverlay.dwWidth = 100; //pels; + mddsdOverlay.dwHeight = 100; // lines; + mddsdOverlay.dwBackBufferCount = 1; //cBuffers; + + mddsdOverlay.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT); + mddsdOverlay.ddpfPixelFormat.dwFlags = DDPF_RGB; + mddsdOverlay.ddpfPixelFormat.dwRGBBitCount = 32; + + + //DDHAL_CANCREATESURFACEDATA mDdCanCreateSurface; + mDdCanCreateSurface.lpDD = &mDDrawGlobal; + mDdCanCreateSurface.CanCreateSurface = mCallbacks.HALDD.CanCreateSurface; + mDdCanCreateSurface.bIsDifferentPixelFormat = TRUE; //isDifferentPixelFormat; + mDdCanCreateSurface.lpDDSurfaceDesc = &mddsdOverlay; // pDDSD; + + + if (mHALInfo.lpDDCallbacks->CanCreateSurface(&mDdCanCreateSurface)== DDHAL_DRIVER_NOTHANDLED) + { + // derr(L"DirectDrawImpl[%08x]::__createPrimary Cannot create primary [%08x]", this, rv); + + printf("Fail to mDdCanCreateSurface DDHAL_DRIVER_NOTHANDLED \n"); + return DDERR_NOTINITIALIZED; + } + + if (mDdCanCreateSurface.ddRVal != DD_OK) + { + printf("Fail to mDdCanCreateSurface mDdCanCreateSurface.ddRVal = %d:%s\n",(int)mDdCanCreateSurface.ddRVal,DDErrorString(mDdCanCreateSurface.ddRVal)); + return DDERR_NOTINITIALIZED; + } + + + memset(&mOverlayGlobal, 0, sizeof(DDRAWI_DDRAWSURFACE_GBL)); + mOverlayGlobal.dwGlobalFlags = 0; + mOverlayGlobal.lpDD = &mDDrawGlobal; + mOverlayGlobal.lpDDHandle = &mDDrawGlobal; + mOverlayGlobal.wWidth = (WORD)mddsdOverlay.dwWidth; + mOverlayGlobal.wHeight = (WORD)mddsdOverlay.dwHeight; + mOverlayGlobal.lPitch = -1; + mOverlayGlobal.ddpfSurface = mddsdOverlay.ddpfPixelFormat; + + // setup front- and backbuffer surfaces + UINT cSurfaces = mddsdOverlay.dwBackBufferCount + 1; + for ( i = 0; i < cSurfaces; i++) + { + memset(&mOverlayMore[i], 0, sizeof(DDRAWI_DDRAWSURFACE_MORE)); + mOverlayMore[i].dwSize = sizeof(DDRAWI_DDRAWSURFACE_MORE); + + memset(&mOverlayLocal[i], 0, sizeof(DDRAWI_DDRAWSURFACE_LCL)); + mOverlayLocal[i].lpGbl = &mOverlayGlobal; + mOverlayLocal[i].lpSurfMore = &mOverlayMore[i]; + mOverlayLocal[i].dwProcessId = GetCurrentProcessId(); + mOverlayLocal[i].dwFlags = (i == 0) ? + (DDRAWISURF_IMPLICITROOT|DDRAWISURF_FRONTBUFFER): + (DDRAWISURF_IMPLICITCREATE|DDRAWISURF_BACKBUFFER); + + mOverlayLocal[i].dwFlags |= + DDRAWISURF_ATTACHED|DDRAWISURF_ATTACHED_FROM| + DDRAWISURF_HASPIXELFORMAT| + DDRAWISURF_HASOVERLAYDATA; + + mOverlayLocal[i].ddsCaps.dwCaps = mddsdOverlay.ddsCaps.dwCaps; + mpOverlayLocals[i] = &mOverlayLocal[i]; + } + + for ( i = 0; i < cSurfaces; i++) + { + j = (i + 1) % cSurfaces; + + + /*if (!mHALInfo.lpDDSurfaceCallbacks->AddAttachedSurface(mpOverlayLocals[i], mpOverlayLocals[j])) + { + // derr(L"DirectDrawImpl[%08x]::__setupDevice DdAttachSurface(%d, %d) failed", this, i, j); + return DD_FALSE; + }*/ + + if (!DdAttachSurface(mpOverlayLocals[i], mpOverlayLocals[j])) + { + // derr(L"DirectDrawImpl[%08x]::__setupDevice DdAttachSurface(%d, %d) failed", this, i, j); + printf("Fail to DdAttachSurface (%d:%d)\n", i, j); + return DD_FALSE; + } + + } + + + // DDHAL_CREATESURFACEDATA mDdCreateSurface; + mDdCreateSurface.lpDD = &mDDrawGlobal; + mDdCreateSurface.CreateSurface = mCallbacks.HALDD.CreateSurface; + mDdCreateSurface.lpDDSurfaceDesc = &mddsdOverlay;//pDDSD; + mDdCreateSurface.lplpSList = mpOverlayLocals; //cSurfaces; + mDdCreateSurface.dwSCnt = 1 ; //ppSurfaces; + + if (mHALInfo.lpDDCallbacks->CreateSurface(&mDdCreateSurface) == DDHAL_DRIVER_NOTHANDLED) + { + printf("Fail to mDdCreateSurface = DDHAL_DRIVER_HANDLED\n"); + return DDERR_NOTINITIALIZED; + } + + + if (mDdCreateSurface.ddRVal != DD_OK) + { + printf("Fail to mDdCreateSurface mDdCreateSurface.ddRVal = %d:%s\n",(int)mDdCreateSurface.ddRVal,DDErrorString(mDdCreateSurface.ddRVal)); + return mDdCreateSurface.ddRVal; + } + + + DDHAL_UPDATEOVERLAYDATA mDdUpdateOverlay; + mDdUpdateOverlay.lpDD = &mDDrawGlobal; + mDdUpdateOverlay.UpdateOverlay = mCallbacks.HALDDSurface.UpdateOverlay; + mDdUpdateOverlay.lpDDDestSurface = mpPrimaryLocals[0]; + mDdUpdateOverlay.lpDDSrcSurface = mpOverlayLocals[0];//pDDSurface; + mDdUpdateOverlay.dwFlags = DDOVER_SHOW; + + /* if (flags & DDOVER_DDFX) + mDdUpdateOverlay.overlayFX = *pFx; + copyRect(&mDdUpdateOverlay.rDest, pdst); + copyRect(&mDdUpdateOverlay.rSrc, psrc); +*/ + + mDdUpdateOverlay.rDest.top = 0; + mDdUpdateOverlay.rDest.left = 0; + mDdUpdateOverlay.rDest.right = 50; + mDdUpdateOverlay.rDest.bottom = 50; + + mDdUpdateOverlay.rSrc.top = 0; + mDdUpdateOverlay.rSrc.left = 0; + mDdUpdateOverlay.rSrc.right = 50; + mDdUpdateOverlay.rSrc.bottom = 50; + + + + + if ( mDdUpdateOverlay.UpdateOverlay(&mDdUpdateOverlay) == DDHAL_DRIVER_NOTHANDLED) + { + printf("Fail to mDdBlt = DDHAL_DRIVER_HANDLED\n"); + return DDERR_NOTINITIALIZED; + } + + + if (mDdUpdateOverlay.ddRVal != DD_OK) + { + printf("Fail to mDdUpdateOverlay mDdUpdateOverlay.ddRVal = %d:%s\n",(int)mDdUpdateOverlay.ddRVal,DDErrorString(mDdUpdateOverlay.ddRVal)); + return mDdUpdateOverlay.ddRVal; + } + + /* blt */ + + + DDRAWI_DDRAWSURFACE_LCL *pDDSurface = mpPrimaryLocals[0]; + + if (!DdResetVisrgn(pDDSurface, NULL)) + { + // derr(L"DirectDrawImpl[%08x]::_clear DdResetVisrgn failed", this); + } + + + memset(&mDdBlt, 0, sizeof(DDHAL_BLTDATA)); + memset(&mDdBlt.bltFX, 0, sizeof(DDBLTFX)); + mDdBlt.bltFX.dwSize = sizeof(DDBLTFX); + + mDdBlt.lpDD = &mDDrawGlobal; + mDdBlt.Blt = mCallbacks.HALDDSurface.Blt; + mDdBlt.lpDDDestSurface = mpPrimaryLocals[0]; + + mpPrimaryLocals[0]->hDC = (ULONG_PTR)GetDC(GetDesktopWindow()); + mDdBlt.rDest.top = 50; + mDdBlt.rDest.bottom = 100; + mDdBlt.rDest.left = 0; + mDdBlt.rDest.right = 100; + mDdBlt.lpDDSrcSurface = NULL; + mDdBlt.IsClipped = FALSE; + mDdBlt.bltFX.dwFillColor = 0xFFFF00; + mDdBlt.dwFlags = DDBLT_COLORFILL | DDBLT_WAIT; + // mDdBlt.IsClipped = TRUE; + + if (mDdBlt.Blt(&mDdBlt) != DDHAL_DRIVER_HANDLED) + { + printf("Fail to mDdBlt = DDHAL_DRIVER_HANDLED\n"); + return DDHAL_DRIVER_HANDLED; + } + + + + if (mDdBlt.ddRVal!=DD_OK) + { + printf("Fail to mDdBlt mDdBlt.ddRVal = %d:%s\n",(int)mDdBlt.ddRVal,DDErrorString(mDdBlt.ddRVal)); + return mDdBlt.ddRVal; + } + + mDdUpdateOverlay.rDest.right = 100; + if ( mDdUpdateOverlay.UpdateOverlay(&mDdUpdateOverlay) == DDHAL_DRIVER_NOTHANDLED) + { + printf("Fail to mDdUpdateOverlay = DDERR_NOTINITIALIZED\n"); + return DDERR_NOTINITIALIZED; + } + + while(TRUE); + + return DD_OK; + + +} + +
Propchange: trunk/rosapps/tests/DxHalTest/main.c ------------------------------------------------------------------------------ svn:eol-style = native
Added: trunk/rosapps/tests/DxHalTest/main.h URL: http://svn.reactos.org/svn/reactos/trunk/rosapps/tests/DxHalTest/main.h?rev=... ============================================================================== --- trunk/rosapps/tests/DxHalTest/main.h (added) +++ trunk/rosapps/tests/DxHalTest/main.h Thu Jul 13 23:00:05 2006 @@ -1,0 +1,267 @@ +#include <windows.h> +#include <ddrawi.h> +#include <d3dhal.h> + + +int StartupHAL (); +extern HDC hdc; +extern DDRAWI_DIRECTDRAW_GBL mDDrawGlobal; + extern DDRAWI_DIRECTDRAW_LCL mDDrawLocal; + extern DDHALINFO mHALInfo; + + extern DDHAL_CALLBACKS mCallbacks; + extern DDHAL_DDEXEBUFCALLBACKS mD3dBufferCallbacks; + extern D3DHAL_CALLBACKS mD3dCallbacks; + extern D3DHAL_GLOBALDRIVERDATA mD3dDriverData; + + extern UINT mcModeInfos; + extern DDHALMODEINFO *mpModeInfos; + + extern UINT mcvmList; + extern VIDMEM *mpvmList; + + extern UINT mcFourCC; + extern DWORD *mpFourCC; + + extern UINT mcTextures; + extern DDSURFACEDESC *mpTextures; + + + +BOOL (APIENTRY *DdCreateDirectDrawObject) ( + LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal, + HDC hdc +); + +BOOL (APIENTRY *DdQueryDirectDrawObject) ( + LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal, + LPDDHALINFO pHalInfo, + LPDDHAL_DDCALLBACKS pDDCallbacks, + LPDDHAL_DDSURFACECALLBACKS pDDSurfaceCallbacks, + LPDDHAL_DDPALETTECALLBACKS pDDPaletteCallbacks, + LPD3DHAL_CALLBACKS pD3dCallbacks, + LPD3DHAL_GLOBALDRIVERDATA pD3dDriverData, + LPDDHAL_DDEXEBUFCALLBACKS pD3dBufferCallbacks, + LPDDSURFACEDESC pD3dTextureFormats, + LPDWORD pdwFourCC, + LPVIDMEM pvmList +); + +BOOL +APIENTRY +DdDeleteDirectDrawObject( + LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal +); + +BOOL +APIENTRY +DdCreateSurfaceObject( + LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal, + BOOL bPrimarySurface +); + +BOOL +APIENTRY +DdDeleteSurfaceObject( + LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal +); + +//BOOL +//APIENTRY +//DdResetVisrgn( +// LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal, +// HWND hWnd +//); +BOOL (APIENTRY *DdResetVisrgn) ( + LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal, + HWND hWnd +); + +HDC +APIENTRY +DdGetDC( + LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal, + LPPALETTEENTRY pColorTable +); + +BOOL +APIENTRY +DdReleaseDC( + LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal +); + +HBITMAP +APIENTRY +DdCreateDIBSection( + HDC hdc, + CONST BITMAPINFO *pbmi, + UINT iUsage, + VOID **ppvBits, + HANDLE hSectionApp, + DWORD dwOffset +); + +BOOL +APIENTRY +DdReenableDirectDrawObject( + LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal, + BOOL *pbNewMode +); + +//BOOL +//APIENTRY +//DdAttachSurface( +// LPDDRAWI_DDRAWSURFACE_LCL pSurfaceFrom, +// LPDDRAWI_DDRAWSURFACE_LCL pSurfaceTo +//); + +BOOL (APIENTRY *DdAttachSurface) ( + LPDDRAWI_DDRAWSURFACE_LCL pSurfaceFrom, + LPDDRAWI_DDRAWSURFACE_LCL pSurfaceTo +); + +VOID +APIENTRY +DdUnattachSurface( + LPDDRAWI_DDRAWSURFACE_LCL pSurface, + LPDDRAWI_DDRAWSURFACE_LCL pSurfaceAttached +); + +ULONG +APIENTRY +DdQueryDisplaySettingsUniqueness(VOID); + +HANDLE +APIENTRY +DdGetDxHandle( + LPDDRAWI_DIRECTDRAW_LCL pDDraw, + LPDDRAWI_DDRAWSURFACE_LCL pSurface, + BOOL bRelease +); + +BOOL +APIENTRY +DdSetGammaRamp( + LPDDRAWI_DIRECTDRAW_LCL pDDraw, + HDC hdc, + LPVOID lpGammaRamp +); + +DWORD +APIENTRY +DdSwapTextureHandles( + LPDDRAWI_DIRECTDRAW_LCL pDDraw, + LPDDRAWI_DDRAWSURFACE_LCL pDDSLcl1, + LPDDRAWI_DDRAWSURFACE_LCL pDDSLcl2 +); + +char* DDErrorString (HRESULT hr) +{ + switch (hr) + { + case DD_OK: return "DD_OK"; + case DDERR_ALREADYINITIALIZED: return "DDERR_ALREADYINITIALIZED"; + case DDERR_CANNOTATTACHSURFACE: return "DDERR_CANNOTATTACHSURFACE"; + case DDERR_CANNOTDETACHSURFACE: return "DDERR_CANNOTDETACHSURFACE"; + case DDERR_CURRENTLYNOTAVAIL: return "DDERR_CURRENTLYNOTAVAIL"; + case DDERR_EXCEPTION: return "DDERR_EXCEPTION"; + case DDERR_GENERIC: return "DDERR_GENERIC"; + case DDERR_HEIGHTALIGN: return "DDERR_HEIGHTALIGN"; + case DDERR_INCOMPATIBLEPRIMARY: return "DDERR_INCOMPATIBLEPRIMARY"; + case DDERR_INVALIDCAPS: return "DDERR_INVALIDCAPS"; + case DDERR_INVALIDCLIPLIST: return "DDERR_INVALIDCLIPLIST"; + case DDERR_INVALIDMODE: return "DDERR_INVALIDMODE"; + case DDERR_INVALIDOBJECT: return "DDERR_INVALIDOBJECT"; + case DDERR_INVALIDPARAMS: return "DDERR_INVALIDPARAMS"; + case DDERR_INVALIDPIXELFORMAT: return "DDERR_INVALIDPIXELFORMAT"; + case DDERR_INVALIDRECT: return "DDERR_INVALIDRECT"; + case DDERR_LOCKEDSURFACES: return "DDERR_LOCKEDSURFACES"; + case DDERR_NO3D: return "DDERR_NO3D"; + case DDERR_NOALPHAHW: return "DDERR_NOALPHAHW"; + case DDERR_NOCLIPLIST: return "DDERR_NOCLIPLIST"; + case DDERR_NOCOLORCONVHW: return "DDERR_NOCOLORCONVHW"; + case DDERR_NOCOOPERATIVELEVELSET: return "DDERR_NOCOOPERATIVELEVELSET"; + case DDERR_NOCOLORKEY: return "DDERR_NOCOLORKEY"; + case DDERR_NOCOLORKEYHW: return "DDERR_NOCOLORKEYHW"; + case DDERR_NODIRECTDRAWSUPPORT: return "DDERR_NODIRECTDRAWSUPPORT"; + case DDERR_NOEXCLUSIVEMODE: return "DDERR_NOEXCLUSIVEMODE"; + case DDERR_NOFLIPHW: return "DDERR_NOFLIPHW"; + case DDERR_NOGDI: return "DDERR_NOGDI"; + case DDERR_NOMIRRORHW: return "DDERR_NOMIRRORHW"; + case DDERR_NOTFOUND: return "DDERR_NOTFOUND"; + case DDERR_NOOVERLAYHW: return "DDERR_NOOVERLAYHW"; + case DDERR_NORASTEROPHW: return "DDERR_NORASTEROPHW"; + case DDERR_NOROTATIONHW: return "DDERR_NOROTATIONHW"; + case DDERR_NOSTRETCHHW: return "DDERR_NOSTRETCHHW"; + case DDERR_NOT4BITCOLOR: return "DDERR_NOT4BITCOLOR"; + case DDERR_NOT4BITCOLORINDEX: return "DDERR_NOT4BITCOLORINDEX"; + case DDERR_NOT8BITCOLOR: return "DDERR_NOT8BITCOLOR"; + case DDERR_NOTEXTUREHW: return "DDERR_NOTEXTUREHW"; + case DDERR_NOVSYNCHW: return "DDERR_NOVSYNCHW"; + case DDERR_NOZBUFFERHW: return "DDERR_NOZBUFFERHW"; + case DDERR_NOZOVERLAYHW: return "DDERR_NOZOVERLAYHW"; + case DDERR_OUTOFCAPS: return "DDERR_OUTOFCAPS"; + case DDERR_OUTOFMEMORY: return "DDERR_OUTOFMEMORY"; + case DDERR_OUTOFVIDEOMEMORY: return "DDERR_OUTOFVIDEOMEMORY"; + case DDERR_OVERLAYCANTCLIP: return "DDERR_OVERLAYCANTCLIP"; + case DDERR_OVERLAYCOLORKEYONLYONEACTIVE: return "DDERR_OVERLAYCOLORKEYONLYONEACTIVE"; + case DDERR_PALETTEBUSY: return "DDERR_PALETTEBUSY"; + case DDERR_COLORKEYNOTSET: return "DDERR_COLORKEYNOTSET"; + case DDERR_SURFACEALREADYATTACHED: return "DDERR_SURFACEALREADYATTACHED"; + case DDERR_SURFACEALREADYDEPENDENT: return "DDERR_SURFACEALREADYDEPENDENT"; + case DDERR_SURFACEBUSY: return "DDERR_SURFACEBUSY"; + case DDERR_CANTLOCKSURFACE: return "DDERR_CANTLOCKSURFACE"; + case DDERR_SURFACEISOBSCURED: return "DDERR_SURFACEISOBSCURED"; + case DDERR_SURFACELOST: return "DDERR_SURFACELOST"; + case DDERR_SURFACENOTATTACHED: return "DDERR_SURFACENOTATTACHED"; + case DDERR_TOOBIGHEIGHT: return "DDERR_TOOBIGHEIGHT"; + case DDERR_TOOBIGSIZE: return "DDERR_TOOBIGSIZE"; + case DDERR_TOOBIGWIDTH: return "DDERR_TOOBIGWIDTH"; + case DDERR_UNSUPPORTED: return "DDERR_UNSUPPORTED"; + case DDERR_UNSUPPORTEDFORMAT: return "DDERR_UNSUPPORTEDFORMAT"; + case DDERR_UNSUPPORTEDMASK: return "DDERR_UNSUPPORTEDMASK"; + case DDERR_VERTICALBLANKINPROGRESS: return "DDERR_VERTICALBLANKINPROGRESS"; + case DDERR_WASSTILLDRAWING: return "DDERR_WASSTILLDRAWING"; + case DDERR_XALIGN: return "DDERR_XALIGN"; + case DDERR_INVALIDDIRECTDRAWGUID: return "DDERR_INVALIDDIRECTDRAWGUID"; + case DDERR_DIRECTDRAWALREADYCREATED: return "DDERR_DIRECTDRAWALREADYCREATED"; + case DDERR_NODIRECTDRAWHW: return "DDERR_NODIRECTDRAWHW"; + case DDERR_PRIMARYSURFACEALREADYEXISTS: return "DDERR_PRIMARYSURFACEALREADYEXISTS"; + case DDERR_NOEMULATION: return "DDERR_NOEMULATION"; + case DDERR_REGIONTOOSMALL: return "DDERR_REGIONTOOSMALL"; + case DDERR_CLIPPERISUSINGHWND: return "DDERR_CLIPPERISUSINGHWND"; + case DDERR_NOCLIPPERATTACHED: return "DDERR_NOCLIPPERATTACHED"; + case DDERR_NOHWND: return "DDERR_NOHWND"; + case DDERR_HWNDSUBCLASSED: return "DDERR_HWNDSUBCLASSED"; + case DDERR_HWNDALREADYSET: return "DDERR_HWNDALREADYSET"; + case DDERR_NOPALETTEATTACHED: return "DDERR_NOPALETTEATTACHED"; + case DDERR_NOPALETTEHW: return "DDERR_NOPALETTEHW"; + case DDERR_BLTFASTCANTCLIP: return "DDERR_BLTFASTCANTCLIP"; + case DDERR_NOBLTHW: return "DDERR_NOBLTHW"; + case DDERR_NODDROPSHW: return "DDERR_NODDROPSHW"; + case DDERR_OVERLAYNOTVISIBLE: return "DDERR_OVERLAYNOTVISIBLE"; + case DDERR_NOOVERLAYDEST: return "DDERR_NOOVERLAYDEST"; + case DDERR_INVALIDPOSITION: return "DDERR_INVALIDPOSITION"; + case DDERR_NOTAOVERLAYSURFACE: return "DDERR_NOTAOVERLAYSURFACE"; + case DDERR_EXCLUSIVEMODEALREADYSET: return "DDERR_EXCLUSIVEMODEALREADYSET"; + case DDERR_NOTFLIPPABLE: return "DDERR_NOTFLIPPABLE"; + case DDERR_CANTDUPLICATE: return "DDERR_CANTDUPLICATE"; + case DDERR_NOTLOCKED: return "DDERR_NOTLOCKED"; + case DDERR_CANTCREATEDC: return "DDERR_CANTCREATEDC"; + case DDERR_NODC: return "DDERR_NODC"; + case DDERR_WRONGMODE: return "DDERR_WRONGMODE"; + case DDERR_IMPLICITLYCREATED: return "DDERR_IMPLICITLYCREATED"; + case DDERR_NOTPALETTIZED: return "DDERR_NOTPALETTIZED"; + case DDERR_UNSUPPORTEDMODE: return "DDERR_UNSUPPORTEDMODE"; + case DDERR_NOMIPMAPHW: return "DDERR_NOMIPMAPHW"; + case DDERR_INVALIDSURFACETYPE: return "DDERR_INVALIDSURFACETYPE"; + case DDERR_DCALREADYCREATED: return "DDERR_DCALREADYCREATED"; + case DDERR_CANTPAGELOCK: return "DDERR_CANTPAGELOCK"; + case DDERR_CANTPAGEUNLOCK: return "DDERR_CANTPAGEUNLOCK"; + case DDERR_NOTPAGELOCKED: return "DDERR_NOTPAGELOCKED"; + case DDERR_NOTINITIALIZED: return "DDERR_NOTINITIALIZED"; + } + + return "Unknown Error "; +} +
Propchange: trunk/rosapps/tests/DxHalTest/main.h ------------------------------------------------------------------------------ svn:eol-style = native
Modified: trunk/rosapps/tests/directory.xml URL: http://svn.reactos.org/svn/reactos/trunk/rosapps/tests/directory.xml?rev=230... ============================================================================== --- trunk/rosapps/tests/directory.xml (original) +++ trunk/rosapps/tests/directory.xml Thu Jul 13 23:00:05 2006 @@ -67,6 +67,9 @@ <directory name="dnsquery"> <xi:include href="dnsquery/dnsquery.xml" /> </directory> +<directory name="DxHalTest"> + <xi:include href="DxHalTest/DxHalTest.rbuild" /> +</directory> <directory name="edit"> <xi:include href="edit/edit.xml" /> </directory> @@ -97,9 +100,9 @@ <directory name="gradient"> <xi:include href="gradient/gradient.xml" /> </directory> -<directory name="guithreadinfo"> - <xi:include href="guithreadinfo/guithreadinfo.xml" /> -</directory> + +<!-- fixme: guithreadinfo --> + <directory name="hello"> <xi:include href="hello/hello.xml" /> </directory>
-
greatlrd＠svn.reactos.org