ReactOS Development > Doxygen

00001 /* $Id: ddraw_displaymode.c 37776 2008-11-30 19:28:11Z hyperion $
00002  *
00003  * COPYRIGHT:            See COPYING in the top level directory
00004  * PROJECT:              ReactOS DirectX
00005  * FILE:                 ddraw/ddraw/ddraw_displaymode.c
00006  * PURPOSE:              IDirectDraw7 Implementation
00007  * PROGRAMMER:           Maarten Bosma, Magnus Olsen (add seh support)
00008  *
00009  */
00010 
00011 
00012 #include "rosdraw.h"
00013 
00014 HRESULT WINAPI
00015 Main_DirectDraw_EnumDisplayModes(LPDDRAWI_DIRECTDRAW_INT This, DWORD dwFlags,
00016                                   LPDDSURFACEDESC pDDSD, LPVOID pContext, LPDDENUMMODESCALLBACK pCallback)
00017 {
00018     HRESULT ret = DD_OK;
00019     INT iMode = 0;
00020     DEVMODE DevMode;
00021 
00022     DX_WINDBG_trace();
00023 
00024     ZeroMemory(&DevMode, sizeof(DEVMODE));
00025 
00026     _SEH2_TRY
00027     {
00028 
00029         if (pDDSD != NULL)
00030         {
00031             if (pDDSD->dwSize != sizeof(DDSURFACEDESC))
00032             {
00033                  ret = DDERR_INVALIDPARAMS;
00034             }
00035         }
00036 
00037         if (IsBadCodePtr((LPVOID)pCallback))
00038         {
00039             ret = DDERR_INVALIDPARAMS;
00040         }
00041         else if ( ret == DD_OK)
00042         {
00043 
00044             DevMode.dmSize = sizeof(DEVMODE);
00045 
00046             while (EnumDisplaySettingsEx(NULL, iMode, &DevMode, 0) == TRUE)
00047             {
00048                 DDSURFACEDESC SurfaceDesc;
00049 
00050                 ZeroMemory(&SurfaceDesc, sizeof(DDSURFACEDESC));
00051 
00052                 iMode++;
00053 
00054                 SurfaceDesc.dwSize = sizeof (DDSURFACEDESC);
00055                 SurfaceDesc.dwFlags = DDSD_HEIGHT | DDSD_WIDTH | DDSD_REFRESHRATE | DDSD_WIDTH | DDSD_PIXELFORMAT;
00056                 SurfaceDesc.dwHeight = DevMode.dmPelsHeight;
00057                 SurfaceDesc.dwWidth = DevMode.dmPelsWidth;
00058                 SurfaceDesc.lPitch = DevMode.dmPelsWidth * DevMode.dmBitsPerPel / 8;
00059                 SurfaceDesc.dwRefreshRate = DevMode.dmDisplayFrequency;
00060 
00061                 SurfaceDesc.ddpfPixelFormat.dwSize = sizeof (DDPIXELFORMAT);
00062                 SurfaceDesc.ddpfPixelFormat.dwFlags = DDPF_RGB;
00063                 // FIXME: get these
00064                 /*
00065                     SurfaceDesc.ddpfPixelFormat.dwRBitMask =
00066                     SurfaceDesc.ddpfPixelFormat.dwGBitMask =
00067                     SurfaceDesc.ddpfPixelFormat.dwBBitMask =
00068                     SurfaceDesc.ddpfPixelFormat.dwRGBAlphaBitMask =
00069                 */
00070                 SurfaceDesc.ddpfPixelFormat.dwRGBBitCount = DevMode.dmBitsPerPel;
00071 
00072                 // FIXME1: This->lpLcl->lpGbl->dwMonitorFrequency is not set !
00073                 if(dwFlags & DDEDM_REFRESHRATES && SurfaceDesc.dwRefreshRate != This->lpLcl->lpGbl->dwMonitorFrequency)
00074                 {
00075                     //continue;  // FIXME2: what is SurfaceDesc.dwRefreshRate supposed to be set to ?
00076                 }
00077 
00078                 // FIXME: Take case when DDEDM_STANDARDVGAMODES flag is not set in account
00079 
00080                 if(pDDSD)
00081                 {
00082                     if(pDDSD->dwFlags & DDSD_HEIGHT && pDDSD->dwHeight != SurfaceDesc.dwHeight)
00083                         continue;
00084 
00085                     else if(pDDSD->dwFlags & DDSD_WIDTH && pDDSD->dwWidth != SurfaceDesc.dwWidth)
00086                         continue;
00087 
00088                     else if(pDDSD->dwFlags & DDSD_PITCH && pDDSD->lPitch != SurfaceDesc.lPitch)
00089                         continue;
00090 
00091                     else if(pDDSD->dwFlags & DDSD_REFRESHRATE && pDDSD->dwRefreshRate != SurfaceDesc.dwRefreshRate)
00092                         continue;
00093 
00094                     else if(pDDSD->dwFlags & DDSD_PIXELFORMAT && pDDSD->ddpfPixelFormat.dwRGBBitCount != SurfaceDesc.ddpfPixelFormat.dwRGBBitCount)
00095                         continue;  // FIXME: test for the other members of ddpfPixelFormat as well
00096                 }
00097 
00098                 if((*pCallback)(&SurfaceDesc, pContext) == DDENUMRET_CANCEL)
00099                     break;
00100             }
00101         }
00102 
00103     }
00104     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
00105     {
00106     }
00107     _SEH2_END;
00108 
00109     return ret;
00110 }
00111 
00112 HRESULT WINAPI
00113 Main_DirectDraw_EnumDisplayModes4(LPDDRAWI_DIRECTDRAW_INT This, DWORD dwFlags,
00114                                   LPDDSURFACEDESC2 pDDSD, LPVOID pContext, LPDDENUMMODESCALLBACK2 pCallback)
00115 {
00116     HRESULT ret = DD_OK;
00117     INT iMode = 0;
00118     DEVMODE DevMode;
00119 
00120     DX_WINDBG_trace();
00121 
00122     ZeroMemory(&DevMode, sizeof(DEVMODE));
00123 
00124     _SEH2_TRY
00125     {
00126 
00127         if (pDDSD != NULL)
00128         {
00129             if (pDDSD->dwSize != sizeof(DDSURFACEDESC2))
00130             {
00131                  ret = DDERR_INVALIDPARAMS;
00132             }
00133         }
00134 
00135         if (IsBadCodePtr((LPVOID)pCallback))
00136         {
00137             ret = DDERR_INVALIDPARAMS;
00138         }
00139         else if ( ret == DD_OK)
00140         {
00141 
00142             DevMode.dmSize = sizeof(DEVMODE);
00143 
00144             while (EnumDisplaySettingsEx(NULL, iMode, &DevMode, 0) == TRUE)
00145             {
00146                 DDSURFACEDESC2 SurfaceDesc;
00147 
00148                 ZeroMemory(&SurfaceDesc, sizeof(DDSURFACEDESC2));
00149 
00150                 iMode++;
00151 
00152                 SurfaceDesc.dwSize = sizeof (DDSURFACEDESC2);
00153                 SurfaceDesc.dwFlags = DDSD_HEIGHT | DDSD_WIDTH | DDSD_REFRESHRATE | DDSD_WIDTH | DDSD_PIXELFORMAT;
00154                 SurfaceDesc.dwHeight = DevMode.dmPelsHeight;
00155                 SurfaceDesc.dwWidth = DevMode.dmPelsWidth;
00156                 SurfaceDesc.lPitch = DevMode.dmPelsWidth * DevMode.dmBitsPerPel / 8;
00157                 SurfaceDesc.dwRefreshRate = DevMode.dmDisplayFrequency;
00158 
00159                 SurfaceDesc.ddpfPixelFormat.dwSize = sizeof (DDPIXELFORMAT);
00160                 SurfaceDesc.ddpfPixelFormat.dwFlags = DDPF_RGB;
00161                 // FIXME: get these
00162                 /*
00163                     SurfaceDesc.ddpfPixelFormat.dwRBitMask =
00164                     SurfaceDesc.ddpfPixelFormat.dwGBitMask =
00165                     SurfaceDesc.ddpfPixelFormat.dwBBitMask =
00166                     SurfaceDesc.ddpfPixelFormat.dwRGBAlphaBitMask =
00167                 */
00168                 SurfaceDesc.ddpfPixelFormat.dwRGBBitCount = DevMode.dmBitsPerPel;
00169 
00170                 // FIXME1: This->lpLcl->lpGbl->dwMonitorFrequency is not set !
00171                 if(dwFlags & DDEDM_REFRESHRATES && SurfaceDesc.dwRefreshRate != This->lpLcl->lpGbl->dwMonitorFrequency)
00172                 {
00173                     //continue;  // FIXME2: what is SurfaceDesc.dwRefreshRate supposed to be set to ?
00174                 }
00175 
00176                 // FIXME: Take case when DDEDM_STANDARDVGAMODES flag is not set in account
00177 
00178                 if(pDDSD)
00179                 {
00180                     if(pDDSD->dwFlags & DDSD_HEIGHT && pDDSD->dwHeight != SurfaceDesc.dwHeight)
00181                         continue;
00182 
00183                     else if(pDDSD->dwFlags & DDSD_WIDTH && pDDSD->dwWidth != SurfaceDesc.dwWidth)
00184                         continue;
00185 
00186                     else if(pDDSD->dwFlags & DDSD_PITCH && pDDSD->lPitch != SurfaceDesc.lPitch)
00187                         continue;
00188 
00189                     else if(pDDSD->dwFlags & DDSD_REFRESHRATE && pDDSD->dwRefreshRate != SurfaceDesc.dwRefreshRate)
00190                         continue;
00191 
00192                     else if(pDDSD->dwFlags & DDSD_PIXELFORMAT && pDDSD->ddpfPixelFormat.dwRGBBitCount != SurfaceDesc.ddpfPixelFormat.dwRGBBitCount)
00193                         continue;  // FIXME: test for the other members of ddpfPixelFormat as well
00194                 }
00195 
00196                 if((*pCallback)(&SurfaceDesc, pContext) == DDENUMRET_CANCEL)
00197                     break;
00198             }
00199         }
00200 
00201     }
00202     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
00203     {
00204     }
00205     _SEH2_END;
00206 
00207     return ret;
00208 }
00209 
00210 HRESULT WINAPI
00211 Main_DirectDraw_SetDisplayMode (LPDDRAWI_DIRECTDRAW_INT This, DWORD dwWidth, DWORD dwHeight, DWORD dwBPP)
00212 {
00213     DX_WINDBG_trace();
00214 
00215     return Main_DirectDraw_SetDisplayMode2 (This, dwWidth, dwHeight, dwBPP, 0, 0 );
00216 }
00217 
00218 HRESULT WINAPI
00219 Main_DirectDraw_SetDisplayMode2 (LPDDRAWI_DIRECTDRAW_INT This, DWORD dwWidth, DWORD dwHeight,
00220                                  DWORD dwBPP, DWORD dwRefreshRate, DWORD dwFlags)
00221 {
00222     HRESULT ret = DD_OK;
00223     DX_WINDBG_trace();
00224 
00225     _SEH2_TRY
00226     {
00227         // FIXME: Check primary if surface is locked / busy etc.
00228 
00229         // Check Parameters
00230         if(dwFlags != 0)
00231         {
00232             ret = DDERR_INVALIDPARAMS;
00233         }
00234         else
00235         {
00236             if ((!dwHeight || This->lpLcl->lpGbl->vmiData.dwDisplayHeight == dwHeight) &&
00237                 (!dwWidth || This->lpLcl->lpGbl->vmiData.dwDisplayWidth == dwWidth)  &&
00238                 (!dwBPP || This->lpLcl->lpGbl->vmiData.ddpfDisplay.dwRGBBitCount == dwBPP) &&
00239                 (!dwRefreshRate || This->lpLcl->lpGbl->dwMonitorFrequency == dwRefreshRate))
00240             {
00241                 ret = DD_OK; // nothing to do here for us
00242             }
00243             else
00244             {
00245                 LONG retval;
00246                 // Here we go
00247                 DEVMODE DevMode;
00248                 ZeroMemory(&DevMode, sizeof(DEVMODE));
00249                 DevMode.dmSize = sizeof(DEVMODE);
00250 
00251                 if (dwHeight)
00252                     DevMode.dmFields |= DM_PELSHEIGHT;
00253                 if (dwWidth)
00254                     DevMode.dmFields |= DM_PELSWIDTH;
00255                 if (dwBPP)
00256                     DevMode.dmFields |= DM_BITSPERPEL;
00257                 if (dwRefreshRate)
00258                     DevMode.dmFields |= DM_DISPLAYFREQUENCY;
00259 
00260                 DevMode.dmPelsHeight = dwHeight;
00261                 DevMode.dmPelsWidth = dwWidth;
00262                 DevMode.dmBitsPerPel = dwBPP;
00263                 DevMode.dmDisplayFrequency = dwRefreshRate;
00264 
00265                 DX_WINDBG_trace_res(dwWidth, dwHeight,dwBPP, dwRefreshRate);
00266 
00267                 retval = ChangeDisplaySettings(&DevMode, CDS_FULLSCREEN);
00268                 /* FIXME: Are we supposed to set CDS_SET_PRIMARY as well ? */
00269 
00270                 if(retval == DISP_CHANGE_BADMODE)
00271                 {
00272                     /* Note : it seam ms ddraw ignore this and try using the bad mode any case.
00273                      * tested with Ati HD2400 that only support 16 and 32 Bpp in windows
00274                      */
00275                     DX_STUB_str("Warning ChangeDisplaySettings return DISP_CHANGE_BADMODE, but ddraw.dll ignore it\n");
00276 
00277                     //ret = DDERR_UNSUPPORTED;
00278                     BOOL ModeChanged;
00279                     This->lpLcl->lpGbl->hDD = This->lpLcl->hDD;
00280                     DdReenableDirectDrawObject(This->lpLcl->lpGbl, &ModeChanged);
00281                     StartDirectDraw((LPDIRECTDRAW)This, 0, TRUE);
00282                 }
00283                 else if(retval != DISP_CHANGE_SUCCESSFUL)
00284                 {
00285                     ret = DDERR_GENERIC;
00286                 }
00287                 else
00288                 {
00289                     // Update Interals
00290                     BOOL ModeChanged;
00291                     This->lpLcl->lpGbl->hDD = This->lpLcl->hDD;
00292                     DdReenableDirectDrawObject(This->lpLcl->lpGbl, &ModeChanged);
00293                     StartDirectDraw((LPDIRECTDRAW)This, 0, TRUE);
00294                 }
00295             }
00296         }
00297     }
00298     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
00299     {
00300     }
00301     _SEH2_END;
00302 
00303     return ret;
00304 }
00305 
00306 HRESULT WINAPI
00307 Main_DirectDraw_RestoreDisplayMode (LPDDRAWI_DIRECTDRAW_INT This)
00308 {
00309     DX_WINDBG_trace();
00310 
00311     _SEH2_TRY
00312     {
00313         BOOL ModeChanged;
00314 
00315         ChangeDisplaySettings(NULL, 0);
00316 
00317         // Update Interals
00318 
00319 
00320         This->lpLcl->lpGbl->hDD = This->lpLcl->hDD;
00321         DdReenableDirectDrawObject(This->lpLcl->lpGbl, &ModeChanged);
00322         StartDirectDraw((LPDIRECTDRAW)This, 0, TRUE);
00323     }
00324     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
00325     {
00326     }
00327     _SEH2_END;
00328 
00329 
00330     return DD_OK;
00331 }
00332 
00333 HRESULT WINAPI
00334 Main_DirectDraw_GetMonitorFrequency (LPDDRAWI_DIRECTDRAW_INT This, LPDWORD lpFreq)
00335 {
00336     HRESULT retVal = DD_OK;
00337     DX_WINDBG_trace();
00338 
00339     _SEH2_TRY
00340     {
00341         if(IsBadWritePtr(lpFreq,sizeof(LPDWORD)))
00342         {
00343             retVal = DDERR_INVALIDPARAMS;
00344         }
00345         else
00346         {
00347             if (This->lpLcl->lpGbl->dwMonitorFrequency)
00348             {
00349                 *lpFreq = This->lpLcl->lpGbl->dwMonitorFrequency;
00350             }
00351             else
00352             {
00353                 retVal = DDERR_UNSUPPORTED;
00354             }
00355         }
00356     }
00357     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
00358     {
00359       retVal = DD_FALSE;
00360     }
00361     _SEH2_END;
00362 
00363     return retVal;
00364 }
00365 
00366 HRESULT WINAPI
00367 Main_DirectDraw_GetDisplayMode (LPDDRAWI_DIRECTDRAW_INT This, LPDDSURFACEDESC pDDSD)
00368 {
00369     HRESULT retVal = DD_OK;
00370     DX_WINDBG_trace();
00371 
00372     _SEH2_TRY
00373     {
00374         if(IsBadWritePtr(pDDSD,sizeof(LPDDSURFACEDESC)))
00375         {
00376             retVal = DDERR_INVALIDPARAMS;
00377         }
00378         else if (pDDSD->dwSize != sizeof(DDSURFACEDESC))
00379         {
00380              retVal = DDERR_INVALIDPARAMS;
00381         }
00382         else
00383         {
00384             // FIXME: More stucture members might need to be filled
00385 
00386             pDDSD->dwFlags |= DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH | DDSD_REFRESHRATE;
00387             pDDSD->dwHeight = This->lpLcl->lpGbl->vmiData.dwDisplayHeight;
00388             pDDSD->dwWidth = This->lpLcl->lpGbl->vmiData.dwDisplayWidth;
00389             pDDSD->ddpfPixelFormat = This->lpLcl->lpGbl->vmiData.ddpfDisplay;
00390             pDDSD->dwRefreshRate = This->lpLcl->lpGbl->dwMonitorFrequency;
00391             pDDSD->lPitch = This->lpLcl->lpGbl->vmiData.lDisplayPitch;
00392         }
00393     }
00394     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
00395     {
00396     }
00397     _SEH2_END;
00398 
00399     return retVal;
00400 }
00401 
00402 HRESULT WINAPI
00403 Main_DirectDraw_GetDisplayMode4 (LPDDRAWI_DIRECTDRAW_INT This, LPDDSURFACEDESC2 pDDSD)
00404 {
00405     HRESULT retVal = DD_OK;
00406     DX_WINDBG_trace();
00407 
00408     _SEH2_TRY
00409     {
00410         if(IsBadWritePtr(pDDSD,sizeof(LPDDSURFACEDESC2)))
00411         {
00412             retVal = DDERR_INVALIDPARAMS;
00413         }
00414         else if (pDDSD->dwSize != sizeof(DDSURFACEDESC2))
00415         {
00416              retVal = DDERR_INVALIDPARAMS;
00417         }
00418         else
00419         {
00420             // FIXME: More stucture members might need to be filled
00421 
00422             pDDSD->dwFlags |= DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH | DDSD_REFRESHRATE;
00423             pDDSD->dwHeight = This->lpLcl->lpGbl->vmiData.dwDisplayHeight;
00424             pDDSD->dwWidth = This->lpLcl->lpGbl->vmiData.dwDisplayWidth;
00425             pDDSD->ddpfPixelFormat = This->lpLcl->lpGbl->vmiData.ddpfDisplay;
00426             pDDSD->dwRefreshRate = This->lpLcl->lpGbl->dwMonitorFrequency;
00427             pDDSD->lPitch = This->lpLcl->lpGbl->vmiData.lDisplayPitch;
00428         }
00429     }
00430     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
00431     {
00432     }
00433     _SEH2_END;
00434 
00435     return retVal;
00436 }
Generated on Sun May 27 2012 04:21:24 for ReactOS by
1.7.6.1