lcdcclass.cpp

Microsoft WinCE 6.0 BSP FINAL release source code for use with the i.MX27ADS TO2 WCE600_FINAL_MX27_S

    if(dwStatus == ERROR_SUCCESS)
    {
        DWORD dwType, dwSize;
        dwSize = sizeof(m_szGuidClass);
        dwStatus = RegQueryValueEx(hk, _T("DisplayPowerClass"), NULL, &dwType, (LPBYTE)m_szGuidClass, &dwSize);
        if(dwStatus == ERROR_SUCCESS && dwType == REG_SZ)
        {
            // got a guid string, convert it to a guid
            fOk = ConvertStringToGuid(m_szGuidClass, &gTemp);
            DEBUGCHK(fOk);
        }

        // release the registry key
        RegCloseKey(hk);
    }

    // figure out what device name to advertise
    if(fOk)
    {
        fOk = GetModuleFileName(hInst, m_szDevName, sizeof(m_szDevName) / sizeof(m_szDevName[0]));
        DEBUGCHK(fOk);
    }

    // now advertise the interface
    if(fOk)
    {
        fOk = AdvertiseInterface(&gTemp, m_szDevName, TRUE);
        DEBUGCHK(fOk);
    }

    return fOk;
}

//------------------------------------------------------------------------------
//
//  FUNCTION:       SetDisplayPower
//
//  DESCRIPTION:    This function sets the display hardware according 
//                  to the desired video power state. Also updates
//                  current device power state variable.
//
//  PARAMETERS:     vps - desired video power state
//  
//  RETURNS:        None
//
//------------------------------------------------------------------------------
void LcdcClass::SetDisplayPower(CEDEVICE_POWER_STATE dx)
{
    switch(dx)
    {
        case D0:
            if(m_Dx != dx)
            {
                // Turn off graphic window first
                if(m_bGraphicWindowRunning)
                    INSREG32BF(&m_pLCDC->GWCR, LCDC_GWCR_GWE, 0);
            
                // wait for beginning of next frame
                m_pLCDC->IER |= CSP_BITFMASK(LCDC_IER_EOF_EN);
                while( !( m_pLCDC->ISR & CSP_BITFMASK(LCDC_ISR_EOF)) );

                // memcpy((PVOID)m_pLinearVideoMem, (PVOID)m_pBlankVideoMem, m_VideoFrameSize);
                // wait for screen refresh.
                while( !( m_pLCDC->ISR & CSP_BITFMASK(LCDC_ISR_EOF)) );
                while( !( m_pLCDC->ISR & CSP_BITFMASK(LCDC_ISR_EOF)) );
                while( !( m_pLCDC->ISR & CSP_BITFMASK(LCDC_ISR_EOF)) );

                m_pLCDC->IER &= ~CSP_BITFMASK(LCDC_IER_EOF_EN);

                // turn on lcd panel just in case
                BSPTurnOnLCD();
                m_Dx = D0;
            }
            break;
            
        case D1:
        case D2:
        case D3:
        case D4:
            if(m_Dx != D4)
            {
                m_pLCDC->IER |= CSP_BITFMASK(LCDC_IER_EOF_EN);

                // wait for beginning of next frame
                while( !( m_pLCDC->ISR & CSP_BITFMASK(LCDC_ISR_EOF)) );


                // backup the frame buffer to blank buffer
                // memcpy((PVOID)m_pBlankVideoMem, (PVOID)m_pLinearVideoMem, m_VideoFrameSize);
                // clear the frame buffer
                // memset((PVOID)m_pLinearVideoMem, 0xFF, m_VideoFrameSize);
                // Turn on graphic window
                if(m_bGraphicWindowRunning)
                    INSREG32BF(&m_pLCDC->GWCR, LCDC_GWCR_GWE, 1);

                // wait for screen refresh
                while( !( m_pLCDC->ISR & CSP_BITFMASK(LCDC_ISR_EOF)) );
                while( !( m_pLCDC->ISR & CSP_BITFMASK(LCDC_ISR_EOF)) );
                while( !( m_pLCDC->ISR & CSP_BITFMASK(LCDC_ISR_EOF)) );

                m_pLCDC->IER &= ~CSP_BITFMASK(LCDC_IER_EOF_EN);

                // turn off lcd panel
                BSPTurnOffLCD();
                m_Dx = D4;
            }
            break;

        default:
            break;
    }
}

//------------------------------------------------------------------------------
//
//  FUNCTION:       PmToVideoPowerState
//
//  DESCRIPTION:    This function maps between power manager power 
//                  states and video ioctl power states.
//
//  PARAMETERS:     dx - desired power manager device power state
//  
//  RETURNS:        corresponding video ioctl power state
//
//------------------------------------------------------------------------------
VIDEO_POWER_STATE LcdcClass::PmToVideoPowerState(CEDEVICE_POWER_STATE dx)
{
    VIDEO_POWER_STATE vps;

    switch(dx)
    {
        // turn the display on
        case D0:
            vps = VideoPowerOn;
            break;

        // if asked for a state we don't support, go to the next lower one
        case D1:        
        case D2:
        case D3:
        case D4:
            vps = VideoPowerOff;
            break;

        default:
            DEBUGMSG(GPE_ZONE_ERROR, (L"PmToVideoPowerState: mapping unknown PM state %d to VideoPowerOn\r\n", dx));
            vps = VideoPowerOn;
            break;
    }
    return vps;
}

//------------------------------------------------------------------------------
//
//  FUNCTION:       VideoToPmPowerState
//
//  DESCRIPTION:    This function maps between video power states 
//                  to PM power states.
//
//  PARAMETERS:     vps - desired video power state
//  
//  RETURNS:        corresponding PM device power state
//
//------------------------------------------------------------------------------
CEDEVICE_POWER_STATE LcdcClass::VideoToPmPowerState(VIDEO_POWER_STATE vps)
{
    CEDEVICE_POWER_STATE dx;

    switch(vps)
    {
        case VideoPowerOn:
            dx = D0;
            break;

        case VideoPowerStandBy:
        case VideoPowerSuspend:
        case VideoPowerOff:
            dx = D4;
            break;

        default:
            dx = D0;
            DEBUGMSG(GPE_ZONE_WARNING, (L"VideoToPmPowerState: mapping unknown video state %d to pm state %d\r\n",
                     vps, dx));
            break;
    }

    return dx;
}

//------------------------------------------------------------------------------
//
//  FUNCTION:       ConvertStringToGuid
//
//  DESCRIPTION:    This converts a string into a GUID.
//
//  PARAMETERS:     
//                  pszGuid - pointer to GUID in string format
//                  pGuid - pointer to GUID struct for output
//  
//  RETURNS:        returns TRUE if the conversion was successful
//
//------------------------------------------------------------------------------
BOOL LcdcClass::ConvertStringToGuid(LPCTSTR pszGuid, GUID *pGuid)
{
    UINT Data4[8];
    int  Count;
    BOOL fOk = FALSE;
    TCHAR *pszGuidFormat = _T("{%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}");

    DEBUGCHK(pGuid != NULL && pszGuid != NULL);
    __try
    {
        if (_stscanf(pszGuid, pszGuidFormat, &pGuid->Data1, 
            &pGuid->Data2, &pGuid->Data3, &Data4[0], &Data4[1], &Data4[2], &Data4[3], 
            &Data4[4], &Data4[5], &Data4[6], &Data4[7]) == 11)
        {
            for(Count = 0; Count < (sizeof(Data4) / sizeof(Data4[0])); Count++)
            {
                        pGuid->Data4[Count] = (UCHAR) Data4[Count];
            }
        }
        fOk = TRUE;
    }
    __except(EXCEPTION_EXECUTE_HANDLER)
    {
    }

    return fOk;
}

//------------------------------------------------------------------------------
//
//  FUNCTION:       GetRotateModeFromReg
//
//  DESCRIPTION:    This function is used to read the registry to get the initial 
//                  rotation angle. 
//
//  PARAMETERS:     
//              
//  
//  RETURNS:        returns default rotation angle
//
//------------------------------------------------------------------------------
int LcdcClass::GetRotateModeFromReg()
{
    HKEY hKey;
	int RotateMode = DMDO_0;
    if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("SYSTEM\\GDI\\ROTATION"),0,0, &hKey))
    {
        DWORD dwSize, dwAngle, dwType = REG_DWORD;
        dwSize = sizeof(DWORD);
        if (ERROR_SUCCESS == RegQueryValueEx(hKey, 
                                               TEXT("ANGLE"), 
                                               NULL, 
                                               &dwType,
                                               (LPBYTE)&dwAngle,
                                               &dwSize))
        {
            switch (dwAngle)
            {
            case 0:
                RotateMode = DMDO_0;
				break;
            case 90: 
				RotateMode = DMDO_90;
				break;
            case 180:
                RotateMode = DMDO_180;
				break;
            case 270:
                RotateMode = DMDO_270;
				break;
            default:
                RotateMode = DMDO_0;
				break;
            }
        }

        RegCloseKey(hKey);
    }
    
    return RotateMode;
}

//------------------------------------------------------------------------------
//
//  FUNCTION:       SetRotateParms
//
//  DESCRIPTION:    This function is used to set up the screen width and height 
//                  based on the current rotation angle.
//
//  PARAMETERS:     
//  
//  RETURNS:        
//
//------------------------------------------------------------------------------
void LcdcClass::SetRotateParms()
{
    int iswap;

        switch(m_iRotate)
        {
            case DMDO_0:
            case DMDO_180:
            m_nScreenHeightSave = m_nScreenHeight;
            m_nScreenWidthSave = m_nScreenWidth;
            break;
        case DMDO_90:
        case DMDO_270:
            iswap = m_nScreenHeight;
            m_nScreenHeight = m_nScreenWidth;
            m_nScreenWidth = iswap;
                m_nScreenHeightSave = m_nScreenWidth;
                m_nScreenWidthSave = m_nScreenHeight;
            break;
        default:
            m_nScreenHeightSave = m_nScreenHeight;
            m_nScreenWidthSave = m_nScreenWidth;
            break;
        }
        
    return;
}

//------------------------------------------------------------------------------
//
//  FUNCTION:       DynRotate
//
//  DESCRIPTION:    This function Rotates the screen when DrvEscape gets a 
//                  DRVESC_SETSCREENROTATION message.
//
//  PARAMETERS:     
//                  int angle - angle to rotate
//
//  RETURNS:        
//                  DISP_CHANGE_SUCCESSFUL
//
//------------------------------------------------------------------------------
LONG LcdcClass::DynRotate(int angle)
{
    GPESurfRotate *pSurf = (GPESurfRotate *)m_pPrimarySurface;

    if (angle == m_iRotate)
        return DISP_CHANGE_SUCCESSFUL;

    m_iRotate = angle;

    switch(m_iRotate)
        {
            case DMDO_0:
            case DMDO_180:
               m_nScreenHeight = m_nScreenHeightSave;
               m_nScreenWidth = m_nScreenWidthSave;
               break;
            case DMDO_90:
            case DMDO_270:
               m_nScreenHeight = m_nScreenWidthSave;
               m_nScreenWidth = m_nScreenHeightSave;
               break;
		   default:
               m_nScreenHeight = m_nScreenHeightSave;
               m_nScreenWidth = m_nScreenWidthSave;
               break;
        }

    m_pMode->width = m_nScreenWidth;
    m_pMode->height = m_nScreenHeight;
    pSurf->SetRotation(m_nScreenWidth, m_nScreenHeight, angle);

    return DISP_CHANGE_SUCCESSFUL;
}

//------------------------------------------------------------------------------
//
//  FUNCTION:       CursorOn
//
//  DESCRIPTION:    This function is used to support software cursor.
//
//  PARAMETERS:     
//  
//  RETURNS:        
//
//------------------------------------------------------------------------------
VOID LcdcClass::CursorOn (void)
{
    UCHAR   *ptrScreen = (UCHAR*)m_pPrimarySurface->Buffer();
    UCHAR   *ptrLine;
    UCHAR   *cbsLine;
    int     x, y;

    if (!m_CursorForcedOff && !m_CursorDisabled && !m_CursorVisible)
    {
        RECTL cursorRectSave = m_CursorRect;
        int   iRotate;
        RotateRectl(&m_CursorRect);
        for (y = m_CursorRect.top; y < m_CursorRect.bottom;