/*
* Copyright (c) 2007-2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0""
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Implementation for PeninputLayoutControl
*
*/

//#include <e32base.h>
#include <AknIconUtils.h>
#include <w32std.h>
#include <AknsDrawUtils.h>
#include <eikenv.h>
#include <AknsConstants.h>
#include <AknUtils.h>
#include <featmgr.h>

#include "peninputlayoutvirtualkeyctrl.h"
#include "peninputlayoutvkb.h"
#include "peninputlayout.h"
#include "peninputpluginutils.h"
#include "peninputcmd.h"

_LIT( KKeyShiftCharacter, "\x2191");
_LIT( KKeyStarCharacter, "\x002a");

const TInt KDefaultKeyMargin = 10;

// ---------------------------------------------------------------------------
// CVirtualKeyCtrl::NewL
// Static factory creator
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
CVirtualKeyCtrl* CVirtualKeyCtrl::NewL(CVirtualKeyboard* aKeyboard,
                                                        CVirtualKey* aKeyInfo)
    {
    if(!aKeyInfo || !aKeyboard)
        return 0;
    
    CVirtualKeyCtrl* keyCtrl = new(ELeave) CVirtualKeyCtrl(aKeyboard,aKeyInfo);
    CleanupStack::PushL(keyCtrl);
    keyCtrl->ConstructL();
    CleanupStack::Pop();    
    return keyCtrl;    
    }

// ---------------------------------------------------------------------------
// CVirtualKeyCtrl::CVirtualKeyCtrl
// constuctor
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//    
CVirtualKeyCtrl::CVirtualKeyCtrl(CVirtualKeyboard* aKeyboard, CVirtualKey* aKeyInfo)
                                 :CFepUiBaseCtrl(aKeyInfo->Rect(), aKeyboard->UiLayout(),-1),
                                  iKeyInfo(aKeyInfo), iKeyboard(aKeyboard)
    {
    SetControlType(ECtrlVirtualKey);    
    //virtual key postion is kept as relative to key board, so we must change the 
    //key control's position relative to layout.
    Move(aKeyboard->Rect().iTl);
    
#ifdef RD_TACTILE_FEEDBACK     
    //register the key feedback area
    //UiLayout()->RegisterFeedbackArea(reinterpret_cast<TInt>(this),Rect());    
#endif // RD_TACTILE_FEEDBACK 
    
    aKeyInfo->iKeyCtrl = this;
    iScanCode = aKeyInfo->ScanCode();
    }

// ---------------------------------------------------------------------------
// CVirtualKeyCtrl::~CVirtualKeyCtrl
// destructor
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//    
CVirtualKeyCtrl::~CVirtualKeyCtrl()
    {
    //Never uncomment the following statement. When this control is deleted,
    //iKeyInfo may be already invalid!!!
    //iKeyInfo->iKeyCtrl = 0;
    
#ifdef RD_TACTILE_FEEDBACK     
    UiLayout()->DeRegisterFeedbackArea(reinterpret_cast<TInt>(this),Rect());            
#endif // RD_TACTILE_FEEDBACK     
    }
    
// ---------------------------------------------------------------------------
// CVirtualKeyCtrl::ConsructL
// 2nd phase constuctor
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//        
void CVirtualKeyCtrl::ConstructL()
    {
    BaseConstructL();
    
    //tap accuracy enhancement
    if( FeatureManager::FeatureSupported( KFeatureIdFfCapacitiveDisplay ))
        {
        EnableExtResponseArea( ETrue, TRect(TPoint(10,10),TSize(10,10)) );
        }
    }

// ---------------------------------------------------------------------------
// CVirtualKeyCtrl::DrawKeyText
// Draw key text
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//        
void CVirtualKeyCtrl::DrawKeyText(CFbsBitGc* aGc)  
    {
    TBool textlineset = EFalse;

    // if text line set
    for (TInt i = 0; i <= EPosLast; i++)
        {
        if (iKeyboard->TextLineLayoutSet(TVirtualKeyTextPos(i)))
            {
            textlineset = ETrue;

            if (iKeyInfo->KeyUnicodes(TVirtualKeyTextPos(i)) != KNullDesC)
                {
                TAknLayoutText textLayout;
                textLayout.LayoutText(GetRect(), 
                                      iKeyboard->TextLineLayout(TVirtualKeyTextPos(i)));
				TRgb color( KRgbBlack );  // sane default for nonskinned case			    
			    if ( AknsUtils::AvkonSkinEnabled() )
			        {
			        AknsUtils::GetCachedColor( UiLayout()->SkinInstance(),
				                               color, 
				                               KAknsIIDQsnTextColors, 
				                               iKeyboard->KeyTextColorGroup() );
			        }
			    
			    // replace the shift text to shift icon			        
				if( iKeyboard->ShiftIcon() &&
					iKeyInfo->KeyUnicodes(TVirtualKeyTextPos(i)) == KKeyShiftCharacter )
					{
					//CFbsBitGc* gc = GetGc();//static_cast<CFbsBitGc*>(BitGc());
					AknPenInputDrawUtils::DrawColorIcon( iKeyboard->ShiftIcon(),
														 *aGc,
														 textLayout.TextRect() );	
					}
				else if(iKeyboard->StarIcon() &&
						iKeyInfo->KeyUnicodes(TVirtualKeyTextPos(i)) == KKeyStarCharacter )
					{
					//CFbsBitGc* gc = static_cast<CFbsBitGc*>(BitGc());
					AknPenInputDrawUtils::DrawColorIcon( iKeyboard->StarIcon(),
														 *aGc,
														 textLayout.TextRect() );		
					}
				else				    
				    {
				    textLayout.DrawText(*aGc, iKeyInfo->KeyUnicodes(TVirtualKeyTextPos(i)), 
                                    EFalse, color);
				    }
                }
            }
        }

    if (!textlineset)
        {
		TAknLayoutText textLayout;
		textLayout.LayoutText(GetRect(), iKeyboard->iVKBTextLineLayout);
	    
	    //CFbsBitGc* gc = static_cast<CFbsBitGc*>(BitGc());    
	    
	    //charRect.Move(keyboardRect.iTl);
	    //if(iKeyInfo->Dimmed())
	    //    {        
	    //    gc->SetFadingParameters(iKeyboard->iFadingParamBlack, iKeyboard->iFadingParamWhite);
	    //    gc->SetFaded(ETrue);            
	    //    }
		TRgb color( KRgbBlack );  // sane default for nonskinned case			    
	    if ( AknsUtils::AvkonSkinEnabled() || 
	    	 iKeyboard->KeyTextColorGroup() != INVALID_COLOR_GROUP )
	        {
	        AknsUtils::GetCachedColor( UiLayout()->SkinInstance(),
		                               color, 
		                               KAknsIIDQsnTextColors, 
		                               iKeyboard->KeyTextColorGroup() );
	        }
	    else
    		{
			color = iKeyboard->iFontColor;
    		}
    		
    	if( iKeyInfo->Dimmed() )
			{			
			color = KRgbGray;	
			}	
    	if( iKeyInfo->DisplayUnicode() && iKeyInfo->DisplayUnicode()->Length() != 0)
    		{
    		textLayout.DrawText(*aGc, *iKeyInfo->DisplayUnicode(), EFalse, color);		
    		}
    	else
    		{
    		textLayout.DrawText(*aGc, iKeyInfo->KeyUnicodes(), EFalse, color);		
    		}		
    		
	    //if(iKeyInfo->Dimmed())
	    //    gc->SetFaded(EFalse);            
	    
    	}
    }

// ---------------------------------------------------------------------------
// CVirtualKeyCtrl::DrawDimKey
// Draw dimmed key
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//        
void CVirtualKeyCtrl::DrawDimKey()
    {
    CFbsBitGc* gc = static_cast<CFbsBitGc*>(BitGc());    
    TRect rect = Rect();
    TRect bmpRect(TPoint(0,0),rect.Size());    
    gc->Activate( BitmapDevice() );
                
    
    if(iVirtualKeyDrawInfo.iVKDimLeftImgID.iMajor && 
       iVirtualKeyDrawInfo.iVKDimMiddleImgID.iMajor &&
       iVirtualKeyDrawInfo.iVKDimRightImgID.iMajor)
        {
        TRect innerRect = Rect();
		innerRect.Shrink( 4, 0 );
		    
		AknPenInputDrawUtils::Draw3PiecesFrame(UiLayout()->SkinInstance(),
								   *gc,
								   Rect(),
								   innerRect,
								   iVirtualKeyDrawInfo.iVKDimLeftImgID,
								   iVirtualKeyDrawInfo.iVKDimMiddleImgID,
								   iVirtualKeyDrawInfo.iVKDimRightImgID);
        }
    else if (iKeyboard->IsIrregularKeyBoard())
        {
        DrawIrregularKey(EKeyStateDimmed, EKeyStateDimmedMask);
        }
    else if (iKeyboard->KeySkinId(EKeyBmpDim) != KAknsIIDNone)
        {
        TRect innerrect = rect;
        innerrect.Shrink( KDefaultKeyMargin, KDefaultKeyMargin );
        
        AknsDrawUtils::DrawFrame(UiLayout()->SkinInstance(),
                                 *gc,
                                 rect,
                                 innerrect,
                                 iKeyboard->KeySkinId(EKeyBmpDim),
                                 KAknsIIDDefault);
        }
    else if( iKeyboard->NonIrregularKeyBitmap( EKeyBmpDim ) )
    	{
        TRect srcRect(TPoint(0,0), iKeyboard->NonIrregularKeyBitmap( EKeyBmpDim )->SizeInPixels());
        DrawBmp(rect,
                srcRect,
                iKeyboard->NonIrregularKeyBitmap( EKeyBmpDim ),
                iKeyboard->NonIrregularKeyBitmap( EkeyBmpDimMask ),
                ETrue); 
    	}
    else if (iKeyboard->iDimKeyBmp)
        {
        TRect srcRect(TPoint(0,0),iKeyboard->iDimKeyBmp->SizeInPixels());
        DrawBmp(rect,srcRect,iKeyboard->iDimKeyBmp,
                                            iKeyboard->iDimKeyMaskBmp,ETrue);
        }    

    else
        {
        gc->SetFaded(ETrue);

        //use if keboard has background bitmap            
        if (iKeyboard->BackgroundBmp())
            {
            TRect srcRect = Rect();
            srcRect.Move(-iKeyboard->Rect().iTl);
            DrawBmp(Rect(),srcRect,iKeyboard->BackgroundBmp(),iKeyboard->BkMaskBmp());
            }
        else
            {
            //self draw background if background bitmap
            gc->SetBrushColor( BkColor());
            gc->SetPenColor( BkColor() );
            gc->SetBrushStyle( CGraphicsContext::ESolidBrush );                
            gc->DrawRect(rect);		                      
            }
        }
        
    gc->SetPenColor(KRgbBlack);
    gc->SetBrushStyle( CGraphicsContext::ENullBrush );    
    //Draw text again.
    DrawKeyText(gc); 
    }

// ---------------------------------------------------------------------------
// CVirtualKeyCtrl::DrawBmp
// Draw bitmap
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//        
void CVirtualKeyCtrl::DrawBmp(const TRect& aDestRect,const TRect& aSourceRect,
                                  const CFbsBitmap* aBmp,CFbsBitmap* aMask,
                                  TBool aInvertFlag)
    {
    CFbsBitGc* gc = static_cast<CFbsBitGc*>(BitGc());
    DrawBmp(gc,aDestRect,aSourceRect,aBmp,aMask,aInvertFlag);					     
    }

// ---------------------------------------------------------------------------
// CVirtualKeyCtrl::DrawBmp
// Draw bitmap
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//        
void CVirtualKeyCtrl::DrawBmp(CFbsBitGc* aGc, const TRect& aDestRect,const TRect& aSourceRect,
                                  const CFbsBitmap* aBmp,CFbsBitmap* aMask,
                                  TBool aInvertFlag)
    {
    if(aMask)
        {
        //TRect bmpRect(TPoint(0,0),aMask->SizeInPixels());
        aGc->DrawBitmapMasked(aDestRect,aBmp,aSourceRect,aMask,aInvertFlag);        
        }
    else
        {
        aGc->DrawBitmap(aDestRect,aBmp,aSourceRect);
        }                            
    }
    
// ---------------------------------------------------------------------------
// CVirtualKeyCtrl::DrawNormalStateKey
// Draw key in normal state
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//            
void CVirtualKeyCtrl::DrawNormalStateKey()
    {    
    CFbsBitGc* gc = static_cast<CFbsBitGc*>(BitGc());
 
    TRect rect = Rect();    
    TRect bmpRect(TPoint(0,0),rect.Size());
    
    if(iVirtualKeyDrawInfo.iVKLeftImgID.iMajor && 
       iVirtualKeyDrawInfo.iVKMiddleImgID.iMajor &&
       iVirtualKeyDrawInfo.iVKRightImgID.iMajor)
        {
        TRect innerRect = Rect();
		innerRect.Shrink( 4, 0 );
		    
		AknPenInputDrawUtils::Draw3PiecesFrame(UiLayout()->SkinInstance(),
								   *gc,
								   Rect(),
								   innerRect,
								   iVirtualKeyDrawInfo.iVKLeftImgID,
								   iVirtualKeyDrawInfo.iVKMiddleImgID,
								   iVirtualKeyDrawInfo.iVKRightImgID);
        }
    else if (iKeyboard->IsIrregularKeyBoard())
        {
        DrawIrregularKey(EKeyStateNormal, EKeyStateNormalMask);
        }
    else if (iKeyboard->KeySkinId(EKeyBmpNormal) != KAknsIIDNone)
        {
        TRect innerrect = rect;
        innerrect.Shrink( KDefaultKeyMargin, KDefaultKeyMargin );
        TBool bHasDrawn = EFalse;
        if(UiLayout()->NotDrawToLayoutDevice())
            {
            /*TBool ret = iKeyboard->PrepareKeyBmp(iKeyboard->NormalKeyBmp(),
                                    iKeyboard->NormalKeyDev(),
                                    rect,innerrect,
                                    iKeyboard->KeySkinId(EKeyBmpNormal), 
                                    KAknsIIDDefault,Rect());*/
            TBool ret = iKeyboard->PrepareNormalKeyBmp(rect,innerrect,Rect());                                    
            if(ret)
                {
                gc->BitBlt(rect.iTl,iKeyboard->NormalKeyBmp());
                bHasDrawn = ETrue;
                }
            }
        
        if(!bHasDrawn)
            {
	        AknsDrawUtils::DrawFrame(UiLayout()->SkinInstance(), 
	                                 *gc, 
	                                 rect, 
	                                 innerrect,
	                                 iKeyboard->KeySkinId(EKeyBmpNormal), 
	                                 KAknsIIDDefault); 
            }
        }
    else if( iKeyboard->NonIrregularKeyBitmap( EKeyBmpNormal ) )
    	{
        TRect srcRect(TPoint(0,0), 
                      iKeyboard->NonIrregularKeyBitmap( EKeyBmpNormal )->SizeInPixels());
        DrawBmp(rect,
                srcRect,
                iKeyboard->NonIrregularKeyBitmap( EKeyBmpNormal ),
                iKeyboard->NonIrregularKeyBitmap( EKeyBmpNormalMask ),
                ETrue); 
    	}
     
    else
        {
        gc->SetFaded(EFalse);

        //use if keboard has background bitmap            
        if (iKeyboard->BackgroundBmp())
            {
            TRect srcRect = Rect();
            srcRect.Move(-iKeyboard->Rect().iTl);
            DrawBmp(Rect(),srcRect,iKeyboard->BackgroundBmp(),iKeyboard->BkMaskBmp());
            }
        else
            {
            //self draw background if background bitmap
            gc->SetBrushColor( BkColor());
            gc->SetPenColor( BkColor() );
            gc->SetBrushStyle( CGraphicsContext::ESolidBrush );                
            gc->DrawRect(rect);		                      
            }
        }        
        
    gc->SetPenColor( KRgbBlack );
    gc->SetBrushStyle( CGraphicsContext::ENullBrush );    
    gc->SetFaded(EFalse);            
    DrawKeyText(gc);        
    }

CFbsBitGc* CVirtualKeyCtrl::GetGc()
    {
    if(UiLayout()->NotDrawToLayoutDevice())
        {
        //draw to highligh bitmap
        if(Keyboard()->Bitmap()->SizeInPixels() != Rect().Size())
            {
            Keyboard()->Bitmap()->Resize(Rect().Size());
            Keyboard()->HighlightDev()->Resize( Rect().Size());
                //gc must be adjusted
            Keyboard()->HighlightGc()->Activate(Keyboard()->HighlightDev());
            Keyboard()->HighlightGc()->Resized();
            }
        return Keyboard()->HighlightGc();
        }
    else
        return static_cast<CFbsBitGc*>(BitGc());
    }

// ---------------------------------------------------------------------------
// CVirtualKeyCtrl::DrawHighlightKey
// Draw key in highlight state
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//                
void CVirtualKeyCtrl::DrawHighlightKey()
    {    
    CFbsBitGc* gc = GetGc();
    if(UiLayout()->NotDrawToLayoutDevice())
        gc->Activate( Keyboard()->HighlightDev() );
    TRect rect = GetRect();

    TPoint bmpPos = rect.iTl;
    TRect bmpRect(TPoint(0,0),rect.Size());
   
    if(iVirtualKeyDrawInfo.iVKPressedLeftImgID.iMajor && 
       iVirtualKeyDrawInfo.iVKPressedMiddleImgID.iMajor &&
       iVirtualKeyDrawInfo.iVKPressedRightImgID.iMajor)
        {
        TRect innerRect = GetRect();
		innerRect.Shrink( 4, 0 );
		    
		AknPenInputDrawUtils::Draw3PiecesFrame(UiLayout()->SkinInstance(),
								   *gc,
								   GetRect(),
								   innerRect,
								   iVirtualKeyDrawInfo.iVKPressedLeftImgID,
								   iVirtualKeyDrawInfo.iVKPressedMiddleImgID,
								   iVirtualKeyDrawInfo.iVKPressedRightImgID);

        }
    else if (iKeyboard->IsIrregularKeyBoard())
        {
        DrawIrregularKey(EKeyStatePressed, EKeyStatePressedMask);
        }

    //do we have highlight background bmp for this key?
    else if (iKeyboard->KeySkinId(EKeyBmpHighlight) != KAknsIIDNone)
        {
        TRect innerrect = rect;

        innerrect.Shrink( KDefaultKeyMargin, KDefaultKeyMargin );
        TBool bHasDrawn = EFalse;
        if(UiLayout()->NotDrawToLayoutDevice())
            {
            /*TBool ret = iKeyboard->PrepareKeyBmp(iKeyboard->HighightKeyBmp(),
                                    iKeyboard->HighlightKeyDev(),
                                    rect,innerrect,
                                    iKeyboard->KeySkinId(EKeyBmpHighlight), 
                                    KAknsIIDDefault,Rect());*/
            TBool ret = iKeyboard->PrepareHighlightKeyBmp(rect,innerrect,Rect());                                    
            if(ret)
                {
                gc->BitBlt(rect.iTl,iKeyboard->HighightKeyBmp());
                bHasDrawn = ETrue;
                }
            }
        
        if(!bHasDrawn)
            {        
	        AknsDrawUtils::DrawFrame(UiLayout()->SkinInstance(), 
	                                 *gc, 
	                                 rect, 
	                                 innerrect,
	                                 iKeyboard->KeySkinId(EKeyBmpHighlight), 
	                                 KAknsIIDDefault); 
            }
        }
    else if( iKeyboard->NonIrregularKeyBitmap( EKeyBmpHighlight ) )
    	{
        TRect srcRect(TPoint(0,0), 
                      iKeyboard->NonIrregularKeyBitmap( EKeyBmpHighlight )->SizeInPixels());
        DrawBmp(gc, rect,
                srcRect,
                iKeyboard->NonIrregularKeyBitmap( EKeyBmpHighlight ),
                iKeyboard->NonIrregularKeyBitmap( EKeyBmpHighlightMask ),
                ETrue); 
    	}
    else if(iKeyInfo->HighlightBmpIndex() >= 0 && 
                 iKeyInfo->HighlightBmpIndex() < iKeyboard->iKeyHighLightBmpList.Count())
        {
        gc->DrawBitmap(rect,iKeyboard->iKeyHighLightBmpList[iKeyInfo->HighlightBmpIndex()]);
        }
    else //using fading
        {
        gc->SetFadingParameters(iKeyboard->iFadingParamBlack, iKeyboard->iFadingParamWhite);
        gc->SetFaded(ETrue);            

        if(iKeyboard->BackgroundBmp())//use keyboard background bitmap
            {
            gc->BitBlt(bmpPos, iKeyboard->BackgroundBmp(), iKeyInfo->Rect());                
            }
        else //draw background if not background bitmap
            {              
            gc->SetBrushColor( BkColor());
            gc->SetPenColor( BkColor() );
            gc->SetBrushStyle( CGraphicsContext::ESolidBrush );                
            gc->DrawRect(rect);
            }
        }                    
 
    gc->SetPenColor( KRgbBlack );

    gc->SetBrushStyle( CGraphicsContext::ENullBrush );    
    gc->SetFaded(EFalse);       
    if(UiLayout()->NotDrawToLayoutDevice())
        {
		DrawKeyText(Keyboard()->HighlightGc());
        UpdateChangedArea(ETrue);
		}
    else
        {
		DrawKeyText(gc);
		}   

    }
    
// ---------------------------------------------------------------------------
// CVirtualKeyCtrl::Draw
// Draw key
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//                    
void CVirtualKeyCtrl::Draw()
    {
    if(!AbleToDraw())
    	return;    
    
    CFbsBitGc* gc = static_cast<CFbsBitGc*>(BitGc());
    
    //mask bitmaps
  	DrawOpaqueMaskBackground();  
        
    // ----- draw bitmaps -----
    gc->Activate( BitmapDevice() );                
    
/*    if (iScanCode == -1 && !iKeyInfo->Dimmed() && iKeyboard)
    	{
    	iKeyboard->DimKey(iKeyInfo, ETrue);
    	}*/

    if(iKeyInfo->Dimmed())
        {
        DrawDimKey();
        return;
        }
    
    if(iKeyInfo->Latched()||(PointerDown()&&!iKeyInfo->IsLatchKey()))
        {        
        DrawHighlightKey();
        
// remove DrawBubble() into HandlePointerDownEventL()
// to avoid showing more than one bubble at the same time.        
//        iKeyboard->DrawBubble(iKeyInfo);
        }
    else
        {                
        DrawNormalStateKey();
        }
    }
    
// ---------------------------------------------------------------------------
// CVirtualKeyCtrl::HandlePointerDownEventL
// Handle pointer down event
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//                    
CFepUiBaseCtrl* CVirtualKeyCtrl::HandlePointerDownEventL(const TPoint& aPoint)
    {
    //do nothing if key is dimmed.
    if(iKeyInfo->Dimmed())
        return this;
    
    CFepUiBaseCtrl::HandlePointerDownEventL(aPoint);
    
    //draw key new state
    iKeyboard->DrawBubble(iKeyInfo);
    if(UiLayout()->NotDrawToLayoutDevice())
        {
        if( !(iKeyInfo->Dimmed()) && (iKeyInfo->Latched() || (PointerDown()&&!iKeyInfo->IsLatchKey())) )
            {        
            DrawHighlightKey();
            }
		else
		    {
			ReDraw();
			}	
        }
    else
        {
        ReDraw();
        UpdateArea( Rect() );
        }         	
    UpdateArea( Rect() );

    if(iKeyInfo->IsLatchKey())
        {
        // Only set latch status, not generate event for latch key
        iKeyInfo->SetLatched(!iKeyInfo->Latched());       
        }
    else
        {
        ReportKeyEvent(GetKeyEventType(EVirtualKeyControlDown));
        }     
 
    return this;
    }

// ---------------------------------------------------------------------------
// CVirtualKeyCtrl::HandlePointerUpEventL
// Handle pointer up event
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
CFepUiBaseCtrl* CVirtualKeyCtrl::HandlePointerUpEventL(const TPoint& aPoint)
    {
    if(!PointerDown() || iKeyInfo->Dimmed())
        {
        return this;
        }
    CFepUiBaseCtrl::HandlePointerUpEventL(aPoint);
    
    iKeyboard->ClearBubble(ETrue);
    
	TControlEvent  eventType = GetKeyEventType(EVirtualKeyControlUp);
    if(iKeyInfo->IsLatchKey())
        {
        // When key up, latch key will generate event. 
        // When key down, latch key won't generate event.
        eventType = iKeyInfo->Latched() ? EEventVirtualKeyLatched : EEventVirtualKeyUnLatched;
        }     
    if(UiLayout()->NotDrawToLayoutDevice())
        {
        //no need to draw again, just remove the highlight bitmap
        UpdateChangedArea(EFalse);
		Draw();
        }
    else
        {
        ReDraw();
        UpdateAreaImmed( Rect() );
        }
    ReportKeyEvent(eventType); 
    
    
    //Advanced tactile feedback REQ 417-47932
	#ifdef RD_TACTILE_FEEDBACK
    if (UiLayout()->SupportTactileFeedback())
    	{
   		UiLayout()->DoTactileFeedback(ETouchFeedbackSensitiveInput, ETrue, EFalse);
        }
	#endif // RD_TACTILE_FEEDBACK 
    return this;
    }
	
// ---------------------------------------------------------------------------
// CVirtualKeyCtrl::HandlePointerEnter
// Handle pointer enter event
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CVirtualKeyCtrl::HandlePointerEnter(const TPoint& aPoint)
    {
    //do nothing if key is dimmed.
    if(iKeyInfo->Dimmed())
        return;
    
    CFepUiBaseCtrl::HandlePointerEnter(aPoint);
    if(iKeyInfo->IsLatchKey())
        {
        iKeyInfo->SetLatched(!iKeyInfo->Latched());       
        }
        
    iKeyboard->DrawBubble(iKeyInfo);    
    ReDraw();
    if(UiLayout()->NotDrawToLayoutDevice())
        {
        UpdateChangedArea(ETrue);
        }
    else
        UpdateArea( Rect() );
      
    }

// ---------------------------------------------------------------------------
// CVirtualKeyCtrl::HandlePointerLeave
// Handle pointer left event
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CVirtualKeyCtrl::HandlePointerLeave(const TPoint& aPoint)
    {    
    //do nothing if key is dimmed.
    if(iKeyInfo->Dimmed())
        return;
    
    CFepUiBaseCtrl::HandlePointerLeave(aPoint);
    if(iKeyInfo->IsLatchKey())
        {
        iKeyInfo->SetLatched(!iKeyInfo->Latched());       
        }
        
    iKeyboard->ClearBubble(ETrue);
    if(UiLayout()->NotDrawToLayoutDevice())
        {
        UpdateChangedArea(EFalse);
        }
    else
        {
        ReDraw();
        UpdateArea( Rect() );
        }
	
#ifdef RD_TACTILE_FEEDBACK
    if ( iKeyboard->GowithPointerDown() )
		{
	    
		if (UiLayout()->SupportTactileFeedback())
			{
			if (!Hiden())
				{				
				UiLayout()->DoTactileFeedback(ETouchFeedbackCharacterInputButton, ETrue, EFalse);				
				}
			}
		}
#endif //RD_TACTILE_FEEDBACK
    }

void CVirtualKeyCtrl::CancelPointerDownL()
	{
	CFepUiBaseCtrl::CancelPointerDownL();
	iKeyboard->ClearBubble(ETrue);
    if(UiLayout()->NotDrawToLayoutDevice())
        {
        UpdateChangedArea(EFalse);
        }
    else
        {	
        ReDraw();
        UpdateArea( Rect() );
        }
	}
// ---------------------------------------------------------------------------
// CVirtualKeyCtrl::ReDraw
// Redraw and updates the key
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//    
void CVirtualKeyCtrl::ReDraw()
    {
    if(UiLayout()->NotDrawToLayoutDevice())
        {
        if(iKeyInfo->Latched()||(PointerDown()&&!iKeyInfo->IsLatchKey()))
            {        
            DrawHighlightKey();
            UpdateChangedArea(ETrue);
            }
		else
            {
			Draw();
			UpdateArea(Rect(), EFalse);
			}		
        }
    else
        {
        Draw();        
        UpdateArea(Rect(), EFalse);
        }    
    }
    
// ---------------------------------------------------------------------------
// CVirtualKeyCtrl::ReportKeyEvent
// Report current key event
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//   
void CVirtualKeyCtrl::ReportKeyEvent(TControlEvent aEventType)
    {
    if (iKeyInfo->ScanCode() == 0xffffffff ||
        iKeyInfo->ScanCode() == 0xffff)
    	{
    	return;	
    	}

    TVirtualKeyEventData eventData;

    eventData.iKeyEvent.iCode = iKeyInfo->KeyCode();
    eventData.iKeyEvent.iScanCode = iKeyInfo->ScanCode();
    
    TInt unicodeidx;

    if (iKeyInfo->UnicodesListEmpty(unicodeidx))
        {
        eventData.iKeyData.Set(iKeyInfo->KeyUnicodes());
        }
    else
        {
        eventData.iKeyData.Set(iKeyInfo->KeyUnicodes(TVirtualKeyTextPos(unicodeidx)));
        }    
    eventData.iKey = iKeyInfo;
    TPtrC eventDataPtr;
    eventDataPtr.Set(reinterpret_cast<TUint16*>(&eventData),sizeof(eventData)/sizeof(TUint16));
    
    iKeyboard->ReportEvent(aEventType,eventDataPtr);	    
    }
    
// ---------------------------------------------------------------------------
// CVirtualKeyCtrl::GetKeyEventType
// Convert event type
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//       
TControlEvent CVirtualKeyCtrl::GetKeyEventType(TVirtualKeyEventType aEvent)
    {
    TControlEvent event = EEventVirtualKeyUp;
    switch(aEvent)
        {
        case EVirtualKeyControlUp:
            event = EEventVirtualKeyUp;
            break;
        case EVirtualKeyControlDown:
            event = EEventVirtualKeyDown;
            break;
        default:
            __ASSERT_DEBUG(EFalse, User::Panic(_L("peninputserver"), EUiLayoutBadEvent));    
        }
    return event;
    }

TBool CVirtualKeyCtrl::Contains(const TPoint& aPt)
    {
    if  (!CFepUiBaseCtrl::Contains(aPt))   // OR:  if (!iRect.Contains(aPt))
        {
        return EFalse;
        }
    
    if (iKeyboard->IsIrregularKeyBoard())
        {
        return MaskBmpContains(aPt);    
        }
        
    return ETrue; 
    }

TBool CVirtualKeyCtrl::MaskBmpContains(const TPoint& aPt)
    {
    // judge if mask bitmap contains a point
    TRgb ptColor;

    // map aPt to maskbmp's point
    TPoint ptInBmp = TPoint(aPt.iX - iRect.iTl.iX, aPt.iY - iRect.iTl.iY);

    CFbsBitmap* maskbmp = MaskBmp();
    if (!maskbmp)
        {
        return EFalse;
        }

       //  before following call, when mask bitmap created, you must call IMPORT_C static void DisableCompression( CFbsBitmap* aBitmap ); in akniconutils.h to make sure following call not crash
   maskbmp->GetPixel(ptColor, ptInBmp);    

    return (ptColor != KRgbBlack);
    }

CFbsBitmap* CVirtualKeyCtrl::MaskBmp()  // there may be other method to get mask bitmap
    {
    if (iKeyInfo->Dimmed())
        {
        return iKeyboard->IrregularKeyBitmap(iKeyInfo->IrregualrKeyType(),EKeyStateDimmedMask);
        }

    if (PointerDown() || iKeyInfo->Latched())
        {
        return iKeyboard->IrregularKeyBitmap(iKeyInfo->IrregualrKeyType(),EKeyStatePressedMask);
        }
    return iKeyboard->IrregularKeyBitmap(iKeyInfo->IrregualrKeyType(),EKeyStateNormalMask);
    }
 
 void CVirtualKeyCtrl::DrawIrregularKey(TVirtualKeyIrregularKeyState aKeyState, 
                                        TVirtualKeyIrregularKeyState aKeyStateMask)
    {
    TRect rect = Rect();
        
    if( rect.IsEmpty()	)    
        {
        return;
        }
    TSize bitmapSize = 
             iKeyboard->IrregularKeyBitmap(iKeyInfo->IrregualrKeyType(),aKeyState)->SizeInPixels();
    
    
    TRect srcRect(TPoint(0,0), bitmapSize);

    DrawBmp(rect,
            srcRect,
            iKeyboard->IrregularKeyBitmap(iKeyInfo->IrregualrKeyType(),aKeyState),
            iKeyboard->IrregularKeyBitmap(iKeyInfo->IrregualrKeyType(),aKeyStateMask),
            ETrue);

    }
 
void CVirtualKeyCtrl::SetVirtualKeyImgID(TVirtualKeyDrawInfo aVirtualKeyDrawInfo)
    {
    iVirtualKeyDrawInfo = aVirtualKeyDrawInfo;
    }
    
//implementation for class CVirtualRawKeyCtrl
// ---------------------------------------------------------------------------
// CVirtualRawKeyCtrl::NewL
// Factory function
// (other items were commented in a header).
// ---------------------------------------------------------------------------
// 
CVirtualRawKeyCtrl* CVirtualRawKeyCtrl::NewL(CVirtualKeyboard* aKeyboard,
                                                          CVirtualKey* aKeyInfo)
    {
    if(!aKeyInfo)
        return 0;
    
    CVirtualRawKeyCtrl* keyCtrl = 
                            new(ELeave) CVirtualRawKeyCtrl(aKeyboard,aKeyInfo);
    CleanupStack::PushL(keyCtrl);
    keyCtrl->ConstructL();
    CleanupStack::Pop();    
    return keyCtrl;        
    }
   
// ---------------------------------------------------------------------------
// CVirtualRawKeyCtrl::CVirtualRawKeyCtrl
// Constructor
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//     
CVirtualRawKeyCtrl::CVirtualRawKeyCtrl(CVirtualKeyboard* aKeyboard,
                                                        CVirtualKey* aKeyInfo)
                                      :CVirtualKeyCtrl(aKeyboard,aKeyInfo)
    {
    SetControlType(ECtrlVirtualItutKey);
    }
    
// ---------------------------------------------------------------------------
// CVirtualRawKeyCtrl::GetKeyEventType
// Convert key event type
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//         
TControlEvent CVirtualRawKeyCtrl::GetKeyEventType(TVirtualKeyEventType aEvent)
    {
    TControlEvent event = EEventVirtualKeyUp;
    switch(aEvent)
        {
            case EVirtualKeyControlUp:
                event = EEventRawKeyUpEvent;
                break;
            case EVirtualKeyControlDown:
                event = EEventRawKeyDownEvent;
                break;
            default:
                __ASSERT_DEBUG(EFalse, User::Panic(_L("peninputserver"), EUiLayoutBadEvent));    
        }
    return event;
    }
    
// ---------------------------------------------------------------------------
// CVirtualRawKeyCtrl::CancelPointerDownL
// Handle cancel pointer down event
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//             
void CVirtualRawKeyCtrl::CancelPointerDownL()
    {
    CFepUiBaseCtrl::CancelPointerDownL();

    //simulates key up event
    ReportKeyEvent(EEventRawKeyUpEvent);
    }
    
// ---------------------------------------------------------------------------
// CVirtualRawKeyCtrl::HandlePointerLeave
// Handle pointer left event
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CVirtualRawKeyCtrl::HandlePointerLeave(const TPoint& aPoint)
    {    
    if(UiLayout()->NotDrawToLayoutDevice())
        {
        UpdateChangedArea(EFalse);
        }
    TRawEvent event;
    event.Set(TRawEvent::EButton1Up,aPoint.iX,aPoint.iY);
    
    SimulateRawEvent(event);
    
	// Advanced tactile feedback REQ 417-47932
#ifdef RD_TACTILE_FEEDBACK
	if (UiLayout()->SupportTactileFeedback())
		{		
		if (!VirtualKey()->Dimmed() && !Hiden())
			{
			UiLayout()->DoTactileFeedback(ETouchFeedbackSensitiveInput, ETrue, EFalse);
			}
        }
#endif //RD_TACTILE_FEEDBACK     
	}

TRect CVirtualKeyCtrl::GetRect()
    {
    TRect r(Rect());
    if(UiLayout()->NotDrawToLayoutDevice())
        {
		if(iKeyInfo->Latched()||(PointerDown()&&!iKeyInfo->IsLatchKey()))
		    {
			r.Move(-r.iTl.iX, -r.iTl.iY);
			}
        }
    return r;
    }
	
void CVirtualKeyCtrl::UpdateChangedArea(TBool aFlag)
    {
    struct SData
        {
    	TUint32 ctrl;
        TBool flag;
        CFbsBitmap* bmp;
        TRect pos;
        } data;
        
    data.ctrl = (TUint32)this;
    data.flag = aFlag;
    data.bmp = Keyboard()->Bitmap();//aFlag ? Keyboard()->iBitmap : 0;
    data.pos = Rect();
    TPtrC ptr;
    ptr.Set(reinterpret_cast<const TUint16*>(&data),sizeof(data)/sizeof(TUint16));
    
    UiLayout()->SignalOwner(ESignalUpdateChangedArea,ptr);
    }
//end of file
