diff -r 000000000000 -r eb1f2e154e89 textinput/peninputhwrtrui/src/truihwrbox.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/textinput/peninputhwrtrui/src/truihwrbox.cpp Tue Feb 02 01:02:04 2010 +0200 @@ -0,0 +1,1374 @@ +/* +* Copyright (c) 2009 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: Implement of class CTruiHwrBox +* +*/ + + +// INCLUDE FILES +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "truihwrbox.h" +#include "truihwrboxobserver.h" +#include "truiappui.h" +#include "truiappui.h" +#include "truiengine.h" + +#ifdef __WINS__ +static const TInt KWritePeriod = 1500000; +#else +static const TInt KWritePeriod = 1000000; +#endif + +#ifdef __WINS__ +static const TInt KDrawSpeed = 30000; +#else +static const TInt KDrawSpeed = 30000; +#endif + +const TInt KFirstPoint = -1; +const TSize KGuideLinePenSize = TSize( 1, 1 ); +const TSize KLinePenSize = TSize( 4, 4 ); +const TInt KFirstEventDelay = 0; + +_LIT( KTRUIICONSFILENAME, "\\resource\\apps\\trui_icons.mif" ); + +const TInt KTopGuideLineIndex = 0; +const TInt KBottomGuideLineIndex = 1; + +const TInt KGuideLineWidthRadio = 10; + +// ======== MEMBER FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// Two-phased constructor. +// --------------------------------------------------------------------------- +// +CTruiHwrBox* CTruiHwrBox::NewL( CCoeControl* aParent, + MTruiHwrBoxObserver* aHwrBoxObserver, + MAknsControlContext* aBgContext ) + { + CTruiHwrBox* self = CTruiHwrBox::NewLC( aParent, aHwrBoxObserver, + aBgContext ); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// Two-phased constructor. +// --------------------------------------------------------------------------- +// +CTruiHwrBox* CTruiHwrBox::NewLC( CCoeControl* aParent, + MTruiHwrBoxObserver* aHwrBoxObserver, + MAknsControlContext* aBgContex ) + { + CTruiHwrBox* self = new ( ELeave ) CTruiHwrBox(); + CleanupStack::PushL( self ); + self->ConstructL( aParent, aHwrBoxObserver, + aBgContex ); + return self; + } + +// ----------------------------------------------------------------------------- +// CTruiHwrBox::CTruiHwrBox() +// C++ default constructor can NOT contain any code, that might leave. +// ----------------------------------------------------------------------------- +// +CTruiHwrBox::CTruiHwrBox() + { + // No implementation required + } + +// ----------------------------------------------------------------------------- +// CTruiHwrBox::ConstructL() +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CTruiHwrBox::ConstructL( CCoeControl* aParent, + MTruiHwrBoxObserver* aHwrBoxObserver, + MAknsControlContext* aBgContext ) + { + if ( aParent ) + { + SetContainerWindowL( *aParent ); + } + else + { + CreateWindowL(); + } + + SetHwrBoxObserver( aHwrBoxObserver ); + + // Create tooltip + iTooltip = CAknInfoPopupNoteController::NewL(); + iTooltip->SetTooltipModeL( ETrue ); + iTooltip->AddObserverL( *this ); + + iBoxState = ENewModelStop; + iTimeToSave = CPeriodic::NewL( CActive::EPriorityHigh ); // neutral priority + iTimeToDrawNext = CPeriodic::NewL( CActive::EPriorityStandard ); // neutral priority + + iPointArrayDraw.Reset(); + iPointArrayModel.Reset(); + + LoadBorderBitmapsL(); + LoadShadowBitmapsL(); + LoadGuideLineBitmapsL(); + + EnableDragEvents(); + + iBgContext = static_cast( aBgContext ); + + } + +// ----------------------------------------------------------------------------- +// CTruiHwrBox::~CTruiHwrBox() +// Destructor. +// ----------------------------------------------------------------------------- +// +CTruiHwrBox::~CTruiHwrBox() + { + if ( iTooltip ) + { + iTooltip->RemoveObserver( *this ); + } + HideInfoPopupNote(); + + // Cancel and delete timer. + if ( iTimeToSave ) + { + iTimeToSave->Cancel(); + delete iTimeToSave; + } + + if ( iTimeToDrawNext ) + { + iTimeToDrawNext->Cancel(); + delete iTimeToDrawNext; + } + + iPointArrayDraw.Close(); + iPointArrayModel.Close(); + delete iTooltip; + + iBorderBitmaps.ResetAndDestroy(); + iBorderBitmapMasks.ResetAndDestroy(); + iBorderLayout.Close(); + + iShadowBitmaps.ResetAndDestroy(); + iShadowBitmapMasks.ResetAndDestroy(); + iShadowLayout.Close(); + + iGuideLineBitmaps.ResetAndDestroy(); + iGuideLineBitmapMasks.ResetAndDestroy(); + iGuideLineLayout.Close(); + } + +// ----------------------------------------------------------------------------- +// Draws control to given area +// ----------------------------------------------------------------------------- +// +void CTruiHwrBox::Draw( const TRect& /*aRect*/ ) const + { + // Get the standard graphics context + CWindowGc& gc = SystemGc(); + + // Set context + PrepareContext( gc ); + + // Gets the control's extent + TRect rect = Rect(); + if ( iBgContext ) + { + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + if ( !AknsDrawUtils::Background( skin, iBgContext, + gc, rect ) ) + { + gc.Clear( rect ); + } + } + + if ( iFlag & EFrameHwrBox == EFrameHwrBox ) + { + // Draw border + DrawBorders( gc ); + // Draw shawdow + DrawShadows( gc ); + } + + // Get repository + CRepository* repository = NULL; + TRAPD( err, repository = CRepository::NewL( KCRUidPersonalizationSettings ) ); + if ( err == KErrNone ) + { + TInt guideLine; + repository->Get( KSettingsPenInputGuideLine, guideLine ); + delete repository; + repository = NULL; + // Draw guideline + if ( guideLine ) + { + // Draw guidelines + DrawGuideLines( gc ); + } + } + // Draw work area + gc.SetPenSize( KLinePenSize ); + DrawTrails( gc ); + } + +TInt CTruiHwrBox::TimeToSaveL( TAny* aObject ) + { + ( (CTruiHwrBox*)aObject )->SaveModelL(); // cast, and call non-static function + return KErrNone; + } + +TInt CTruiHwrBox::TimeToDrawNextL( TAny* aObject ) + { + ( (CTruiHwrBox*)aObject )->DrawNextL(); // cast, and call non-static function + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CTruiHwrBox::TimedOut() +// Timer control, called everytime the time times out. +// ----------------------------------------------------------------------------- +// +void CTruiHwrBox::SaveModelL() + { + if ( iBoxState == ENewModelDraw ) + { + // Restore all screen to invalid region. + Window().Invalidate(); + //Cancel the timer + iTimeToSave->Cancel(); + iBoxState = EExistModelStop; + SetPointerCapture( EFalse ); + iPointArrayModel.Reset(); + for ( TInt i=0; i 0 ) + { + if ( iHwrBoxObserver ) + { + iHwrBoxObserver->SaveNewModelL(); + } + } + else + { + ClearExistModel(); + } + iStartSave = EFalse; + } + } + +// ----------------------------------------------------------------------------- +// Compare the numbers of points of two arrays at first. if they are not same, +// add a new point from iPointArrayModel to iPointArrayDraw. then draw a new line +// ----------------------------------------------------------------------------- +// +void CTruiHwrBox::DrawNextL() + { + // Check HwrBox state at first and then Check if model is drawn acompletely + if ( iBoxState == EExistModelDraw && + iPointArrayModel.Count() > iPointArrayDraw.Count() ) + { + // Add new point to iPointArrayDraw + iPointArrayDraw.AppendL( iPointArrayModel[ iPointArrayDraw.Count() ] ); + // Update the screen + DrawModel(); + } + else + { + iBoxState = EExistModelStop; + iTimeToDrawNext->Cancel(); + Window().Invalidate(); + } + } + +// --------------------------------------------------------------------------- +// Draw an existing model +// --------------------------------------------------------------------------- +// +void CTruiHwrBox::PlayAnimation( TBool aIsScale, const TSize& aRefSize ) + { + if ( ( iBoxState == EExistModelStop || iBoxState == EExistModelDraw ) + && iPointArrayModel.Count() ) + { + // Check and scale model points + if ( aIsScale ) + { + // Scale model points + ScaleModel( aRefSize, Rect().Size(), iPointArrayModel ); + } + + //Cancel the timer at first + iTimeToDrawNext->Cancel(); + + //Clear the box + iPointArrayDraw.Reset(); + if ( Parent() ) + { + Parent()->DrawNow(); + } + + //Set index of point need to be drawn to the beginning + iLastAnimatedPoint = KFirstPoint; + + //Set animate timer + iTimeToDrawNext->Start( KFirstEventDelay, KDrawSpeed, TCallBack( TimeToDrawNextL, this ) ); + + //Change box state + iBoxState = EExistModelDraw; + } + } + +// --------------------------------------------------------------------------- +// Clear the existing model +// --------------------------------------------------------------------------- +// +void CTruiHwrBox::ClearExistModel() + { + switch ( iBoxState ) + { + case EExistModelDraw: + { + //animation is playing, cancel the timer before clear it + iTimeToDrawNext->Cancel(); + break; + } + case ENewModelDraw: + { + //new model is inputting, cancel the timer before clear it + iTimeToSave->Cancel(); + iStartSave = EFalse; + break; + } + case EExistModelStop: + case ENewModelStop: + default: + { + } + } + iPointArrayModel.Reset(); + iPointArrayDraw.Reset(); + iBoxState = ENewModelStop; + Window().Invalidate(); + } + +// --------------------------------------------------------------------------- +// Handles an event from an observed control. +// --------------------------------------------------------------------------- +// +void CTruiHwrBox::HandlePointerEventL( const TPointerEvent& aPointerEvent ) + { + if ( iFlag & EReadOnlyHwrBox ) + { + // Readonly, don't handle pointer event. + return; + } + + CCoeControl::HandlePointerEventL( aPointerEvent ); + if ( AknLayoutUtils::PenEnabled() ) + { + switch( aPointerEvent.iType ) + { + case TPointerEvent::EButton1Down: + { + Window().Invalidate(); + if ( IsContained( aPointerEvent.iPosition ) ) + { + HideInfoPopupNote(); + iPenInRect = ETrue; + if ( iBoxState == ENewModelStop ) + { + //change box state + iBoxState = ENewModelDraw; + SetPointerCapture( ETrue ); + //start from the point where button is down + iPointArrayDraw.Append( aPointerEvent.iPosition - Position() ); + iLastAnimatedPoint = KFirstPoint; + DrawModel(); + } + else if ( iBoxState == ENewModelDraw ) + { + //cancel the iTimeToSave + iTimeToSave->Cancel(); + iStartSave = EFalse; + //start from the point where button is down + iPointArrayDraw.Append( aPointerEvent.iPosition - Position() ); + DrawModel(); + } + else + { + if ( iHwrBoxObserver ) + { + iHwrBoxObserver->HandleEventL( MTruiHwrBoxObserver::EModelExist ); + } + } + } + else + { + iPenInRect = EFalse; + } + break; + } + case TPointerEvent::EButton1Up: + { + if ( iBoxState == ENewModelDraw ) + { + iPointArrayDraw.Append( KTail ); + if ( !iStartSave ) + { + iStartSave = ETrue; + iTimeToSave->Start( KWritePeriod, + KWritePeriod, + TCallBack( TimeToSaveL, this ) ); + } + } + break; + } + case TPointerEvent::EDrag: + case TPointerEvent::EMove: + { + if ( iBoxState == ENewModelDraw ) + { + if ( IsContained( aPointerEvent.iPosition ) ) + { + Window().Invalidate(); + HideInfoPopupNote(); + //Pen go into available rect again, start an new trace + if ( iPenInRect == EFalse ) + { + iTimeToSave->Cancel(); + iStartSave = EFalse; + } + iPointArrayDraw.Append( aPointerEvent.iPosition - Position() ); + DrawModel(); + iPenInRect = ETrue; + } + else + { + if ( iPenInRect ) + { + iPointArrayDraw.Append( KTail ); + if ( !iStartSave ) + { + iStartSave = ETrue; + iTimeToSave->Start( KWritePeriod, + KWritePeriod, + TCallBack( TimeToSaveL, + this ) ); + } + iPenInRect = EFalse; + } + } + } + break; + } + default: + break; + } + } + } + +// --------------------------------------------------------------------------- +// Handles an event from an observed control. +// --------------------------------------------------------------------------- +// +TKeyResponse CTruiHwrBox::OfferKeyEventL( const TKeyEvent& /*aKeyEvent*/, + TEventCode /*aType*/ ) + { + return EKeyWasConsumed; + } + +// -------------------------------------------------------------------------- +// CTruiHwrBox::SetHwrBoxObserver +// -------------------------------------------------------------------------- +// +void CTruiHwrBox::SetHwrBoxObserver( MTruiHwrBoxObserver* aHwrBoxObserver ) + { + iHwrBoxObserver = aHwrBoxObserver; + } + +// -------------------------------------------------------------------------- +// Get the HwrBox's model. +// -------------------------------------------------------------------------- +// +RArray& CTruiHwrBox::Model() + { + return iPointArrayModel; + } + +// -------------------------------------------------------------------------- +// Draw character model +// -------------------------------------------------------------------------- +// +void CTruiHwrBox::DrawModel() + { + if ( IsActivated() && iPointArrayDraw.Count() && + iLastAnimatedPoint + 1 < iPointArrayDraw.Count() ) + { + // Get system graphic content + CWindowGc& gc = SystemGc(); + RWindow& window = Window(); + gc.Activate( window ); + window.Invalidate( Rect() ); + window.BeginRedraw( Rect() ); + Draw( Rect() ); + window.EndRedraw(); + gc.Deactivate(); + } + } + +// --------------------------------------------------------------------------- +// Responds to changes to the size and position of the contents of this control. +// --------------------------------------------------------------------------- +// +void CTruiHwrBox::SizeChanged() + { + LoadBorderLayout( 0 ); + for ( TInt i = 0; i < iBorderLayout.Count() + && i < iBorderBitmaps.Count() + && i < iBorderBitmapMasks.Count(); i++ ) + { + TSize size = iBorderLayout[i].Rect().Size(); + AknIconUtils::SetSize( iBorderBitmaps[i], size, EAspectRatioNotPreserved ); + AknIconUtils::SetSize( iBorderBitmapMasks[i], size, EAspectRatioNotPreserved ); + } + + LoadShadowLayout( 0 ); + for ( TInt i = 0; i < iShadowLayout.Count() + && i < iShadowBitmaps.Count() + && i < iShadowBitmapMasks.Count(); i++ ) + { + TSize size = iShadowLayout[i].Rect().Size(); + AknIconUtils::SetSize( iShadowBitmaps[i], size, EAspectRatioNotPreserved ); + AknIconUtils::SetSize( iShadowBitmapMasks[i], size, EAspectRatioNotPreserved ); + } + + LoadGuideLineLayout( 0 ); + // Guide line position + TInt margin = Size().iWidth / KGuideLineWidthRadio; + + iGuideLineBottomL.iX = Position().iX + margin; + iGuideLineTopL.iX = Position().iX + margin; + + for ( TInt i = 0; i < iGuideLineLayout.Count() + && i < iGuideLineBitmaps.Count() + && i < iGuideLineBitmapMasks.Count(); i++ ) + { + TSize size = iGuideLineLayout[i].Rect().Size(); + size.iWidth = Size().iWidth - margin * 2; + AknIconUtils::SetSize( iGuideLineBitmaps[i], size, EAspectRatioNotPreserved ); + AknIconUtils::SetSize( iGuideLineBitmapMasks[i], size, EAspectRatioNotPreserved ); + } + + // Caculate hwr_training_write_pane_g7 for drawable rect + TRect rect = Rect(); + TAknWindowComponentLayout drawable_rect_layout = + AknLayoutScalable_Apps::hwr_training_write_pane_g7( 0 ); + TAknLayoutRect drawable_rect_layout_rect; + drawable_rect_layout_rect.LayoutRect( rect, drawable_rect_layout ); + iDrawabelRect = drawable_rect_layout_rect.Rect(); + iDrawabelRect.Shrink( KLinePenSize.iWidth , + KLinePenSize.iHeight ); + iPenColor = drawable_rect_layout_rect.Color(); + + TInt guidinglinetop(0); + TInt guidinglinebottom(0); + CTruiEngine* engine = static_cast( iEikonEnv->AppUi() )->HwrEngine(); + engine->GetGuidingLinePos( iDrawabelRect.Size(), guidinglinetop, guidinglinebottom ); + SetGuidingLine( guidinglinetop, guidinglinebottom ); + } + +// --------------------------------------------------------------------------- +// From class CCoeControl. +// Handles a change to the control's resources. +// --------------------------------------------------------------------------- +// +void CTruiHwrBox::HandleResourceChange( TInt aType ) + { + CCoeControl::HandleResourceChange( aType ); + if ( aType == KEikMessageUnfadeWindows ) + { + DrawDeferred(); + } + if ( aType == KAknsMessageSkinChange ) + { + TRAP_IGNORE( + LoadBorderBitmapsL(); + LoadShadowBitmapsL(); + LoadGuideLineBitmapsL(); + ) + SizeChanged(); + } + } + +// --------------------------------------------------------------------------- +// From class CCoeControl. +// Handle focus changed. +// --------------------------------------------------------------------------- +// +void CTruiHwrBox::FocusChanged( TDrawNow /*aDrawNow*/ ) + { + if ( !IsFocused() && iBoxState == ENewModelDraw ) + { + iPointArrayDraw.Append( KTail ); + TRAP_IGNORE( SaveModelL() ); + } + } + +// --------------------------------------------------------------------------- +// When load model from outside, set box state +// --------------------------------------------------------------------------- +// +void CTruiHwrBox::ModelIsReady( TBool aReady ) + { + if ( aReady ) + { + iBoxState = EExistModelStop; + } + else + { + iBoxState = ENewModelStop; + } + } + +TRect CTruiHwrBox::DrawableRect() const + { + return iDrawabelRect; + } + +// --------------------------------------------------------------------------- +// Set editing mode to readonly or writable +// --------------------------------------------------------------------------- +// +void CTruiHwrBox::SetHwrBoxReadOnly( TBool aReadOnly ) + { + TUint flag = aReadOnly ? EReadOnlyHwrBox : EWritableHwrBox; + iFlag &= ( ~EReadOnlyHwrBox & ~EWritableHwrBox ); + iFlag |= flag; + } + +// --------------------------------------------------------------------------- +// Get the Hwrbox's state +// --------------------------------------------------------------------------- +// +TInt CTruiHwrBox::BoxState() const + { + return iBoxState; + } + +// --------------------------------------------------------------------------- +// Pause the playing of animation +// --------------------------------------------------------------------------- +// +void CTruiHwrBox::PausePlaying() + { + if ( iBoxState == EExistModelDraw ) + { + iBoxState = EExistModelStop; + iTimeToDrawNext->Cancel(); + Window().Invalidate(); + } + } + +// --------------------------------------------------------------------------- +// Resume the playing of animation +// --------------------------------------------------------------------------- +// +void CTruiHwrBox::ResumePlaying() + { + // Check HwrBox state at first and then Check if model is drawn acompletely + if ( iBoxState == EExistModelStop && + iPointArrayModel.Count() > iPointArrayDraw.Count() ) + { + + //Cancel the timer at first + iTimeToDrawNext->Cancel(); + + //Set animate timer + iTimeToDrawNext->Start( KFirstEventDelay, KDrawSpeed, + TCallBack(TimeToDrawNextL, this) ); + + //Change box state + iBoxState = EExistModelDraw; + } + } + +// --------------------------------------------------------------------------- +// Set Guiding Line +// --------------------------------------------------------------------------- +// +TInt CTruiHwrBox::SetGuidingLine( TInt aTop, TInt aBottom ) + { + TRect rect = DrawableRect(); + if ( Size().iHeight <= aBottom || aBottom <= 0 + || Size().iHeight <= aTop || aTop <= 0 ) + { + return KErrArgument; + } + + iGuideLineTopL.iY = rect.iTl.iY + aTop; + iGuideLineBottomL.iY = rect.iTl.iY + aBottom; + return KErrNone; + } + +// --------------------------------------------------------------------------- +// Check if the point is contained in drawing area +// --------------------------------------------------------------------------- +// +TBool CTruiHwrBox::IsContained( const TPoint& aPoint ) const + { + return DrawableRect().Contains( aPoint ); + } + +// --------------------------------------------------------------------------- +// Adjust shortcut model's point to fit the popup hwr box. +// --------------------------------------------------------------------------- +// +void CTruiHwrBox::ScaleModel( const TSize& aOriginSize, + const TSize& aRealSize, + RArray& aModel ) + { + CTruiEngine* engine = static_cast( iEikonEnv->AppUi() )->HwrEngine(); + TInt originTop; + TInt originBottom; + engine->GetGuidingLinePos( aOriginSize, originTop, originBottom ); + TInt realTop; + TInt realBottom; + engine->GetGuidingLinePos( aRealSize, realTop, realBottom ); + for ( TInt i =0; i < aModel.Count(); i++ ) + { + if ( aModel[i] != KTail ) + { + aModel[i].iX = aModel[i].iX * realBottom / originBottom; + aModel[i].iY = aModel[i].iY * realBottom / originBottom; + } + } + } + +// ----------------------------------------------------------------------------- +// Draws all points. +// ----------------------------------------------------------------------------- +// +void CTruiHwrBox::DrawTrails( CWindowGc& aGc ) const + { + // Draw model + if ( iPointArrayDraw.Count() ) + { + //Draw from the first point in the array + TInt lastAnimatedPoint( 0 ); + TPoint relativePos; + if ( OwnsWindow() ) + { + relativePos = TPoint( 0, 0 ); + } + else + { + relativePos = Position(); + } + aGc.Plot( iPointArrayDraw[lastAnimatedPoint] + relativePos ); + + // Check if there is point need to be drawn + // Plus 1 to lastAnimatedPointIndex since zero implies the first point + // in the iLastAnimatedPoint + while ( lastAnimatedPoint + 1 < iPointArrayDraw.Count() ) + { + //Check if this is a new arc and increase the index counter + if ( iPointArrayDraw[lastAnimatedPoint++] != KTail ) + { + //It is not a new arc, then check if this is the end of an arc + if ( iPointArrayDraw[lastAnimatedPoint] != KTail ) + { + //It is not the end of an arc, so draw line + aGc.DrawLineTo( iPointArrayDraw[lastAnimatedPoint] + + relativePos ); + } + } + else + { + //It is a new arc, so move the pen to the new point + aGc.Plot( iPointArrayDraw[lastAnimatedPoint] + + relativePos ); + } + } + } + } + +// -------------------------------------------------------------------------- +// Set context for this control. +// -------------------------------------------------------------------------- +// +void CTruiHwrBox::PrepareContext( CWindowGc& aGc ) const + { + TRgb color; + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + // Set pen color to the color of test in main area + TInt error = AknsUtils::GetCachedColor( skin, + color, + KAknsIIDQsnTextColors, + EAknsCIQsnTextColorsCG6 ); + if ( !error ) + { + aGc.SetPenColor( color ); + } + } + +// -------------------------------------------------------------------------- +// Load bitmaps for border. +// -------------------------------------------------------------------------- +// +void CTruiHwrBox::LoadBorderBitmapsL() + { + iBorderBitmaps.ResetAndDestroy(); + iBorderBitmapMasks.ResetAndDestroy(); + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + CFbsBitmap* bitmapLeft; + CFbsBitmap* bitmapLeftMask; + AknsUtils::CreateColorIconL( skin, + KAknsIIDQgnGrafFepBgColour, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG14, + bitmapLeft, + bitmapLeftMask, + KTRUIICONSFILENAME, + EMbmTrui_iconsQgn_graf_fep_bg_colour, + EMbmTrui_iconsQgn_graf_fep_bg_colour_mask, + KRgbBlack + ); + iBorderBitmaps.Append( bitmapLeft ); + iBorderBitmapMasks.Append( bitmapLeftMask ); + + CFbsBitmap* bitmapTop; + CFbsBitmap* bitmapTopMask; + AknsUtils::CreateColorIconL( skin, + KAknsIIDQgnGrafFepBgColour, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG14, + bitmapTop, + bitmapTopMask, + KTRUIICONSFILENAME, + EMbmTrui_iconsQgn_graf_fep_bg_colour, + EMbmTrui_iconsQgn_graf_fep_bg_colour_mask, + KRgbBlack + ); + iBorderBitmaps.Append( bitmapTop ); + iBorderBitmapMasks.Append( bitmapTopMask ); + + CFbsBitmap* bitmapBottom; + CFbsBitmap* bitmapBottomMask; + AknsUtils::CreateColorIconL( skin, + KAknsIIDQgnGrafFepBgColour, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG14, + bitmapBottom, + bitmapBottomMask, + KTRUIICONSFILENAME, + EMbmTrui_iconsQgn_graf_fep_bg_colour, + EMbmTrui_iconsQgn_graf_fep_bg_colour_mask, + KRgbBlack + ); + iBorderBitmaps.Append( bitmapBottom ); + iBorderBitmapMasks.Append( bitmapBottomMask ); + + CFbsBitmap* bitmapRight; + CFbsBitmap* bitmapRightMask; + AknsUtils::CreateColorIconL( skin, + KAknsIIDQgnGrafFepBgColour, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG14, + bitmapRight, + bitmapRightMask, + KTRUIICONSFILENAME, + EMbmTrui_iconsQgn_graf_fep_bg_colour, + EMbmTrui_iconsQgn_graf_fep_bg_colour_mask, + KRgbBlack + ); + iBorderBitmaps.Append( bitmapRight ); + iBorderBitmapMasks.Append( bitmapRightMask ); + } + +// -------------------------------------------------------------------------- +// Load bitmaps for shadows. +// -------------------------------------------------------------------------- +// +void CTruiHwrBox::LoadShadowBitmapsL() + { + iShadowBitmaps.ResetAndDestroy(); + iShadowBitmapMasks.ResetAndDestroy(); + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + CFbsBitmap* bitmapTl; + CFbsBitmap* bitmapTlMask; + AknsUtils::CreateColorIconL( skin, + KAknsIIDQgnGrafFepPopupShadowTl, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG14, + bitmapTl, + bitmapTlMask, + KTRUIICONSFILENAME, + EMbmTrui_iconsQgn_graf_fep_popup_shadow_tl, + EMbmTrui_iconsQgn_graf_fep_popup_shadow_tl_mask, + KRgbBlack + ); + iShadowBitmaps.Append( bitmapTl ); + iShadowBitmapMasks.Append( bitmapTlMask ); + + CFbsBitmap* bitmapT; + CFbsBitmap* bitmapTMask; + AknsUtils::CreateColorIconL( skin, + KAknsIIDQgnGrafFepPopupShadowT, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG14, + bitmapT, + bitmapTMask, + KTRUIICONSFILENAME, + EMbmTrui_iconsQgn_graf_fep_popup_shadow_t, + EMbmTrui_iconsQgn_graf_fep_popup_shadow_t_mask, + KRgbBlack + ); + iShadowBitmaps.Append( bitmapT ); + iShadowBitmapMasks.Append( bitmapTMask ); + + CFbsBitmap* bitmapTr; + CFbsBitmap* bitmapTrMask; + AknsUtils::CreateColorIconL( skin, + KAknsIIDQgnGrafFepPopupShadowTr, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG14, + bitmapTr, + bitmapTrMask, + KTRUIICONSFILENAME, + EMbmTrui_iconsQgn_graf_fep_popup_shadow_tr, + EMbmTrui_iconsQgn_graf_fep_popup_shadow_tr_mask, + KRgbBlack + ); + iShadowBitmaps.Append( bitmapTr ); + iShadowBitmapMasks.Append( bitmapTrMask ); + + CFbsBitmap* bitmapL; + CFbsBitmap* bitmapLMask; + AknsUtils::CreateColorIconL( skin, + KAknsIIDQgnGrafFepPopupShadowL, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG14, + bitmapL, + bitmapLMask, + KTRUIICONSFILENAME, + EMbmTrui_iconsQgn_graf_fep_popup_shadow_l, + EMbmTrui_iconsQgn_graf_fep_popup_shadow_l_mask, + KRgbBlack + ); + iShadowBitmaps.Append( bitmapL ); + iShadowBitmapMasks.Append( bitmapLMask ); + + CFbsBitmap* bitmapBl; + CFbsBitmap* bitmapBlMask; + AknsUtils::CreateColorIconL( skin, + KAknsIIDQgnGrafFepPopupShadowBl, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG14, + bitmapBl, + bitmapBlMask, + KTRUIICONSFILENAME, + EMbmTrui_iconsQgn_graf_fep_popup_shadow_bl, + EMbmTrui_iconsQgn_graf_fep_popup_shadow_bl_mask, + KRgbBlack + ); + iShadowBitmaps.Append( bitmapBl ); + iShadowBitmapMasks.Append( bitmapBlMask ); + + CFbsBitmap* bitmapR; + CFbsBitmap* bitmapRMask; + AknsUtils::CreateColorIconL( skin, + KAknsIIDQgnGrafFepPopupShadowR, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG14, + bitmapR, + bitmapRMask, + KTRUIICONSFILENAME, + EMbmTrui_iconsQgn_graf_fep_popup_shadow_r, + EMbmTrui_iconsQgn_graf_fep_popup_shadow_r_mask, + KRgbBlack + ); + iShadowBitmaps.Append( bitmapR ); + iShadowBitmapMasks.Append( bitmapRMask ); + + CFbsBitmap* bitmapB; + CFbsBitmap* bitmapBMask; + AknsUtils::CreateColorIconL( skin, + KAknsIIDQgnGrafFepPopupShadowB, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG14, + bitmapB, + bitmapBMask, + KTRUIICONSFILENAME, + EMbmTrui_iconsQgn_graf_fep_popup_shadow_b, + EMbmTrui_iconsQgn_graf_fep_popup_shadow_b_mask, + KRgbBlack + ); + iShadowBitmaps.Append( bitmapB ); + iShadowBitmapMasks.Append( bitmapBMask ); + + CFbsBitmap* bitmapBr; + CFbsBitmap* bitmapBrMask; + AknsUtils::CreateColorIconL( skin, + KAknsIIDQgnGrafFepPopupShadowBr, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG14, + bitmapBr, + bitmapBrMask, + KTRUIICONSFILENAME, + EMbmTrui_iconsQgn_graf_fep_popup_shadow_br, + EMbmTrui_iconsQgn_graf_fep_popup_shadow_br_mask, + KRgbBlack + ); + iShadowBitmaps.Append( bitmapBr ); + iShadowBitmapMasks.Append( bitmapBrMask ); + } + +// -------------------------------------------------------------------------- +// Load bitmaps for guidelines. +// -------------------------------------------------------------------------- +// +void CTruiHwrBox::LoadGuideLineBitmapsL() + { + iGuideLineBitmaps.ResetAndDestroy(); + iGuideLineBitmapMasks.ResetAndDestroy(); + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + CFbsBitmap* bitmapTop; + CFbsBitmap* bitmapTopMask; + AknsUtils::CreateColorIconL( skin, + KAknsIIDQgnGrafFepBgColour, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG14, + bitmapTop, + bitmapTopMask, + KTRUIICONSFILENAME, + EMbmTrui_iconsQgn_graf_fep_bg_colour, + EMbmTrui_iconsQgn_graf_fep_bg_colour_mask, + KRgbBlack + ); + iGuideLineBitmaps.Append( bitmapTop ); + iGuideLineBitmapMasks.Append( bitmapTopMask ); + + CFbsBitmap* bitmapBottom; + CFbsBitmap* bitmapBottomMask; + AknsUtils::CreateColorIconL( skin, + KAknsIIDQgnGrafFepBgColour, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG14, + bitmapBottom, + bitmapBottomMask, + KTRUIICONSFILENAME, + EMbmTrui_iconsQgn_graf_fep_bg_colour, + EMbmTrui_iconsQgn_graf_fep_bg_colour_mask, + KRgbBlack + ); + iGuideLineBitmaps.Append( bitmapBottom ); + iGuideLineBitmapMasks.Append( bitmapBottomMask ); + } + +// -------------------------------------------------------------------------- +// Load layouts for borders from LAF. +// -------------------------------------------------------------------------- +// +void CTruiHwrBox::LoadBorderLayout( TInt aVarity ) + { + TRect rect = Rect(); + iBorderLayout.Reset(); + // Caculate hwr_training_write_pane_g1 + TAknWindowComponentLayout border_left_layout = + AknLayoutScalable_Apps::hwr_training_write_pane_g1( aVarity ); + TAknLayoutRect border_left_layout_rect; + border_left_layout_rect.LayoutRect( rect, border_left_layout ); + iBorderLayout.Append( border_left_layout_rect ); + + TAknWindowComponentLayout border_top_layout = + AknLayoutScalable_Apps::hwr_training_write_pane_g2( aVarity ); + TAknLayoutRect border_top_layout_rect; + border_top_layout_rect.LayoutRect( rect, border_top_layout ); + iBorderLayout.Append( border_top_layout_rect ); + + TAknWindowComponentLayout border_bottom_layout = + AknLayoutScalable_Apps::hwr_training_write_pane_g3( aVarity ); + TAknLayoutRect border_bottom_layout_rect; + border_bottom_layout_rect.LayoutRect( rect, border_bottom_layout ); + iBorderLayout.Append( border_bottom_layout_rect ); + + TAknWindowComponentLayout border_right_layout = + AknLayoutScalable_Apps::hwr_training_write_pane_g4( aVarity ); + TAknLayoutRect border_right_layout_rect; + border_right_layout_rect.LayoutRect( rect, border_right_layout ); + iBorderLayout.Append( border_right_layout_rect ); + } + +// -------------------------------------------------------------------------- +// Load layouts for shadows from LAF. +// -------------------------------------------------------------------------- +// +void CTruiHwrBox::LoadShadowLayout( TInt aVarity ) + { + TRect rect = Rect(); + iShadowLayout.Reset(); + // Caculate bg_frame_shadow_pane + TAknWindowComponentLayout shadow_pane_layout = + AknLayoutScalable_Apps::bg_frame_shadow_pane( aVarity ); + TAknLayoutRect shadow_pane_layout_rect; + shadow_pane_layout_rect.LayoutRect( rect, shadow_pane_layout ); + TRect shadowPaneRect = shadow_pane_layout_rect.Rect(); + + // Caculate bg_frame_shadow_pane_g1 + TAknWindowComponentLayout shadow_pane_tl_layout = + AknLayoutScalable_Apps::bg_frame_shadow_pane_g1( aVarity ); + TAknLayoutRect shadow_pane_tl_layout_rect; + shadow_pane_tl_layout_rect.LayoutRect( shadowPaneRect, shadow_pane_tl_layout ); + iShadowLayout.Append( shadow_pane_tl_layout_rect ); + + // Caculate bg_frame_shadow_pane_g2 + TAknWindowComponentLayout shadow_pane_t_layout = + AknLayoutScalable_Apps::bg_frame_shadow_pane_g2( aVarity ); + TAknLayoutRect shadow_pane_t_layout_rect; + shadow_pane_t_layout_rect.LayoutRect( shadowPaneRect, shadow_pane_t_layout ); + iShadowLayout.Append( shadow_pane_t_layout_rect ); + + // Caculate bg_frame_shadow_pane_g3 + TAknWindowComponentLayout shadow_pane_tr_layout = + AknLayoutScalable_Apps::bg_frame_shadow_pane_g3( aVarity ); + TAknLayoutRect shadow_pane_tr_layout_rect; + shadow_pane_tr_layout_rect.LayoutRect( shadowPaneRect, shadow_pane_tr_layout ); + iShadowLayout.Append( shadow_pane_tr_layout_rect ); + + // Caculate bg_frame_shadow_pane_g4 + TAknWindowComponentLayout shadow_pane_l_layout = + AknLayoutScalable_Apps::bg_frame_shadow_pane_g4( aVarity ); + TAknLayoutRect shadow_pane_l_layout_rect; + shadow_pane_l_layout_rect.LayoutRect( shadowPaneRect, shadow_pane_l_layout ); + iShadowLayout.Append( shadow_pane_l_layout_rect ); + + // Caculate bg_frame_shadow_pane_g5 + TAknWindowComponentLayout shadow_pane_bl_layout = + AknLayoutScalable_Apps::bg_frame_shadow_pane_g5( aVarity ); + TAknLayoutRect shadow_pane_bl_layout_rect; + shadow_pane_bl_layout_rect.LayoutRect( shadowPaneRect, shadow_pane_bl_layout ); + iShadowLayout.Append( shadow_pane_bl_layout_rect ); + + // Caculate bg_frame_shadow_pane_g6 + TAknWindowComponentLayout shadow_pane_r_layout = + AknLayoutScalable_Apps::bg_frame_shadow_pane_g6( aVarity ); + TAknLayoutRect shadow_pane_r_layout_rect; + shadow_pane_r_layout_rect.LayoutRect( shadowPaneRect, shadow_pane_r_layout ); + iShadowLayout.Append( shadow_pane_r_layout_rect ); + + // Caculate bg_frame_shadow_pane_g7 + TAknWindowComponentLayout shadow_pane_b_layout = + AknLayoutScalable_Apps::bg_frame_shadow_pane_g7( aVarity ); + TAknLayoutRect shadow_pane_b_layout_rect; + shadow_pane_b_layout_rect.LayoutRect( shadowPaneRect, shadow_pane_b_layout ); + iShadowLayout.Append( shadow_pane_b_layout_rect ); + + // Caculate bg_frame_shadow_pane_g8 + TAknWindowComponentLayout shadow_pane_br_layout = + AknLayoutScalable_Apps::bg_frame_shadow_pane_g8( aVarity ); + TAknLayoutRect shadow_pane_br_layout_rect; + shadow_pane_br_layout_rect.LayoutRect( shadowPaneRect, shadow_pane_br_layout ); + iShadowLayout.Append( shadow_pane_br_layout_rect ); + } + +// -------------------------------------------------------------------------- +// Load layouts for guidelines from LAF. +// -------------------------------------------------------------------------- +// +void CTruiHwrBox::LoadGuideLineLayout( TInt aVarity ) + { + TRect rect = Rect(); + iGuideLineLayout.Reset(); + // Caculate hwr_training_write_pane_g5 + TAknWindowComponentLayout top_guideline_layout = + AknLayoutScalable_Apps::hwr_training_write_pane_g5( aVarity ); + TAknLayoutRect top_guideline_layout_rect; + top_guideline_layout_rect.LayoutRect( rect, top_guideline_layout ); + iGuideLineLayout.Append( top_guideline_layout_rect ); + + // Caculate hwr_training_write_pane_g6 + TAknWindowComponentLayout bottom_guideline_layout = + AknLayoutScalable_Apps::hwr_training_write_pane_g6( aVarity ); + TAknLayoutRect bottom_guideline_layout_rect; + bottom_guideline_layout_rect.LayoutRect( rect, bottom_guideline_layout ); + iGuideLineLayout.Append( bottom_guideline_layout_rect ); + } + +// -------------------------------------------------------------------------- +// Draw borders. +// -------------------------------------------------------------------------- +// +void CTruiHwrBox::DrawBorders( CWindowGc& aGc ) const + { + for ( TInt i = 0; i < iBorderLayout.Count(); i++ ) + { + iBorderLayout[i].DrawImage( aGc, iBorderBitmaps[i], iBorderBitmapMasks[i] ); + } + } + +// -------------------------------------------------------------------------- +// Draw shadows. +// -------------------------------------------------------------------------- +// +void CTruiHwrBox::DrawShadows( CWindowGc& aGc ) const + { + for ( TInt i = 0; i < iShadowLayout.Count(); i++ ) + { + iShadowLayout[i].DrawImage( aGc, iShadowBitmaps[i], iShadowBitmapMasks[i] ); + } + } + +// -------------------------------------------------------------------------- +// Draw guidelines. +// -------------------------------------------------------------------------- +// +void CTruiHwrBox::DrawGuideLines( CWindowGc& aGc ) const + { + if ( iTopGuideLineDisplay && KTopGuideLineIndex < iGuideLineLayout.Count() + && KTopGuideLineIndex < iGuideLineBitmaps.Count() + && KTopGuideLineIndex < iGuideLineBitmapMasks.Count() ) + { + TSize pixSize = iGuideLineBitmaps[KTopGuideLineIndex]->SizeInPixels(); + aGc.BitBltMasked( iGuideLineTopL, iGuideLineBitmaps[KTopGuideLineIndex], + TRect( TPoint( 0, 0 ), pixSize ), + iGuideLineBitmapMasks[KTopGuideLineIndex], EFalse ); + } + + if ( iBottomGuideLineDisplay && KBottomGuideLineIndex < iGuideLineLayout.Count() + && KBottomGuideLineIndex < iGuideLineBitmaps.Count() + && KBottomGuideLineIndex < iGuideLineBitmapMasks.Count() ) + { + TSize pixSize = iGuideLineBitmaps[KBottomGuideLineIndex]->SizeInPixels(); + aGc.BitBltMasked( iGuideLineBottomL, iGuideLineBitmaps[KBottomGuideLineIndex], + TRect( TPoint( 0, 0 ), pixSize ), + iGuideLineBitmapMasks[KBottomGuideLineIndex], EFalse ); + } + } + +// ----------------------------------------------------------------------------- +// Show trails. +// ----------------------------------------------------------------------------- +// +void CTruiHwrBox::ShowTrails( const RArray& aPointArray, + TBool aIsScale, + const TSize& aRefSize ) + { + // Set values fo iPointArrayDraw + if ( aPointArray.Count() > 0 ) + { + iPointArrayDraw.Reset(); + for ( TInt i = 0; i < aPointArray.Count(); i++ ) + { + iPointArrayDraw.Append( aPointArray[i] ); + } + } + + // Adjust the trails in terms of HwrBox size + if ( aIsScale ) + { + // Scale model points + ScaleModel( aRefSize, iDrawabelRect.Size(), iPointArrayDraw ); + } + DrawNow(); + } + +// -------------------------------------------------------------------------- +// CTruiHwrBox::ShowTooltipL +// -------------------------------------------------------------------------- +// +void CTruiHwrBox::ShowTooltipL( const TDesC& aText, + const TPoint& aPosition, + const TInt aBeforeTimeout, + const TInt aInViewTimeout ) + { + if ( aText.Length() < 0 ) + { + return; + } + iTooltip->SetTextL( aText ); + iTooltip->SetTimeDelayBeforeShow( aBeforeTimeout ); + iTooltip->SetTimePopupInView( aInViewTimeout ); + iTooltip->SetPositionAndAlignment( aPosition, EHCenterVTop ); + + iTooltip->ShowInfoPopupNote(); + } + +void CTruiHwrBox::SetTooltipPosition( const TPoint& aPosition ) + { + if ( iTooltip ) + { + iTooltip->SetPositionAndAlignment( aPosition, EHCenterVTop ); + } + } + +// -------------------------------------------------------------------------- +// Hide tooltip. +// -------------------------------------------------------------------------- +// +void CTruiHwrBox::HideInfoPopupNote() + { + if ( iTooltip ) + { + iTooltip->HideInfoPopupNote(); + } + } + +// -------------------------------------------------------------------------- +// Handles events reported from info popup note. +// -------------------------------------------------------------------------- +// +void CTruiHwrBox::HandleInfoPopupNoteEvent( CAknInfoPopupNoteController* aController, + TAknInfoPopupNoteEvent aEvent ) + { + if ( aController == iTooltip && aEvent == EInfoPopupNoteHidden ) + { + DrawNow(); + } + } + +// ----------------------------------------------------------------------------- +// Save the new inputting model by manual. +// ----------------------------------------------------------------------------- +// +void CTruiHwrBox::SaveModelByManuallyL() + { + if ( iPointArrayDraw.Count() && !iStartSave ) + { + // Has drawn + if ( iPointArrayDraw[iPointArrayDraw.Count() - 1] != KTail ) + { + iPointArrayDraw.Append( KTail ); + } + SaveModelL(); + } + }