1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0""

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  The class of handwriting box container implemention.

    15 *

    16 */

    17 

    18 

    19 #include <peninputlayout.h>

    20 #include <aknfeppeninputenums.h>    //command from fep or IME to plugin. for vkb/hwr : ESignalCapturePointer

    21 

    22 #include "peninputhwrboxgroup.h"

    23 #include "peninputhwrevent.h"

    24 

    25 // Implementation of Class CPeninputHwrBoxGroup

    26 // The container class of HWR boxes

    27 

    28 // -----------------------------------------------------------------------------

    29 // CPeninputHwrBoxGroup::NewL

    30 // factory function

    31 // (other items were commented in a header).

    32 // -----------------------------------------------------------------------------

    33 //

    34 CPeninputHwrBoxGroup* CPeninputHwrBoxGroup::NewL(CFepUiLayout* aUiLayout,

    35                                              TInt aBoxGroupId,

    36                                              TInt aBoxCount)

    37     {

    38     CPeninputHwrBoxGroup* self = new (ELeave) CPeninputHwrBoxGroup(aUiLayout, aBoxGroupId);

    39     CleanupStack::PushL(self);

    40     self->ConstructL(aBoxCount);

    41     CleanupStack::Pop(self);

    42     return self;

    43     }

    44 

    45 // -----------------------------------------------------------------------------

    46 // CPeninputHwrBoxGroup::NewLC

    47 // factory function

    48 // (other items were commented in a header).

    49 // -----------------------------------------------------------------------------

    50 //

    51 CPeninputHwrBoxGroup* CPeninputHwrBoxGroup::NewLC(CFepUiLayout* aUiLayout,

    52                                               TInt aBoxGroupId,

    53                                               TInt aBoxCount)

    54     {

    55     CPeninputHwrBoxGroup* self = new (ELeave) CPeninputHwrBoxGroup(aUiLayout, aBoxGroupId);

    56     CleanupStack::PushL(self);

    57     self->ConstructL(aBoxCount);

    58     return self;

    59     }

    60 

    61 // -----------------------------------------------------------------------------

    62 // CPeninputHwrBoxGroup::~CPeninputHwrBoxGroup

    63 // Destructor

    64 // (other items were commented in a header).

    65 // -----------------------------------------------------------------------------

    66 //

    67 CPeninputHwrBoxGroup::~CPeninputHwrBoxGroup()

    68     {

    69     // base class CControlGroup frees all controls in the list

    70     }

    71 

    72 // ---------------------------------------------------------------------------

    73 // CPeninputHwrBoxGroup::HandlePointerDownEventL

    74 // Handle pointer down event

    75 // (other items were commented in a header).

    76 // ---------------------------------------------------------------------------

    77 CFepUiBaseCtrl* CPeninputHwrBoxGroup::HandlePointerDownEventL(const TPoint& aPoint)

    78     {

    79     if(iDimmed)

    80         {

    81         CapturePointer();

    82         return NULL;

    83         }

    84     return CControlGroup::HandlePointerDownEventL(aPoint);

    85     }

    86 

    87 // ---------------------------------------------------------------------------

    88 // CPeninputHwrBoxGroup::HandlePointerMoveEventL

    89 // Handle pointer move event

    90 // (other items were commented in a header).

    91 // ---------------------------------------------------------------------------

    92 CFepUiBaseCtrl* CPeninputHwrBoxGroup::HandlePointerMoveEventL(const TPoint& aPoint)

    93     {

    94     if(iDimmed)

    95         {

    96         return NULL;

    97         }

    98     return CControlGroup::HandlePointerMoveEventL(aPoint);

    99     }

   100 

   101 // ---------------------------------------------------------------------------

   102 // CPeninputHwrBoxGroup::HandlePointerUpEventL

   103 // Handle pointer up event

   104 // (other items were commented in a header).

   105 // ---------------------------------------------------------------------------

   106 CFepUiBaseCtrl* CPeninputHwrBoxGroup::HandlePointerUpEventL(const TPoint& aPoint)

   107     {

   108     if(iDimmed)

   109         {

   110         TBool capture = ETrue;

   111         TPtrC captureData;

   112         captureData.Set((const TUint16*)&capture,sizeof(TBool)/sizeof(TUint16));

   113         CapturePointer(EFalse);

   114         UiLayout()->SignalOwner(ESignalCapturePointer,captureData);

   115         return NULL;

   116         }

   117     return CControlGroup::HandlePointerUpEventL(aPoint);

   118     }

   119 

   120 // ---------------------------------------------------------------------------

   121 // CPeninputHwrBoxGroup::HandlePointerLeave

   122 // Handle pointer leave  event

   123 // (other items were commented in a header).

   124 // ---------------------------------------------------------------------------

   125 void CPeninputHwrBoxGroup::HandlePointerLeave(const TPoint& aPoint)

   126     {

   127     if(iDimmed)

   128         {

   129         return;

   130         }

   131     CControlGroup::HandlePointerLeave(aPoint);

   132     }

   133 

   134 // ---------------------------------------------------------------------------

   135 // CPeninputHwrBoxGroup::HandlePointerEnter

   136 // Handle pointer enter  event

   137 // (other items were commented in a header).

   138 // ---------------------------------------------------------------------------

   139 void CPeninputHwrBoxGroup::HandlePointerEnter(const TPoint& aPoint)

   140     {

   141     if(iDimmed)

   142         {

   143         return;

   144         }

   145     CControlGroup::HandlePointerEnter(aPoint);

   146     }

   147 

   148 // -----------------------------------------------------------------------------

   149 // CPeninputHwrBoxGroup::BoxCount

   150 // Clear current handwriting trail if any.

   151 // (other items were commented in a header).

   152 // -----------------------------------------------------------------------------

   153 //

   154 TInt CPeninputHwrBoxGroup::BoxCount()

   155     {

   156     return NumOfControls();

   157     }

   158 

   159 // -----------------------------------------------------------------------------

   160 // CPeninputHwrBoxGroup::CancelWriting

   161 // Clear current handwriting trail if any.

   162 // (other items were commented in a header).

   163 // -----------------------------------------------------------------------------

   164 //

   165 void CPeninputHwrBoxGroup::CancelWriting()

   166     {

   167     if( iActiveBox == NULL )

   168         {

   169         //there is nothing to cancel

   170         return;

   171         }

   172 

   173     iActiveBox->SetWndTransparencyFactor(iInactiveTrans);

   174     iActiveBox->CancelCharWriting();

   175     }

   176 

   177 const RArray<TPoint>& CPeninputHwrBoxGroup::StrokeList()

   178     {

   179     ASSERT( iActiveBox != NULL );

   180 

   181     return iActiveBox->StrokeList();

   182     }

   183 

   184 // -----------------------------------------------------------------------------

   185 // CPeninputHwrBoxGroup::SizeChanged

   186 // Hand size change event.

   187 // (other items were commented in a header).

   188 // -----------------------------------------------------------------------------

   189 //

   190 void CPeninputHwrBoxGroup::SizeChanged(const TRect& aRect)

   191     {

   192     TInt boxWidth = aRect.Width() / NumOfControls();

   193     TInt curLeft = aRect.iTl.iX;

   194 

   195     SetRect(aRect);

   196 

   197     for( TInt j = 0; j < NumOfControls(); j++, curLeft += boxWidth )

   198         {

   199         CTransparentHwrWnd* ctrl = static_cast<CTransparentHwrWnd*>(At(j));

   200         ctrl->SetRect( TRect(curLeft, aRect.iTl.iY,

   201                               curLeft + boxWidth,

   202                               aRect.iBr.iY) );

   203         // Set guide line information

   204         TRect rect(TPoint(0,0), TSize(boxWidth, aRect.Height()));

   205         TInt arc = (rect.Width() < rect.Height())? rect.Width() : rect.Height();

   206         TInt unit = arc / 8;

   207 

   208         TRect toprect( rect.Width()/2 - unit*4, unit + aRect.iTl.iY,

   209                     rect.Width()/2 + unit*4, unit + aRect.iTl.iY );

   210         TRect bottomrect( rect.Width()/2 - unit*4, unit*7 + aRect.iTl.iY,

   211                     rect.Width()/2 + unit*4, unit*7 + aRect.iTl.iY);

   212 

   213 

   214         // default black

   215         }

   216 

   217     RefreshUI();

   218     }

   219 

   220 // -----------------------------------------------------------------------------

   221 // CPeninputHwrBoxGroup::SetBoxBackColor

   222 // (other items were commented in a header).

   223 // -----------------------------------------------------------------------------

   224 //

   225 void CPeninputHwrBoxGroup::SetBoxBackColor(const TRgb& aCol)

   226     {

   227     for( TInt j = 0; j < NumOfControls(); j++ )

   228         {

   229         At(j)->SetBkColor(aCol);

   230         }

   231     }

   232 

   233 // -----------------------------------------------------------------------------

   234 // CPeninputHwrBoxGroup::SetBoxFrameColor

   235 // (other items were commented in a header).

   236 // -----------------------------------------------------------------------------

   237 //

   238 void CPeninputHwrBoxGroup::SetBoxFrameColor(const TRgb& aCol)

   239     {

   240     for( TInt j = 0; j < NumOfControls(); j++ )

   241         {

   242         static_cast<CTransparentHwrWnd*>(At(j))->SetFrameCol(aCol);

   243         }

   244     }

   245 

   246 // -----------------------------------------------------------------------------

   247 // CPeninputHwrBoxGroup::SetStrokEndMark

   248 // Iterate to set each HWR box stroke end mark.

   249 // (other items were commented in a header).

   250 // -----------------------------------------------------------------------------

   251 //

   252 void CPeninputHwrBoxGroup::SetStrokeEndMark(const TPoint& aEndMard)

   253     {

   254     for( TInt j = 0; j < NumOfControls(); j++ )

   255         {

   256         static_cast<CTransparentHwrWnd*>(At(j))->SetStrokeEndMark(aEndMard);

   257         }

   258     }

   259 

   260 // -----------------------------------------------------------------------------

   261 // CPeninputHwrBoxGroup::SetTransparency

   262 // (other items were commented in a header).

   263 // -----------------------------------------------------------------------------

   264 //

   265 void CPeninputHwrBoxGroup::SetTransparency(const TUint8 aActiveTrans, const TUint8 aInactiveTrans)

   266     {

   267 #ifdef __ALPHA_TRANCEPARENCY__

   268     iActiveTrans = aActiveTrans;

   269     iInactiveTrans = aInactiveTrans;

   270 #else

   271     iActiveTrans = 255 - aActiveTrans;

   272     iInactiveTrans = 255 - aInactiveTrans;

   273 #endif

   274 

   275     for( TInt j = 0; j < NumOfControls(); j++ )

   276         {

   277         if( At(j) != iActiveBox)

   278             {

   279             static_cast<CTransparentHwrWnd*>(At(j))->SetWndTransparencyFactor(iInactiveTrans);

   280             }

   281         else

   282             {

   283             static_cast<CTransparentHwrWnd*>(At(j))->SetWndTransparencyFactor(iActiveTrans);

   284             }

   285         }

   286     }

   287 

   288 // -----------------------------------------------------------------------------

   289 // from base class MEventObserver

   290 // CPeninputHwrBoxGroup::HandleEvent

   291 // Clear current handwriting trail if any.

   292 // (other items were commented in a header).

   293 // -----------------------------------------------------------------------------

   294 //

   295 void CPeninputHwrBoxGroup::HandleControlEvent(TInt aEventType,

   296                                            CFepUiBaseCtrl* aCtrl,

   297                                            const TDesC& /*aEventData*/)

   298     {

   299     CTransparentHwrWnd* hwrWnd = static_cast<CTransparentHwrWnd*>( aCtrl );

   300 

   301     switch( aEventType )

   302         {

   303         case EEventHwrStrokeStarted:

   304             ReportEvent(aEventType);   // for DisableCaseChange

   305             OnStrokeStarted(hwrWnd);

   306             break;

   307         case EEventHwrStrokeFinished:

   308             OnStrokeFinished(hwrWnd);

   309             break;

   310         case EEventHwrCharacterTimerOut:

   311             ReportEvent(aEventType);   // for EnableCaseChange

   312             OnStrokeCharacterTimerOut(hwrWnd);

   313             break;

   314         case EEventHwrStrokeCanceled:

   315             ReportEvent(aEventType);   // for EnableCaseChange

   316             OnStrokeCanceled(hwrWnd);

   317             break;

   318         default:

   319             // not handle other event type

   320             break;

   321         }

   322     }

   323 

   324 // -----------------------------------------------------------------------------

   325 // CPeninputHwrBoxGroup::CPeninputHwrBoxGroup

   326 // C++ constructor.

   327 // (other items were commented in a header).

   328 // -----------------------------------------------------------------------------

   329 //

   330 CPeninputHwrBoxGroup::CPeninputHwrBoxGroup(CFepUiLayout* aUiLayout, TInt aBoxGroupId)

   331     : CControlGroup(aUiLayout, aBoxGroupId),

   332     iDimmed(EFalse)

   333     {

   334     }

   335 

   336 // -----------------------------------------------------------------------------

   337 // CPeninputHwrBoxGroup::ConstructL

   338 // Symbian secode phase constructor.

   339 // (other items were commented in a header).

   340 // -----------------------------------------------------------------------------

   341 //

   342 void CPeninputHwrBoxGroup::ConstructL(TInt aBoxCount)

   343     {

   344     //leave if invalid aBoxCount

   345     ASSERT( aBoxCount > 0 );

   346 

   347     //call base construct

   348     CControlGroup::ConstructL();

   349 

   350     //create two box hwr window

   351     for( TInt i = 0; i < aBoxCount; ++i )

   352         {

   353         CTransparentHwrWnd* aBox = CTransparentHwrWnd::NewL(TRect(),

   354                                                             UiLayout(),

   355                                                             0,

   356                                                             EFalse);

   357         CleanupStack::PushL( aBox );

   358         aBox->AddEventObserver( this );

   359         aBox->EnableTraceOutsideWindow(EFalse);

   360         AddControlL(aBox);

   361         CleanupStack::Pop(aBox); //aBox

   362        }

   363     }

   364 

   365 // -----------------------------------------------------------------------------

   366 // CPeninputHwrBoxGroup::SetWritingSpeed

   367 // Iterate to set each HWR box writting speed.

   368 // (other items were commented in a header).

   369 // -----------------------------------------------------------------------------

   370 //

   371 void CPeninputHwrBoxGroup::SetWritingSpeed(const TTimeIntervalMicroSeconds32& aCharDelay)

   372     {

   373     for( TInt j = 0; j < NumOfControls(); j++ )

   374         {

   375         CTransparentHwrWnd* hwrWnd = static_cast<CTransparentHwrWnd*>(At(j));

   376 

   377         if( hwrWnd != NULL )

   378             {

   379             hwrWnd->SetCharacterDelay(aCharDelay);

   380             }

   381         }

   382     }

   383 

   384 // -----------------------------------------------------------------------------

   385 // CPeninputHwrBoxGroup::SetStrokeDelay

   386 // Iterate to set each HWR box writting speed.

   387 // (other items were commented in a header).

   388 // -----------------------------------------------------------------------------

   389 //

   390 void CPeninputHwrBoxGroup::SetStrokeDelay(const TTimeIntervalMicroSeconds32& aCharDelay)

   391     {

   392     for( TInt j = 0; j < NumOfControls(); j++ )

   393         {

   394         CTransparentHwrWnd* hwrWnd = static_cast<CTransparentHwrWnd*>(At(j));

   395 

   396         if( hwrWnd != NULL )

   397             {

   398             hwrWnd->SetStrokeDelay(aCharDelay);

   399             }

   400         }

   401     }

   402 

   403 // -----------------------------------------------------------------------------

   404 // CPeninputHwrBoxGroup::SetBoxPenSize

   405 // Iterate to set each HWR box trail drawing pen size.

   406 // (other items were commented in a header).

   407 // -----------------------------------------------------------------------------

   408 //

   409 void CPeninputHwrBoxGroup::SetBoxPenSize(const TSize& aSize)

   410     {

   411     for( TInt j = 0; j < NumOfControls(); j++ )

   412         {

   413         At(j)->SetPenSize(aSize);

   414         }

   415     }

   416 

   417 // -----------------------------------------------------------------------------

   418 // CPeninputHwrBoxGroup::SetBoxPenColor

   419 // Iterate to set each HWR box trail drawing pen color.

   420 // (other items were commented in a header).

   421 // -----------------------------------------------------------------------------

   422 //

   423 void CPeninputHwrBoxGroup::SetBoxPenColor(const TRgb& aCol)

   424     {

   425     for( TInt j = 0; j < NumOfControls(); j++ )

   426         {

   427         At(j)->SetPenColor(aCol);

   428         }

   429     }

   430 // -----------------------------------------------------------------------------

   431 // CPeninputHwrBoxGroup::OnStrokeStarted

   432 // Handle EEventHwrStrokeStarted event.

   433 // (other items were commented in a header).

   434 // -----------------------------------------------------------------------------

   435 //

   436 void CPeninputHwrBoxGroup::OnStrokeStarted(CTransparentHwrWnd* aBoxFrom)

   437     {

   438     TBool refresh = EFalse;

   439 

   440     if( iActiveBox == NULL )

   441         {

   442         //change state from not writing to begin writing

   443         iActiveBox = aBoxFrom;

   444         refresh = ETrue;

   445 

   446         ReportEvent(EPeninputLayoutHwrEventBeginWriting);

   447         //set current box transparency

   448         iActiveBox->SetWndTransparencyFactor(iActiveTrans);

   449         }

   450     else

   451         {

   452         if( iActiveBox != aBoxFrom )

   453             {

   454             // current active box will turn into inactive state

   455             iActiveBox->SetWndTransparencyFactor(iInactiveTrans);

   456             // user switches to another box

   457             if( iActiveBox->HasNewTrace() )

   458                 {

   459                 OnStrokeFinished(iActiveBox);

   460                 }

   461             // handler of EPeninputLayoutHwrEventNewWriting submit default candidate

   462             // reset state

   463             ReportEvent(EPeninputLayoutHwrEventNewWriting);

   464             // clear writing of the last box

   465             CancelWriting();

   466 

   467             iActiveBox = aBoxFrom;

   468             refresh = ETrue;

   469 

   470             //set current box transparency

   471             iActiveBox->SetWndTransparencyFactor(iActiveTrans);

   472             }

   473         else

   474             {

   475             ReportEvent(EPeninputLayoutHwrEventBeginWriting);

   476             }

   477         }

   478 

   479     if( refresh )

   480         {

   481         // only active box need update

   482         // inactive box is already update by CancelWriting

   483         RefreshUI(iActiveBox);

   484         }

   485     }

   486 

   487 // -----------------------------------------------------------------------------

   488 // CPeninputHwrBoxGroup::StrokeStrokeFinished

   489 // Handle EEventHwrStrokeFinished event.

   490 // (other items were commented in a header).

   491 // -----------------------------------------------------------------------------

   492 //

   493 void CPeninputHwrBoxGroup::OnStrokeFinished(CTransparentHwrWnd* /* aBoxFrom */)

   494     {

   495     // Get stroke list is called by event handler

   496     TPtrC ptr;

   497     RArray<TPoint>* strokeList = const_cast<RArray<TPoint>* >(&(StrokeList()));

   498     ptr.Set(reinterpret_cast<TText*>(strokeList), sizeof(strokeList)/sizeof(TUint16));

   499     ReportEvent(EPeninputLayoutHwrEventEndStroke, ptr);

   500     }

   501 

   502 // -----------------------------------------------------------------------------

   503 // CPeninputHwrBoxGroup::StrokeCharacterTimerOut

   504 // Handle EEventHwrCharacterTimerOut event.

   505 // (other items were commented in a header).

   506 // -----------------------------------------------------------------------------

   507 //

   508 void CPeninputHwrBoxGroup::OnStrokeCharacterTimerOut(CTransparentHwrWnd* aBoxFrom)

   509     {

   510     aBoxFrom->SetWndTransparencyFactor(iInactiveTrans);

   511     ReportEvent(EPeninputLayoutHwrEventEndWriting);

   512 

   513     if( iActiveBox == aBoxFrom )

   514         {

   515         iActiveBox = NULL;

   516         }

   517 

   518     RefreshUI(aBoxFrom);

   519     }

   520 

   521 // -----------------------------------------------------------------------------

   522 // CPeninputHwrBoxGroup::OnStrokeCanceled

   523 // Handle EEventHwrStrokeCanceled event.

   524 // (other items were commented in a header).

   525 // -----------------------------------------------------------------------------

   526 //

   527 void CPeninputHwrBoxGroup::OnStrokeCanceled(const CTransparentHwrWnd* aBoxFrom)

   528     {

   529     if( iActiveBox == aBoxFrom )

   530         {

   531         iActiveBox = NULL;

   532         }

   533     }

   534 // -----------------------------------------------------------------------------

   535 // CPeninputHwrBoxGroup::RefreshUI

   536 // Explicit refresh HWR boxes UI.

   537 // (other items were commented in a header).

   538 // -----------------------------------------------------------------------------

   539 //

   540 void CPeninputHwrBoxGroup::RefreshUI(CTransparentHwrWnd* aBox)

   541     {

   542     if( aBox == NULL )

   543         {

   544         if( Hiden() )

   545             {

   546             return;

   547             }

   548 

   549         Draw();

   550         UpdateArea(Rect(), EFalse);

   551         }

   552     else

   553         {

   554         if( !aBox->Hiden() )

   555             {

   556             CTransparentHwrWnd* box = static_cast<CTransparentHwrWnd*>(aBox);

   557             box->Draw();

   558             UpdateArea(box->Rect(), EFalse);

   559             }

   560         }

   561     }

   562 

   563 // ---------------------------------------------------------------------------

   564 // CPeninputHwrBoxGroup::SetDimmed

   565 // Dim button

   566 // (other items were commented in a header).

   567 // ---------------------------------------------------------------------------

   568 //

   569 void CPeninputHwrBoxGroup::SetDimmed(TBool aDimFlag)

   570     {

   571     iDimmed = aDimFlag;

   572     }

   573 

   574 //End Of File