Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-01 19:13:30 +00:00
Code Issues Projects Releases Packages Wiki Activity

[WIN32K]

Browse source 
Improve formatting

svn path=/trunk/; revision=58405
This commit is contained in:
Timo Kreuzer 2013-03-02 20:23:22 +00:00
parent 32f93fc9b7
commit 95e9b1a4a7
1 changed files with 293 additions and 281 deletions
Download patch file Download diff file Expand all files Collapse all files

574
reactos/win32ss/gdi/ntgdi/icm.c
View file

@ -19,17 +19,17 @@ FASTCALL
IntGdiCreateColorSpace( IntGdiCreateColorSpace(
PLOGCOLORSPACEEXW pLogColorSpace) PLOGCOLORSPACEEXW pLogColorSpace)
{ {
PCOLORSPACE pCS; PCOLORSPACE pCS;
HCOLORSPACE hCS; HCOLORSPACE hCS;
pCS = COLORSPACEOBJ_AllocCSWithHandle(); pCS = COLORSPACEOBJ_AllocCSWithHandle();
hCS = pCS->BaseObject.hHmgr; hCS = pCS->BaseObject.hHmgr;
pCS->lcsColorSpace = pLogColorSpace->lcsColorSpace; pCS->lcsColorSpace = pLogColorSpace->lcsColorSpace;
pCS->dwFlags = pLogColorSpace->dwFlags; pCS->dwFlags = pLogColorSpace->dwFlags;
COLORSPACEOBJ_UnlockCS(pCS); COLORSPACEOBJ_UnlockCS(pCS);
return hCS; return hCS;
} }
BOOL BOOL
@ -37,15 +37,16 @@ FASTCALL
IntGdiDeleteColorSpace( IntGdiDeleteColorSpace(
HCOLORSPACE hColorSpace) HCOLORSPACE hColorSpace)
{ {
BOOL Ret = FALSE; BOOL Ret = FALSE;
if ( hColorSpace != hStockColorSpace && if ((hColorSpace != hStockColorSpace) &&
GDI_HANDLE_GET_TYPE(hColorSpace) == GDILoObjType_LO_ICMLCS_TYPE) (GDI_HANDLE_GET_TYPE(hColorSpace) == GDILoObjType_LO_ICMLCS_TYPE))
{ {
Ret = GreDeleteObject(hColorSpace); Ret = GreDeleteObject(hColorSpace);
if ( !Ret ) EngSetLastError(ERROR_INVALID_PARAMETER); if (!Ret) EngSetLastError(ERROR_INVALID_PARAMETER);
} }
return Ret;
return Ret;
} }
HANDLE HANDLE
@ -53,28 +54,27 @@ APIENTRY
NtGdiCreateColorSpace( NtGdiCreateColorSpace(
IN PLOGCOLORSPACEEXW pLogColorSpace) IN PLOGCOLORSPACEEXW pLogColorSpace)
{ {
LOGCOLORSPACEEXW Safelcs; LOGCOLORSPACEEXW Safelcs;
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
_SEH2_TRY _SEH2_TRY
{ {
ProbeForRead( pLogColorSpace, ProbeForRead( pLogColorSpace, sizeof(LOGCOLORSPACEEXW), 1);
sizeof(LOGCOLORSPACEEXW), RtlCopyMemory(&Safelcs, pLogColorSpace, sizeof(LOGCOLORSPACEEXW));
1); }
RtlCopyMemory(&Safelcs, pLogColorSpace, sizeof(LOGCOLORSPACEEXW)); _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
} {
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) Status = _SEH2_GetExceptionCode();
{ }
Status = _SEH2_GetExceptionCode(); _SEH2_END;
}
_SEH2_END;
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastNtError(Status); SetLastNtError(Status);
return NULL; return NULL;
} }
return IntGdiCreateColorSpace(&Safelcs);
return IntGdiCreateColorSpace(&Safelcs);
} }
BOOL BOOL
@ -82,92 +82,95 @@ APIENTRY
NtGdiDeleteColorSpace( NtGdiDeleteColorSpace(
IN HANDLE hColorSpace) IN HANDLE hColorSpace)
{ {
return IntGdiDeleteColorSpace(hColorSpace); return IntGdiDeleteColorSpace(hColorSpace);
} }
BOOL BOOL
FASTCALL FASTCALL
IntGetDeviceGammaRamp(HDEV hPDev, PGAMMARAMP Ramp) IntGetDeviceGammaRamp(HDEV hPDev, PGAMMARAMP Ramp)
{ {
PPDEVOBJ pGDev = (PPDEVOBJ) hPDev; PPDEVOBJ pGDev = (PPDEVOBJ) hPDev;
int i; int i;
if (!(pGDev->flFlags & PDEV_DISPLAY )) return FALSE; if (!(pGDev->flFlags & PDEV_DISPLAY)) return FALSE;
if ((pGDev->devinfo.iDitherFormat == BMF_8BPP) || if ((pGDev->devinfo.iDitherFormat == BMF_8BPP) ||
(pGDev->devinfo.iDitherFormat == BMF_16BPP) || (pGDev->devinfo.iDitherFormat == BMF_16BPP) ||
(pGDev->devinfo.iDitherFormat == BMF_24BPP) || (pGDev->devinfo.iDitherFormat == BMF_24BPP) ||
(pGDev->devinfo.iDitherFormat == BMF_32BPP)) (pGDev->devinfo.iDitherFormat == BMF_32BPP))
{ {
if (pGDev->flFlags & PDEV_GAMMARAMP_TABLE) if (pGDev->flFlags & PDEV_GAMMARAMP_TABLE)
RtlCopyMemory( Ramp,
pGDev->pvGammaRamp,
sizeof(GAMMARAMP));
else
// Generate the 256-colors array
for(i=0; i<256; i++ )
{ {
int NewValue = i * 256; RtlCopyMemory(Ramp, pGDev->pvGammaRamp, sizeof(GAMMARAMP));
Ramp->Red[i] = Ramp->Green[i] = Ramp->Blue[i] = ((WORD)NewValue);
} }
return TRUE; else
} {
else // Generate the 256-colors array
return FALSE; for (i = 0; i < 256; i++ )
{
int NewValue = i * 256;
Ramp->Red[i] = Ramp->Green[i] = Ramp->Blue[i] = ((WORD)NewValue);
}
}
return TRUE;
}
return FALSE;
} }
BOOL BOOL
APIENTRY APIENTRY
NtGdiGetDeviceGammaRamp(HDC hDC, NtGdiGetDeviceGammaRamp(
LPVOID Ramp) HDC hDC,
LPVOID Ramp)
{ {
BOOL Ret; BOOL Ret;
PDC dc; PDC dc;
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
PGAMMARAMP SafeRamp; PGAMMARAMP SafeRamp;
if (!Ramp) return FALSE; if (!Ramp) return FALSE;
dc = DC_LockDc(hDC); dc = DC_LockDc(hDC);
if (!dc) if (!dc)
{ {
EngSetLastError(ERROR_INVALID_HANDLE); EngSetLastError(ERROR_INVALID_HANDLE);
return FALSE; return FALSE;
} }
SafeRamp = ExAllocatePoolWithTag(PagedPool, sizeof(GAMMARAMP), GDITAG_ICM); SafeRamp = ExAllocatePoolWithTag(PagedPool, sizeof(GAMMARAMP), GDITAG_ICM);
if (!SafeRamp) if (!SafeRamp)
{ {
DC_UnlockDc(dc); DC_UnlockDc(dc);
EngSetLastError(STATUS_NO_MEMORY); EngSetLastError(STATUS_NO_MEMORY);
return FALSE; return FALSE;
} }
Ret = IntGetDeviceGammaRamp((HDEV)dc->ppdev, SafeRamp); Ret = IntGetDeviceGammaRamp((HDEV)dc->ppdev, SafeRamp);
if (!Ret) return Ret; if (!Ret) return Ret;
_SEH2_TRY _SEH2_TRY
{ {
ProbeForWrite(Ramp, sizeof(GAMMARAMP), 1); ProbeForWrite(Ramp, sizeof(GAMMARAMP), 1);
RtlCopyMemory(Ramp, SafeRamp, sizeof(GAMMARAMP)); RtlCopyMemory(Ramp, SafeRamp, sizeof(GAMMARAMP));
} }
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{ {
Status = _SEH2_GetExceptionCode(); Status = _SEH2_GetExceptionCode();
} }
_SEH2_END; _SEH2_END;
DC_UnlockDc(dc); DC_UnlockDc(dc);
ExFreePoolWithTag(SafeRamp, GDITAG_ICM); ExFreePoolWithTag(SafeRamp, GDITAG_ICM);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastNtError(Status); SetLastNtError(Status);
return FALSE; return FALSE;
} }
return Ret; return Ret;
} }
BOOL BOOL
@ -175,94 +178,94 @@ APIENTRY
NtGdiSetColorSpace(IN HDC hdc, NtGdiSetColorSpace(IN HDC hdc,
IN HCOLORSPACE hColorSpace) IN HCOLORSPACE hColorSpace)
{ {
PDC pDC; PDC pDC;
PDC_ATTR pdcattr; PDC_ATTR pdcattr;
PCOLORSPACE pCS; PCOLORSPACE pCS;
pDC = DC_LockDc(hdc); pDC = DC_LockDc(hdc);
if (!pDC) if (!pDC)
{ {
EngSetLastError(ERROR_INVALID_HANDLE); EngSetLastError(ERROR_INVALID_HANDLE);
return FALSE; return FALSE;
} }
pdcattr = pDC->pdcattr; pdcattr = pDC->pdcattr;
if (pdcattr->hColorSpace == hColorSpace) if (pdcattr->hColorSpace == hColorSpace)
{ {
DC_UnlockDc(pDC); DC_UnlockDc(pDC);
return TRUE; return TRUE;
} }
pCS = COLORSPACEOBJ_LockCS(hColorSpace); pCS = COLORSPACEOBJ_LockCS(hColorSpace);
if (!pCS) if (!pCS)
{ {
EngSetLastError(ERROR_INVALID_HANDLE); EngSetLastError(ERROR_INVALID_HANDLE);
return FALSE; return FALSE;
} }
if (pDC->dclevel.pColorSpace) if (pDC->dclevel.pColorSpace)
{ {
GDIOBJ_vDereferenceObject((POBJ) pDC->dclevel.pColorSpace); GDIOBJ_vDereferenceObject((POBJ) pDC->dclevel.pColorSpace);
} }
pDC->dclevel.pColorSpace = pCS; pDC->dclevel.pColorSpace = pCS;
pdcattr->hColorSpace = hColorSpace; pdcattr->hColorSpace = hColorSpace;
COLORSPACEOBJ_UnlockCS(pCS); COLORSPACEOBJ_UnlockCS(pCS);
DC_UnlockDc(pDC); DC_UnlockDc(pDC);
return TRUE; return TRUE;
} }
BOOL BOOL
FASTCALL FASTCALL
UpdateDeviceGammaRamp( HDEV hPDev ) UpdateDeviceGammaRamp(HDEV hPDev)
{ {
BOOL Ret = FALSE; BOOL Ret = FALSE;
PPALETTE palGDI; PPALETTE palGDI;
PALOBJ *palPtr; PALOBJ *palPtr;
PPDEVOBJ pGDev = (PPDEVOBJ) hPDev; PPDEVOBJ pGDev = (PPDEVOBJ)hPDev;
if ((pGDev->devinfo.iDitherFormat == BMF_8BPP) || if ((pGDev->devinfo.iDitherFormat == BMF_8BPP) ||
(pGDev->devinfo.iDitherFormat == BMF_16BPP) || (pGDev->devinfo.iDitherFormat == BMF_16BPP) ||
(pGDev->devinfo.iDitherFormat == BMF_24BPP) || (pGDev->devinfo.iDitherFormat == BMF_24BPP) ||
(pGDev->devinfo.iDitherFormat == BMF_32BPP)) (pGDev->devinfo.iDitherFormat == BMF_32BPP))
{ {
if (pGDev->DriverFunctions.IcmSetDeviceGammaRamp) if (pGDev->DriverFunctions.IcmSetDeviceGammaRamp)
return pGDev->DriverFunctions.IcmSetDeviceGammaRamp( pGDev->dhpdev, return pGDev->DriverFunctions.IcmSetDeviceGammaRamp( pGDev->dhpdev,
IGRF_RGB_256WORDS, IGRF_RGB_256WORDS,
pGDev->pvGammaRamp); pGDev->pvGammaRamp);
if ( (pGDev->devinfo.iDitherFormat != BMF_8BPP) || if ((pGDev->devinfo.iDitherFormat != BMF_8BPP) ||
!(pGDev->gdiinfo.flRaster & RC_PALETTE)) return FALSE; !(pGDev->gdiinfo.flRaster & RC_PALETTE)) return FALSE;
if (!(pGDev->flFlags & PDEV_GAMMARAMP_TABLE)) return FALSE; if (!(pGDev->flFlags & PDEV_GAMMARAMP_TABLE)) return FALSE;
palGDI = PALETTE_ShareLockPalette(pGDev->devinfo.hpalDefault); palGDI = PALETTE_ShareLockPalette(pGDev->devinfo.hpalDefault);
if(!palGDI) return FALSE; if(!palGDI) return FALSE;
palPtr = (PALOBJ*) palGDI; palPtr = (PALOBJ*) palGDI;
if (pGDev->flFlags & PDEV_GAMMARAMP_TABLE) if (pGDev->flFlags & PDEV_GAMMARAMP_TABLE)
palGDI->flFlags |= PAL_GAMMACORRECTION; palGDI->flFlags |= PAL_GAMMACORRECTION;
else else
palGDI->flFlags &= ~PAL_GAMMACORRECTION; palGDI->flFlags &= ~PAL_GAMMACORRECTION;
if (!(pGDev->flFlags & PDEV_DRIVER_PUNTED_CALL)) // No punting, we hook if (!(pGDev->flFlags & PDEV_DRIVER_PUNTED_CALL)) // No punting, we hook
{ {
// BMF_8BPP only! // BMF_8BPP only!
// PALOBJ_cGetColors check mode flags and update Gamma Correction. // PALOBJ_cGetColors check mode flags and update Gamma Correction.
// Set the HDEV to pal and go. // Set the HDEV to pal and go.
palGDI->hPDev = hPDev; palGDI->hPDev = hPDev;
Ret = pGDev->DriverFunctions.SetPalette(pGDev->dhpdev, Ret = pGDev->DriverFunctions.SetPalette(pGDev->dhpdev,
palPtr, palPtr,
0, 0,
0, 0,
palGDI->NumColors); palGDI->NumColors);
} }
PALETTE_ShareUnlockPalette(palGDI); PALETTE_ShareUnlockPalette(palGDI);
return Ret; return Ret;
} }
else else
return FALSE; return FALSE;
} }
// //
@ -274,125 +277,134 @@ BOOL
FASTCALL FASTCALL
IntSetDeviceGammaRamp(HDEV hPDev, PGAMMARAMP Ramp, BOOL Test) IntSetDeviceGammaRamp(HDEV hPDev, PGAMMARAMP Ramp, BOOL Test)
{ {
WORD IcmGR, i, R, G, B; WORD IcmGR, i, R, G, B;
BOOL Ret = FALSE, TstPeak; BOOL Ret = FALSE, TstPeak;
PPDEVOBJ pGDev = (PPDEVOBJ) hPDev; PPDEVOBJ pGDev = (PPDEVOBJ) hPDev;
if (!hPDev) return FALSE; if (!hPDev) return FALSE;
if (!(pGDev->flFlags & PDEV_DISPLAY )) return FALSE; if (!(pGDev->flFlags & PDEV_DISPLAY )) return FALSE;
if ((pGDev->devinfo.iDitherFormat == BMF_8BPP) || if ((pGDev->devinfo.iDitherFormat == BMF_8BPP) ||
(pGDev->devinfo.iDitherFormat == BMF_16BPP) || (pGDev->devinfo.iDitherFormat == BMF_16BPP) ||
(pGDev->devinfo.iDitherFormat == BMF_24BPP) || (pGDev->devinfo.iDitherFormat == BMF_24BPP) ||
(pGDev->devinfo.iDitherFormat == BMF_32BPP)) (pGDev->devinfo.iDitherFormat == BMF_32BPP))
{ {
if (!pGDev->DriverFunctions.IcmSetDeviceGammaRamp) if (!pGDev->DriverFunctions.IcmSetDeviceGammaRamp)
{ // No driver support {
if (!(pGDev->devinfo.flGraphicsCaps2 & GCAPS2_CHANGEGAMMARAMP)) // No driver support
{ // Driver does not support Gamma Ramp, so test to see we if (!(pGDev->devinfo.flGraphicsCaps2 & GCAPS2_CHANGEGAMMARAMP))
// have BMF_8BPP only and palette operation support.
if ((pGDev->devinfo.iDitherFormat != BMF_8BPP) ||
!(pGDev->gdiinfo.flRaster & RC_PALETTE)) return FALSE;
}
}
if (pGDev->flFlags & PDEV_GAMMARAMP_TABLE)
if (RtlCompareMemory( pGDev->pvGammaRamp, Ramp, sizeof(GAMMARAMP)) ==
sizeof(GAMMARAMP)) return TRUE;
// Verify Ramp is inside range.
IcmGR = -IcmGammaRangeSet;
TstPeak = (Test == FALSE);
for (i = 0; i < 256; i++)
{
R = Ramp->Red[i] / 256;
G = Ramp->Green[i] / 256;
B = Ramp->Blue[i] / 256;
if ( R >= IcmGR)
{
if ( R <= IcmGammaRangeSet + i)
{ {
if ( G >= IcmGR && // Driver does not support Gamma Ramp, so test to see we
(G <= IcmGammaRangeSet + i) && // have BMF_8BPP only and palette operation support.
B >= IcmGR && if ((pGDev->devinfo.iDitherFormat != BMF_8BPP) ||
(B <= IcmGammaRangeSet + i) ) continue; !(pGDev->gdiinfo.flRaster & RC_PALETTE)) return FALSE;
} }
} }
if (Test) return Ret; // Don't set and return.
// No test override, check max range
if (TstPeak)
{
if ( R != (IcmGR * 256) ||
G != (IcmGR * 256) ||
B != (IcmGR * 256) ) TstPeak = FALSE; // W/i range.
}
}
// ReactOS allocates a ramp even if it is 8BPP and Palette only.
// This way we have a record of the change in memory.
if (!pGDev->pvGammaRamp && !(pGDev->flFlags & PDEV_GAMMARAMP_TABLE))
{ // If the above is true and we have nothing allocated, create it.
pGDev->pvGammaRamp = ExAllocatePoolWithTag(PagedPool, sizeof(GAMMARAMP), GDITAG_ICM);
pGDev->flFlags |= PDEV_GAMMARAMP_TABLE;
}
if (pGDev->pvGammaRamp)
RtlCopyMemory( pGDev->pvGammaRamp, Ramp, sizeof(GAMMARAMP));
Ret = UpdateDeviceGammaRamp(hPDev); if (pGDev->flFlags & PDEV_GAMMARAMP_TABLE)
{
if (RtlCompareMemory(pGDev->pvGammaRamp, Ramp, sizeof(GAMMARAMP)) ==
sizeof(GAMMARAMP)) return TRUE;
}
return Ret; // Verify Ramp is inside range.
} IcmGR = -IcmGammaRangeSet;
else TstPeak = (Test == FALSE);
return Ret; for (i = 0; i < 256; i++)
{
R = Ramp->Red[i] / 256;
G = Ramp->Green[i] / 256;
B = Ramp->Blue[i] / 256;
if (R >= IcmGR)
{
if (R <= IcmGammaRangeSet + i)
{
if ((G >= IcmGR) &&
(G <= IcmGammaRangeSet + i) &&
(B >= IcmGR) &&
(B <= IcmGammaRangeSet + i) ) continue;
}
}
if (Test) return Ret; // Don't set and return.
// No test override, check max range
if (TstPeak)
{
if ((R != (IcmGR * 256)) ||
(G != (IcmGR * 256)) ||
(B != (IcmGR * 256)) ) TstPeak = FALSE; // W/i range.
}
}
// ReactOS allocates a ramp even if it is 8BPP and Palette only.
// This way we have a record of the change in memory.
if (!pGDev->pvGammaRamp && !(pGDev->flFlags & PDEV_GAMMARAMP_TABLE))
{
// If the above is true and we have nothing allocated, create it.
pGDev->pvGammaRamp = ExAllocatePoolWithTag(PagedPool, sizeof(GAMMARAMP), GDITAG_ICM);
pGDev->flFlags |= PDEV_GAMMARAMP_TABLE;
}
if (pGDev->pvGammaRamp)
RtlCopyMemory(pGDev->pvGammaRamp, Ramp, sizeof(GAMMARAMP));
Ret = UpdateDeviceGammaRamp(hPDev);
}
return Ret;
} }
BOOL BOOL
APIENTRY APIENTRY
NtGdiSetDeviceGammaRamp(HDC hDC, NtGdiSetDeviceGammaRamp(
LPVOID Ramp) HDC hDC,
LPVOID Ramp)
{ {
BOOL Ret; BOOL Ret;
PDC dc; PDC dc;
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
PGAMMARAMP SafeRamp; PGAMMARAMP SafeRamp;
if (!Ramp) return FALSE; if (!Ramp) return FALSE;
dc = DC_LockDc(hDC); dc = DC_LockDc(hDC);
if (!dc) if (!dc)
{ {
EngSetLastError(ERROR_INVALID_HANDLE); EngSetLastError(ERROR_INVALID_HANDLE);
return FALSE; return FALSE;
} }
SafeRamp = ExAllocatePoolWithTag(PagedPool, sizeof(GAMMARAMP), GDITAG_ICM); SafeRamp = ExAllocatePoolWithTag(PagedPool, sizeof(GAMMARAMP), GDITAG_ICM);
if (!SafeRamp) if (!SafeRamp)
{ {
DC_UnlockDc(dc); DC_UnlockDc(dc);
EngSetLastError(STATUS_NO_MEMORY); EngSetLastError(STATUS_NO_MEMORY);
return FALSE; return FALSE;
} }
_SEH2_TRY _SEH2_TRY
{ {
ProbeForRead(Ramp, sizeof(GAMMARAMP), 1); ProbeForRead(Ramp, sizeof(GAMMARAMP), 1);
RtlCopyMemory(SafeRamp, Ramp, sizeof(GAMMARAMP)); RtlCopyMemory(SafeRamp, Ramp, sizeof(GAMMARAMP));
} }
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{ {
Status = _SEH2_GetExceptionCode(); Status = _SEH2_GetExceptionCode();
} }
_SEH2_END; _SEH2_END;
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
DC_UnlockDc(dc); DC_UnlockDc(dc);
ExFreePoolWithTag(SafeRamp, GDITAG_ICM); ExFreePoolWithTag(SafeRamp, GDITAG_ICM);
SetLastNtError(Status); SetLastNtError(Status);
return FALSE; return FALSE;
} }
Ret = IntSetDeviceGammaRamp((HDEV)dc->ppdev, SafeRamp, TRUE); Ret = IntSetDeviceGammaRamp((HDEV)dc->ppdev, SafeRamp, TRUE);
DC_UnlockDc(dc); DC_UnlockDc(dc);
ExFreePoolWithTag(SafeRamp, GDITAG_ICM); ExFreePoolWithTag(SafeRamp, GDITAG_ICM);
return Ret; return Ret;
} }
INT INT
@ -401,21 +413,21 @@ NtGdiSetIcmMode(HDC hDC,
ULONG nCommand, ULONG nCommand,
ULONG EnableICM) // ulMode ULONG EnableICM) // ulMode
{ {
/* FIXME: This should be coded someday */ /* FIXME: This should be coded someday */
if (EnableICM == ICM_OFF) if (EnableICM == ICM_OFF)
{ {
return ICM_OFF; return ICM_OFF;
} }
if (EnableICM == ICM_ON) if (EnableICM == ICM_ON)
{ {
return 0; return 0;
} }
if (EnableICM == ICM_QUERY) if (EnableICM == ICM_QUERY)
{ {
return ICM_OFF; return ICM_OFF;
} }
return 0; return 0;
} }
/* EOF */ /* EOF */