hxparse.cpp

著名的 helix realplayer 基于手机 symbian 系统的 播放器全套源代码

            lIndex = COLOR_INACTIVECAPTIONTEXT;
            bMatch = TRUE;
        }
        else if (!strcasecmp(pColorString, "InfoBackground"))
        {
            lIndex = COLOR_INFOBK;
            bMatch = TRUE;
        }
        else if (!strcasecmp(pColorString, "InfoText"))
        {
            lIndex = COLOR_INFOTEXT;
            bMatch = TRUE;
        }
        else if (!strcasecmp(pColorString, "Menu"))
        {
            lIndex = COLOR_MENU;
            bMatch = TRUE;
        }
        else if (!strcasecmp(pColorString, "MenuText"))
        {
            lIndex = COLOR_MENUTEXT;
            bMatch = TRUE;
        }
        else if (!strcasecmp(pColorString, "Scrollbar"))
        {
            lIndex = COLOR_SCROLLBAR;
            bMatch = TRUE;
        }
        else if (!strcasecmp(pColorString, "ThreeDDarkShadow"))
        {
            lIndex = COLOR_3DDKSHADOW;
            bMatch = TRUE;
        }
        else if (!strcasecmp(pColorString, "ThreeDFace"))
        {
            lIndex = COLOR_3DFACE;
            bMatch = TRUE;
        }
        else if (!strcasecmp(pColorString, "ThreeDHighlight"))
        {
            lIndex = COLOR_3DHILIGHT;
            bMatch = TRUE;
        }
        else if (!strcasecmp(pColorString, "ThreeDLightShadow"))
        {
            lIndex = COLOR_3DLIGHT;
            bMatch = TRUE;
        }
        else if (!strcasecmp(pColorString, "ThreeDShadow"))
        {
            lIndex = COLOR_3DSHADOW;
            bMatch = TRUE;
        }
        else if (!strcasecmp(pColorString, "Window"))
        {
            lIndex = COLOR_WINDOW;
            bMatch = TRUE;
        }
        else if (!strcasecmp(pColorString, "WindowFrame"))
        {
            lIndex = COLOR_WINDOWFRAME;
            bMatch = TRUE;
        }
        else if (!strcasecmp(pColorString, "WindowText"))
        {
            lIndex = COLOR_WINDOWTEXT;
            bMatch = TRUE;
        }
        if (bMatch)
        {
            UINT32 ulColor = GetSysColor(lIndex);
            ucRed          = GetRValue(ulColor);
            ucGreen        = GetGValue(ulColor);
            ucBlue         = GetBValue(ulColor);
            theErr         = HXR_OK;

        }
    }
#endif

#ifdef _WINDOWS
    theColor = (HXxColor)(RGB(ucRed, ucGreen, ucBlue));
#else
    theColor = (HXxColor)
	    (ucRed << 16 |
	    ucGreen << 8 |
	    ucBlue);
#endif
    return theErr;
}


HX_RESULT
HXParseDigit(const char* pDigitString, REF(INT32) ulOut)
{
    // validate it first. ([whitespace][sign]digits)
    HX_RESULT ret = HXR_OK;
    const char* pBuf = pDigitString;
    
    // clear white space.
    while (*pBuf && isspace(*pBuf))
    {
	++pBuf;
    }

    // check for sign
    if (*pBuf == '+' || *pBuf == '-')
    {
	++pBuf;
    }

    // validate all else is a digit
    while (*pBuf)
    {
	if (!isdigit(*pBuf))
	{
	    ret = HXR_FAIL;
	    break;
	}
	++pBuf;
    }

    // run the conversion anyway... just in case the user wants
    // to ignor the error.
    ulOut = atol(pDigitString);

    return ret;
}

HX_RESULT
HXParseDouble(const char* pDoubleString, REF(double) dOut)
{
    // validate it first. 
    // ([whitespace][sign][digits][.digits][{d|D|e|E}[sign]digits])
    HX_RESULT ret = HXR_OK;
    const char* pBuf = pDoubleString;
    // clear white space.
    while (*pBuf && isspace(*pBuf))
    {
	++pBuf;
    }

    // check for sign
    if (*pBuf == '+' || *pBuf == '-')
    {
	++pBuf;
    }

    while (isdigit(*pBuf))
    {
	++pBuf;
    }

    if (*pBuf == '.')
    {
	++pBuf;
    }

    while (isdigit(*pBuf))
    {
	++pBuf;
    }

    if (*pBuf == 'd' || *pBuf == 'D' || *pBuf == 'e' || *pBuf == 'E')
    {
	++pBuf;
	if (*pBuf == '+' || *pBuf == '-')
	{
	    ++pBuf;
	}

	while (isdigit(*pBuf))
	{
	    ++pBuf;
	}
    }
    
    // we will allow whitespace at the end of the buffer,
    while (isspace(*pBuf))
    {
	++pBuf;
    }

    // now if we are not at the NULL termination something is wrong with the
    // string.
    if (*pBuf != '\0')
    {
	ret = HXR_INVALID_PARAMETER;
    }

    // run the conversion anyway...  The string might simply have junk at 
    // the end of it, in which case the error *might* want to be ignored.
    dOut = atof(pDoubleString);

    return ret;
}

HX_RESULT HXParseColorUINT32(const char* pszStr, REF(UINT32) rulValue)
{
    HX_RESULT retVal = HXR_OK;

    if (pszStr)
    {
        HXxColor cColor;
        retVal = HXParseColor(pszStr, cColor);
        if (SUCCEEDED(retVal))
        {
            rulValue = (UINT32) cColor;
#if defined(_WINDOWS)
            // HXParseColor produces 0x00BBGGRR on Windows - 
            // do the swap back to 0x00RRGGBB
            rulValue = ((rulValue & 0x00FF0000) >> 16)  |
                        (rulValue & 0x0000FF00)         |
                       ((rulValue & 0x000000FF) << 16);
#endif
        }
    }
    else
    {
        retVal = HXR_FAIL;
    }

    return retVal;
}

HX_RESULT HXParsePercent(const char* pszStr, REF(double) rdValue)
{
    HX_RESULT retVal = HXR_FAIL;

    if (pszStr)
    {
        char*  pEndPtr = NULL;
        double dVal    = strtod(pszStr, &pEndPtr);
        if (pEndPtr && *pEndPtr == '%')
        {
            rdValue = dVal;
            retVal  = HXR_OK;
        }
    }

    return retVal;
}

HX_RESULT HXParseUINT32(const char* pszStr, REF(UINT32) rulValue)
{
    HX_RESULT retVal = HXR_OK;

    if (pszStr)
    {
        INT32 lVal = 0;
        retVal     = HXParseDigit(pszStr, lVal);
        if (SUCCEEDED(retVal))
        {
            if (lVal >= 0)
            {
                rulValue = (UINT32) lVal;
            }
            else
            {
                retVal = HXR_FAIL;
            }
        }
    }
    else
    {
        retVal = HXR_FAIL;
    }

    return retVal;
}

HX_RESULT HXParseOpacity(const char* pszStr, REF(UINT32) rulValue)
{
    HX_RESULT retVal = HXR_OK;

    if (pszStr)
    {
        // First attempt to parse as a percent
        INT32  lValue   = 0;
        double dPercent = 0.0;
        retVal = HXParsePercent(pszStr, dPercent);
        if (SUCCEEDED(retVal))
        {
            // Scale from 0-100% to 0-255 with rounding
            lValue = (INT32) (dPercent * 255.0 / 100.0 + 0.5);
        }
        else
        {
            // It wasn't a percent, so try and parse as digits
            retVal = HXParseDigit(pszStr, lValue);
        }
        if (SUCCEEDED(retVal))
        {
            // Clamp to 0-255
            if (lValue < 0)   lValue = 0;
            if (lValue > 255) lValue = 255;
            // Assign the out parameter
            rulValue = (UINT32) lValue;
        }
    }
    else
    {
        retVal = HXR_FAIL;
    }

    return retVal;
}