1 /*

     2 * Copyright (c) 2003-2006 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 CMIDChoiceGroup control container. Owns and manipulates

    15 *                the choicegroup model and creates / deletes the actual

    16 *                control as needed.

    17 *

    18 */

    19 

    20 

    21 #include <e32def.h>

    22 #include <e32err.h>

    23 #include <w32std.h>

    24 #include <gdi.h>

    25 #include <gulutil.h>

    26 

    27 #include <eiktxlbm.h>

    28 // CColumnListBoxData API

    29 #include <eikclbd.h>

    30 

    31 #include <aknenv.h>

    32 #include <aknconsts.h>

    33 #include <avkon.mbg>

    34 #include <aknPopup.h>

    35 #include <AknLayoutDef.h>

    36 #include <AknBidiTextUtils.h>

    37 #include <gulcolor.h>

    38 

    39 #include <skinlayout.cdl.h>

    40 #include <AknLayoutFont.h>

    41 #include <aknlayoutscalable_avkon.cdl.h> // LAF

    42 #include <AknsDrawUtils.h>// skin

    43 #include <AknsBasicBackgroundControlContext.h> //skin

    44 

    45 #ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

    46 #include <akntranseffect.h>

    47 #include <akntransitionutils.h>

    48 #endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

    49 

    50 // using MMIDBitmapImage API in NewElement and SetElement functions - setting icon to element

    51 #include <lcdgr.h>

    52 // macros definitions for resources

    53 #include <lcdui.rsg>

    54 #ifndef RD_SCALABLE_UI_V2

    55 #include "CMIDForm.h"

    56 #endif

    57 

    58 // API used in HandlePointerEventL function

    59 #include "CMIDDisplayable.h"

    60 

    61 #include "CMIDFont.h"

    62 // using CMIDUtils::CopyBitmapL in NewElement and SetElement functions - setting icon to element

    63 #include "CMIDUtils.h"

    64 #include "CMIDChoiceGroupControl.h"

    65 // needed for CMIDChoiceGroupItem API in several places

    66 #include "CMIDChoiceGroupItem.h"

    67 // using SetTitleL in DoPopupL function - setting popup title

    68 #include "CMIDItemLabel.h"

    69 // using GetPopupNoteController in ShowInfoPopup function - showing popup with text

    70 #include "CMIDPopupNoteController.h"

    71 

    72 

    73 #include <j2me/jdebug.h>

    74 

    75 // For disabling transition effects

    76 #include <aknlistloadertfx.h>

    77 #include <aknlistboxtfx.h>

    78 

    79 

    80 /** This macro is executed each time a trapped call returns an error code different than KErrNone */

    81 #undef  TRAP_INSTRUMENTATION_LEAVE

    82 #define TRAP_INSTRUMENTATION_LEAVE(aResult) DEBUG_INT2("In CMIDChoiceGroupControl.cpp, trapped method was called at line %D and got exception %D", __LINE__, aResult);

    83 

    84 

    85 // Constant used for calculation of ChoiceGroup, which is not in Form yet

    86 // (from eiklbx.cpp)

    87 const TInt KEikListBoxItemVGap = 6;

    88 

    89 

    90 CMIDChoiceGroupPopupList* CMIDChoiceGroupPopupList::NewL(CEikListBox* aListBox, TInt aCbaResource,

    91         AknPopupLayouts::TAknPopupLayouts aType)

    92 {

    93     CMIDChoiceGroupPopupList* self = new(ELeave) CMIDChoiceGroupPopupList;

    94     CleanupStack::PushL(self);

    95     self->ConstructL(aListBox, aCbaResource, aType);

    96     CleanupStack::Pop(self);

    97     return self;

    98 }

    99 

   100 CMIDChoiceGroupPopupList::~CMIDChoiceGroupPopupList()

   101 {

   102 }

   103 

   104 void CMIDChoiceGroupPopupList::ResizeList()

   105 {

   106     CAknPopupList::SetupWindowLayout(AknPopupLayouts::EMenuUnknownColumnWindow);

   107 }

   108 

   109 #ifdef RD_SCALABLE_UI_V2

   110 void CMIDChoiceGroupPopupList::HandlePointerEventL(const TPointerEvent& aPointerEvent)

   111 {

   112     if (aPointerEvent.iType == TPointerEvent::EButton1Down &&

   113             !Rect().Contains(aPointerEvent.iPosition))

   114     {

   115         AttemptExitL(EFalse);

   116     }

   117     else

   118     {

   119         CAknPopupList::HandlePointerEventL(aPointerEvent);

   120     }

   121 }

   122 #endif //RD_SCALABLE_UI_V2

   123 

   124 CMIDChoiceGroupPopupList::CMIDChoiceGroupPopupList()

   125 {

   126 }

   127 

   128 CMIDChoiceGroupControl::CMIDChoiceGroupControl(

   129     MMIDChoiceGroup::TChoiceType aType,

   130     CMIDChoiceGroupItem* aItem)

   131         : iType(aType),

   132         iItem(aItem)

   133 {

   134 }

   135 

   136 

   137 CMIDChoiceGroupControl::~CMIDChoiceGroupControl()

   138 {

   139     // Do not allow the listbox data to delete the icon

   140     // array. It will be deleted by the model.

   141     DeleteListBox(iListBox);

   142 

   143     // No need to delete iPopupList here. The popup list is created and deleted in DoPopupL().

   144     delete iModel;

   145 }

   146 

   147 

   148 // Constructs the model and adds any given elements into it.

   149 // NOTE that the actual control is not yet created, it comes

   150 // to life when the item is added to a form (that has a window

   151 // for the control to draw in). Constructing and storing the model

   152 // outside the actual control enables elements to be manipulated

   153 // (in Java code) even when the ChoiceGroup is not (yet) added to a form.

   154 void CMIDChoiceGroupControl::ConstructL(

   155     RArray<TPtrC>& aStringArray,

   156     RArray<MMIDImage*>& aImageArray)

   157 {

   158     // Create the listbox model

   159     iModel = new(ELeave) CMIDChoiceGroupModel(iType);

   160     iModel->ConstructL(iEikonEnv);

   161 

   162     // Start observing model events

   163     iModel->SetObserver(this);

   164 

   165     // Stuff any given arrays in the model

   166     PopulateModelL(aStringArray, aImageArray);

   167 

   168     UpdateMargins();

   169 

   170     SetComponentsToInheritVisibility(ETrue);

   171 

   172 #ifdef RD_SCALABLE_UI_V2

   173     SetAllowStrayPointers();

   174 #endif

   175 

   176 #ifdef RD_TACTILE_FEEDBACK

   177     iFeedback = MTouchFeedback::Instance();

   178     // Disabling default tactile feedback to prevent a 'double feedback' while tapping on focused item

   179     iFeedback->EnableFeedbackForControl(this, FALSE);

   180 #endif

   181 

   182 }

   183 

   184 

   185 // Creates the actual choicegroup control, sets all kinds of

   186 // properties and associates the model with the created control

   187 void CMIDChoiceGroupControl::CreateControlL(

   188     const CCoeControl* aParent,

   189     const TRect& aRect)

   190 {

   191     // Model should be created before the control (this is true for

   192     // popup as well)

   193     ASSERT(iModel);

   194 

   195     // In dynamic resolution case store the current item index, so that it can be

   196     // restored once the listbox is recreated

   197     TInt currentItem = KErrNotFound;

   198     if (iListBox)

   199     {

   200         currentItem = iListBox->View()->CurrentItemIndex();

   201     }

   202 

   203     DeleteControl();

   204     ASSERT(!iListBox);

   205 

   206     // Set parent to the existing (form) window and use the rect given

   207     SetContainerWindowL(*aParent);

   208     SetRect(aRect);

   209 

   210     UpdateMargins();

   211 

   212     // If this is a popup, there's nothing to else create really

   213     if (IsPopup())

   214     {

   215         return;

   216     }

   217 

   218     //in case skin or resolution has changed

   219     iModel->ReConstructSelectionIconsL();

   220     iModel->UpdateIconArrayL();

   221 

   222     iListBox = CreateListBoxL(aParent);

   223 

   224     // Disable transition effects for iListBox, this is needed to get

   225     // rid of artifacts caused by transition effects when list box controls

   226     // are scrolled up/down.

   227     CWindowGc* gc = iListBox->View()->ItemDrawer()->Gc();

   228     MAknListBoxTfx* transApi = CAknListLoader::TfxApi(gc);

   229     if (transApi)

   230     {

   231         transApi->EnableEffects(EFalse);

   232     }

   233 

   234     // setup listbox

   235     iListBox->SetListBoxObserver(this);

   236     iListBox->SetRect(ListBoxRect(Rect()));

   237 

   238     if (currentItem != KErrNotFound)

   239     {

   240         iListBox->View()->SetCurrentItemIndex(currentItem);

   241     }

   242 

   243     // Ready to draw

   244     ActivateL();

   245 }

   246 

   247 

   248 // Deletes the actual listbox control (when item is removed from a form)

   249 // and disassociates the model from the control.

   250 // Maintains the model so that elements can be accessed even

   251 // if the item is not attached to a form

   252 void CMIDChoiceGroupControl::DeleteControl()

   253 {

   254     ClosePopup();

   255 

   256     // Gets rid of the listbox when choicegroup is removed from

   257     // a form, but does not yet kill the model (ie elements that

   258     // may have been added)

   259     DeleteListBox(iListBox);

   260 

   261     // Set to null, otherwise destructor will double-delete

   262     iListBox = NULL;

   263 }

   264 

   265 

   266 void CMIDChoiceGroupControl::HiliteFirstElement(TBool aEnableHighlight)

   267 {

   268     if (iListBox)

   269     {

   270         iListBox->View()->SetCurrentItemIndex(0);

   271         EnableListHighlight(aEnableHighlight);

   272     }

   273 }

   274 

   275 void CMIDChoiceGroupControl::HiliteLastElement(TBool aEnableHighlight)

   276 {

   277     if (iListBox)

   278     {

   279         iListBox->View()->SetCurrentItemIndex(iListBox->View()->BottomItemIndex());

   280         EnableListHighlight(aEnableHighlight);

   281     }

   282 }

   283 

   284 void CMIDChoiceGroupControl::EnableListHighlight(TBool aEnable)

   285 {

   286     if (iListBox)

   287     {

   288         CListItemDrawer* drawer = iListBox->View()->ItemDrawer();

   289 

   290         if (aEnable)

   291         {

   292             drawer->ClearFlags(CListItemDrawer::EDisableHighlight);

   293         }

   294         else

   295         {

   296             drawer->SetFlags(CListItemDrawer::EDisableHighlight);

   297 

   298 #ifdef RD_SCALABLE_UI_V2

   299             // If the focus is dragged to another form item, the highlight is

   300             // disabled in this cg. Set the flag to true to be sure that selection is not

   301             // changed if the pointer up happens on same cg element where the drag started.

   302             iPointerDragHasStarted = ETrue;

   303 #endif

   304         }

   305 

   306         TRAP_IGNORE(iListBox->View()->UpdateSelectionL(CListBoxView::ESingleSelection));

   307     }

   308 }

   309 

   310 // msk

   311 void CMIDChoiceGroupControl::CurrentItemChanged()

   312 {

   313     if (iItem)

   314     {

   315         // delegate the information to the item; commands may need to be updated

   316         iItem->UpdateCommands();

   317     }

   318     // redraw

   319     DrawNow();

   320 }

   321 

   322 // msk

   323 TBool CMIDChoiceGroupControl::IsCurrentItemSelected()

   324 {

   325     if (iListBox)

   326     {

   327         return IsSelected(iListBox->View()->CurrentItemIndex());

   328     }

   329 

   330     return EFalse;

   331 }

   332 

   333 // msk

   334 // Posts always the java event

   335 void CMIDChoiceGroupControl::ToggleCurrentItemSelectionL()

   336 {

   337     if (iListBox)

   338     {

   339         // SelectElementL must not be called if the unselection of the selected element is

   340         // attempted in exclusive choice group because it would cause the itemStateChanged event.

   341         if (iType != MMIDChoiceGroup::EExclusive || !IsCurrentItemSelected())

   342         {

   343 #ifdef RD_JAVA_S60_RELEASE_9_2

   344             if (Form() && !Form()->PhysicsScrolling())

   345             {

   346 #endif // RD_JAVA_S60_RELEASE_9_2             

   347                 TInt currentIndex = iListBox->View()->CurrentItemIndex();

   348                 SelectElementL(currentIndex, !IsSelected(currentIndex), ETrue);

   349 #ifdef RD_JAVA_S60_RELEASE_9_2

   350             }

   351 #endif // RD_JAVA_S60_RELEASE_9_2

   352         }

   353     }

   354 }

   355 

   356 // returns the numbers of elements in this choice group

   357 TInt CMIDChoiceGroupControl::NumberOfElements() const

   358 {

   359     ASSERT(iModel);

   360     return iModel->NumberOfItems();

   361 }

   362 

   363 // --- CMIDChoiceGroupItem delegated methods (java Choice interface)

   364 

   365 

   366 // Inserts a new element in the choice

   367 void CMIDChoiceGroupControl::InsertElementL(TInt aIndex, const TDesC& aText, MMIDImage* aImage)

   368 {

   369     ASSERT(iModel);

   370 

   371     CMIDChoiceGroupElement* pElement = NewElementLC(aText, aImage);

   372 

   373     // Reserve space for the new element

   374     iModel->SetReserveL(iModel->NumberOfItems() + 1);

   375 

   376     // Stuff it in

   377     iModel->InsertElementL(aIndex, pElement);

   378 

   379     CListBoxView* view = NULL;

   380 

   381     if (iListBox)

   382     {

   383         view = iListBox->View();

   384     }

   385     else if (iPopupList)

   386     {

   387         view = iPopupList->ListBox()->View();

   388     }

   389 

   390     if (view)

   391     {

   392         TInt current = view->CurrentItemIndex();

   393 

   394         if (current >= aIndex && current < (iModel->NumberOfItems() - 1))

   395         {

   396             // If element was inserted before the highlighted element,

   397             // move the highlight so that it stays in the same element

   398             // as before insertion.

   399             view->SetCurrentItemIndex(++current);

   400         }

   401     }

   402 

   403     CleanupStack::Pop(pElement);

   404 }

   405 

   406 

   407 // Deletes an element from the choice

   408 void CMIDChoiceGroupControl::DeleteElementL(TInt aIndex)

   409 {

   410     ASSERT(iModel);

   411     TInt current = 0;

   412     if (iListBox)

   413     {

   414         current = iListBox->View()->CurrentItemIndex();

   415     }

   416     iModel->DeleteElementL(aIndex);

   417 

   418     if (iListBox && current != KErrNotFound &&

   419             iModel->NumberOfItems() > 0 &&

   420             aIndex <= current)

   421     {

   422         if (current < iModel->NumberOfItems())

   423         {

   424             if (current > 0 && aIndex < current)

   425             {

   426                 // Element was deleted before the current item, decrease

   427                 // current so that highlight stays in the same element

   428                 // as before the deletion

   429                 --current;

   430             }

   431             iListBox->SetCurrentItemIndex(current);

   432         }

   433         else

   434         {

   435             iListBox->SetCurrentItemIndex(iModel->NumberOfItems()-1);

   436         }

   437     }

   438 

   439 }

   440 

   441 

   442 // Deletes all elements

   443 void CMIDChoiceGroupControl::DeleteAllL()

   444 {

   445     ASSERT(iModel);

   446     if (iListBox)

   447     {

   448         iListBox->SetCurrentItemIndex(0);

   449     }

   450     iModel->DeleteAllL();

   451 }

   452 

   453 

   454 // Sets properties of element at <aIndex>

   455 void CMIDChoiceGroupControl::SetElementL(TInt aIndex, const TDesC& aText, MMIDImage* aImage)

   456 {

   457     ASSERT(iModel);

   458 

   459     if (aImage)

   460     {

   461         MMIDBitmapImage* bitmapImage = aImage->BitmapImage();

   462 

   463         CFbsBitmap* bitmap = CMIDUtils::CopyBitmapL(bitmapImage->ColorBitmap());

   464         CleanupStack::PushL(bitmap);

   465 

   466         CFbsBitmap* mask = NULL;

   467         if (bitmapImage->AlphaBitmap())

   468         {

   469             TDisplayMode alphaDisplayMode = bitmapImage->AlphaBitmap()->DisplayMode();

   470             TBool invert = alphaDisplayMode == EGray2 ? ETrue : EFalse;

   471             mask = bitmapImage->CreateAlphaBitmapL(alphaDisplayMode, invert);

   472         }

   473 

   474         CleanupStack::PushL(mask);

   475 

   476         iModel->SetElementL(aIndex, aText, bitmap, mask);

   477 

   478         CleanupStack::Pop(mask);

   479         CleanupStack::Pop(bitmap);

   480 

   481         bitmapImage->RemoveRef();

   482     }

   483     else

   484     {

   485         iModel->SetElementL(aIndex, aText, NULL, NULL);

   486     }

   487 }

   488 

   489 

   490 // Sets selection state of element at <aIndex>

   491 // This method is also declared in MMIDChoiceGroup. It's implementation

   492 // in CMIDChoiceGroupItem just simply calls this method.

   493 void CMIDChoiceGroupControl::SelectElementL(TInt aIndex, TBool aSelected)

   494 {

   495     SelectElementL(aIndex, aSelected, EFalse);

   496 }

   497 

   498 

   499 // Returns selection state of element at <aIndex>

   500 TBool CMIDChoiceGroupControl::IsSelected(TInt aIndex)

   501 {

   502     ASSERT(iModel);

   503     CMIDChoiceGroupElement* pElement = iModel->ElementAt(aIndex);

   504 

   505     if (pElement)

   506     {

   507         return pElement->IsSelected();

   508     }

   509 

   510     return EFalse;

   511 }

   512 

   513 

   514 // Sets element text font

   515 void CMIDChoiceGroupControl::SetFontL(TInt /*aIndex*/, MMIDFont* /*aFont*/)

   516 {

   517     ASSERT(iModel);

   518 }

   519 

   520 

   521 // Sets element text fit policy

   522 void CMIDChoiceGroupControl::SetFitPolicyL(TInt /*aFitPolicy*/)

   523 {

   524     ASSERT(iModel);

   525 }

   526 

   527 

   528 // --- from MMIDChoiceGroupModelObserver ---

   529 

   530 // Called when the model has changed. Based on the change, will cause

   531 // just a redraw of the control, or size recalculation

   532 void CMIDChoiceGroupControl::HandleChoiceGroupModelEventL(

   533     CMIDChoiceGroupModel* aModel,

   534     TChoiceGroupModelEvent aEvent)

   535 {

   536     ASSERT(iModel);

   537 

   538     // If not from our model, ignore

   539     if (aModel != iModel)

   540     {

   541         return;

   542     }

   543 

   544     // Assume everything needs to be done (makes the switch shorter)

   545     TBool bRedraw = ETrue;

   546     TBool bResize = ETrue;

   547 

   548     // Act upon the event, resize and redraw control as necessary

   549     switch (aEvent)

   550     {

   551     case EElementAdded:

   552         if (iListBox)

   553         {

   554             iListBox->HandleItemAdditionL();

   555         }

   556         break;

   557     case EElementDeleted:

   558         if (iListBox)

   559         {

   560             iListBox->HandleItemRemovalL();

   561         }

   562         break;

   563     case EUpdateEnded:

   564         if (iListBox)

   565         {

   566             iListBox->Reset();

   567         }

   568         break;

   569     case EElementModified:

   570         // after the LAF changes the icon column is dynamic, so redo the setup for the listbox

   571         // the columns by calling SizeChanged(). bResize is set to false because the relayout of

   572         // of the whole form is not needed.

   573         SizeChanged();

   574         bResize = EFalse;

   575         break;

   576     case EElementSelected:

   577         // Just a redraw will do

   578         bResize = EFalse;

   579         break;

   580     case EUpdateStarted:

   581     default:

   582         // No redraw, no resize. Do nothing.

   583         bRedraw = EFalse;

   584         bResize = EFalse;

   585         break;

   586     }

   587 

   588     // If popup is opened, it is handled separately

   589     if (iPopupList)

   590     {

   591         UpdatePopupListAppearanceL(aEvent);

   592     }

   593 

   594     // Reporting ESizeChanged event to iItem is not needed since the request

   595     // to update the form comes from java side (CMIDForm::RefreshItem(TInt) is called)

   596     // when items are added to or removed from choice group. See ChoiceGroup.java.

   597     // Redraw if needed and size has not changed, size change will

   598     // cause a form layout and redraw anyway.

   599     if (bRedraw && !bResize)

   600     {

   601         // Do safe redraw

   602         if (!IsPopup() && iListBox && iListBox->DrawableWindow())

   603         {

   604             iListBox->DrawDeferred();

   605         }

   606         else

   607         {

   608             // Seems to be a popup - redraw myself

   609             if (DrawableWindow())

   610             {

   611                 DrawDeferred();

   612             }

   613         }

   614     }

   615 }

   616 

   617 

   618 // --- from MEikListBoxObserver ---

   619 // Handles choice listbox events (as in selection)

   620 void CMIDChoiceGroupControl::HandleListBoxEventL(CEikListBox* aControl, TListBoxEvent aEventType)

   621 {

   622     if (aControl != iListBox)

   623     {

   624         return;

   625     }

   626 

   627     ASSERT(iModel);

   628 

   629     switch (aEventType)

   630     {

   631         // These should all cause a selection change

   632     case MEikListBoxObserver::EEventEnterKeyPressed:

   633     case MEikListBoxObserver::EEventItemActioned:

   634         ToggleCurrentItemSelectionL();

   635         break;

   636 

   637     default:

   638         break;

   639     }

   640 }

   641 

   642 

   643 // Offers key events to the listbox, or handles popup events here

   644 TKeyResponse CMIDChoiceGroupControl::OfferKeyEventL(

   645     const TKeyEvent& aKeyEvent,

   646     TEventCode aType)

   647 {

   648     TKeyResponse resp = EKeyWasNotConsumed;

   649 

   650     // Pop popup if needed, otherwise do nothing (if popup)

   651     if (IsPopup())

   652     {

   653         if ((aKeyEvent.iCode == EKeyOK) || (aKeyEvent.iCode == EKeyEnter))

   654         {

   655             // It's a popup, and the OK key was pressed on it - start poppin'

   656             DoPopupL();

   657             resp = EKeyWasConsumed;

   658         }

   659 

   660         return resp;

   661     }

   662 

   663     // Not a popup then, handle some keys in clever ways

   664 

   665     // Save the currently selected item (if exclusive choice)

   666     TInt oldSelected = iModel->SelectedElement();

   667     TInt oldCurrentIndex = -1;

   668 

   669     if (iListBox)

   670     {

   671         oldCurrentIndex = iListBox->View()->CurrentItemIndex();

   672         // Let the listbox take a shot at the key

   673         resp = iListBox->OfferKeyEventL(aKeyEvent, aType);

   674     }

   675 

   676     // If click (enter) on an already selected item in an exclusive choice,

   677     // do not consume the key. This allows the form to display a context menu

   678     if ((iType == MMIDChoiceGroup::EExclusive) &&

   679             ((aKeyEvent.iCode == EKeyOK) || (aKeyEvent.iCode == EKeyEnter)) &&

   680             ((oldSelected != -1) || (oldSelected == -1 && oldCurrentIndex == -1)) &&

   681             (oldSelected == iModel->SelectedElement()))

   682     {

   683         // Do not consume the key, so that form can pop a menu

   684         CMIDDisplayable& displayable = iItem->Form()->CurrentDisplayable();

   685         TInt cntOpt = displayable.NumCommandsForOkOptionsMenu();

   686 

   687         // set first command from command list,

   688         // if command list <= 0 then command sets NULL

   689         const CMIDCommand* command = (iItem->CommandList()->Count() > 0 ?

   690                                       iItem->CommandList()->At(0).iCommand :

   691                                       NULL);

   692 

   693         // for default command will run ProcessCommandL( KItemCommandIdBase + 1 )

   694         if (iItem->DefaultCommand())

   695         {

   696             displayable.ProcessCommandL(iItem->CommandList()->CommandOffset() +

   697                                         iItem->CommandList()->FindCommandIndex(iItem->DefaultCommand()));

   698 

   699             resp =  EKeyWasConsumed;

   700         }

   701         else

   702         {

   703             // if ( cntOpt > 1 ) will run menu, else execute ProcessCommandL( CommandOffset )

   704             if (cntOpt > 1)

   705             {

   706                 displayable.MenuHandler()->ShowMenuL(CMIDMenuHandler::EOkMenu);

   707                 resp = EKeyWasConsumed;

   708             }

   709             else if (command && command->CommandType() != MMIDCommand::EBack &&

   710                      command->CommandType() != MMIDCommand::ECancel)

   711             {

   712                 displayable.ProcessCommandL(iItem->CommandList()->CommandOffset());

   713                 resp =  EKeyWasConsumed;

   714             }

   715             else

   716             {

   717                 displayable.ProcessCommandL(displayable.MainCommandList()->CommandOffset());

   718                 resp =  EKeyWasConsumed;

   719             }

   720         }

   721     }

   722     // If the event caused current item change, and the new current item

   723     // is outside the visible area, should request the form to scroll a bit.

   724     // Current item has not changed, if the key was not consumed

   725     if (((aKeyEvent.iCode == EKeyUpArrow) ||

   726             (aKeyEvent.iCode == EKeyDownArrow)) &&

   727             (resp != EKeyWasNotConsumed))

   728     {

   729         // Calc scroll need and request one, if necessary

   730         RequestScrollIfNeededL();

   731     }

   732 

   733     if (iListBox && (oldCurrentIndex != iListBox->View()->CurrentItemIndex()))

   734     {

   735         CurrentItemChanged();

   736 #ifdef RD_JAVA_S60_RELEASE_9_2

   737         ShowInfoPopup();

   738 #endif // RD_JAVA_S60_RELEASE_9_2        

   739     }

   740     return resp;

   741 }

   742 

   743 #ifdef RD_SCALABLE_UI_V2

   744 void CMIDChoiceGroupControl::HandlePointerEventL(const TPointerEvent& aPointerEvent)

   745 {

   746     if (!AknLayoutUtils::PenEnabled() || !iListBox)

   747     {

   748 

   749 #ifdef RD_TACTILE_FEEDBACK

   750         // this is to give tactile feedback when a POPUP type CG is focused

   751         // and user taps it to open the popup list

   752         // if focus is changing, tactile feedback is given already in Form

   753         if (IsPopup() &&

   754                 aPointerEvent.iType == TPointerEvent::EButton1Down &&

   755                 !iItem->Form()->IsFocusChangingWithPen())

   756         {

   757 #ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

   758             iFeedback->InstantFeedback(ETouchFeedbackList);

   759 #else

   760             iFeedback->InstantFeedback(ETouchFeedbackBasic);

   761 #endif // RD_JAVA_ADVANCED_TACTILE_FEEDBACK

   762         }

   763 #endif // RD_TACTILE_FEEDBACK

   764 

   765         return;

   766     }

   767 

   768     TInt nOldCurrent = iListBox->View()->CurrentItemIndex();

   769     TBool oldSelected = IsSelected(nOldCurrent);

   770 

   771     switch (aPointerEvent.iType)

   772     {

   773     case TPointerEvent::EDrag:

   774         // In order to enable highlight moving inside the choice group when the focus is dragged

   775         // on the form, forward drag events directly to listbox. This is needed beacuse it is not

   776         // always possible to set the wanted grabbing state for CMIDChoiceGroupListBox.

   777         // See also CCoeControl implementation of pointer event handling.

   778         iListBox->HandlePointerEventL(aPointerEvent);

   779         break;

   780     case TPointerEvent::EButtonRepeat:

   781         // EButtonRepeat events are requested by form. These events come only when pointer

   782         // is dragged out of main pane area.

   783         TimedScroll(aPointerEvent.iPosition.iY < 0 ? CMIDForm::EUp : CMIDForm::EDown);

   784         break;

   785     case TPointerEvent::EButton1Down:

   786     {

   787 #ifdef RD_JAVA_S60_RELEASE_9_2

   788         // Hide pop-up note if visible.

   789         CMIDForm* form = iItem->Form();

   790         if (form)

   791         {

   792             form->GetPopupNoteController()->HidePopup();

   793         }

   794 #endif // RD_JAVA_S60_RELEASE_9_2

   795 

   796         iPointerDragHasStarted = EFalse;

   797 

   798 #ifdef RD_TACTILE_FEEDBACK

   799         // give tactile feedback here on ListBox only if it is already focused

   800         // if focus is changing, tactile feedback is given already in Form

   801         if (!iItem->Form()->IsFocusChangingWithPen())

   802         {

   803 #ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

   804             iFeedback->InstantFeedback(ETouchFeedbackList);

   805 #else

   806             iFeedback->InstantFeedback(ETouchFeedbackBasic);

   807 #endif // RD_JAVA_ADVANCED_TACTILE_FEEDBACK

   808         }

   809 #endif // RD_TACTILE_FEEDBACK

   810         CCoeControl::HandlePointerEventL(aPointerEvent);

   811 

   812         if (iListBox->Rect().Contains(aPointerEvent.iPosition) &&

   813                 !iItem->Form()->IsScrolledOnPointerDown())

   814         {

   815             TRect mainPane;

   816             AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainPane);

   817 

   818             TRect rect = iListBox->HighlightRect(); // highlight rect is in propotion to screen,

   819             rect.Move(0, -mainPane.iTl.iY);         // move it so that it's in propotion to main pane

   820 

   821             // Scroll the form so that highlighted list element becomes fully visible

   822             TInt scroll = 0;

   823             if (rect.iBr.iY > mainPane.Height())

   824             {

   825                 scroll = mainPane.Height() - rect.iBr.iY;

   826             }

   827             else if (rect.iTl.iY < 0)

   828             {

   829                 scroll = -rect.iTl.iY;

   830             }

   831 

   832             if (scroll != 0)

   833             {

   834                 ReportEventL(MMIDChoiceGroupControlObserver::EScrollRequest,

   835                              (TAny*)scroll);

   836             }

   837         }

   838         break;

   839     }

   840     case TPointerEvent::EButton1Up:

   841     {

   842 #ifdef RD_JAVA_S60_RELEASE_9_2

   843         // If up event comes when long tap has been detected, then

   844         // just forward the pointer event. In that case we do not

   845         // want to change selection, but update the listbox visually.

   846         // This is performed when pop-up menu is closed and we want to

   847         // hide listbox highlight.

   848         if (iItem->LongTapDetected())

   849         {

   850             CCoeControl::HandlePointerEventL(aPointerEvent);

   851             return;

   852         }

   853 #endif // RD_JAVA_S60_RELEASE_9_2

   854 #ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

   855         switch (iType)

   856         {

   857         case MMIDChoiceGroup::EMultiple:

   858             iFeedback->InstantFeedback(ETouchFeedbackCheckbox);

   859             break;

   860         default:

   861             iFeedback->InstantFeedback(ETouchFeedbackList);

   862             break;

   863         }

   864 #endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

   865 

   866         CCoeControl::HandlePointerEventL(aPointerEvent);

   867 

   868         TInt idx;

   869 

   870         // Allow toggling the selection also in a case when form has been scrolled on pointer down event,

   871         // if the pointer up happens still on cg item area.

   872         TBool toggleAfterScroll = iItem->Form()->IsScrolledOnPointerDown() &&

   873                                   iItem->Rect().Contains(aPointerEvent.iPosition);

   874 

   875         if (!iPointerDragHasStarted &&

   876                 (iListBox->View()->XYPosToItemIndex(aPointerEvent.iPosition, idx) ||

   877                  toggleAfterScroll))

   878         {

   879             ToggleCurrentItemSelectionL();

   880         }

   881 

   882         // If selected item is tapped in the Exclusive ChoiceGroup

   883         // then possible default Command is executed.

   884         if (iItem->DefaultCommand() && !iItem->Form()->PhysicsScrolling())

   885         {

   886             if (iType == MMIDChoiceGroup::EExclusive && oldSelected

   887                     && !iFocusChangingWithPen && !iItem->Form()->IsFocusChangingWithPen())

   888             {

   889                 iItem->Form()->CurrentDisplayable().ProcessCommandL(iItem->DefaultCommand());

   890             }

   891         }

   892 

   893         iFocusChangingWithPen = EFalse;

   894         break;

   895     }

   896     default:

   897         CCoeControl::HandlePointerEventL(aPointerEvent);

   898         break;

   899     }

   900 

   901     // msk: notify if the current index has changed

   902     if (nOldCurrent != iListBox->View()->CurrentItemIndex())

   903     {

   904         iFocusChangingWithPen = ETrue;

   905         CurrentItemChanged();

   906         if (aPointerEvent.iType == TPointerEvent::EDrag)

   907         {

   908             iPointerDragHasStarted = ETrue;

   909         }

   910     }

   911 }

   912 

   913 #endif //RD_SCALABLE_UI_V2

   914 

   915 // Count component controls in this compound control

   916 TInt CMIDChoiceGroupControl::CountComponentControls() const

   917 {

   918     if (iListBox)

   919         return 1;

   920 

   921     return 0;

   922 }

   923 

   924 

   925 // Return requested component control

   926 CCoeControl* CMIDChoiceGroupControl::ComponentControl(TInt /*aIndex*/) const

   927 {

   928     return iListBox;

   929 }

   930 

   931 

   932 /** Called when the size adjustment need is detected, the item notified and

   933     the item caused the form to relayout. The form will calc the new

   934     position of the item and cause sizechanged to be called - this is

   935     this controls chance to update its position.

   936 

   937 */

   938 void CMIDChoiceGroupControl::SizeChanged()

   939 {

   940     if (iListBox)

   941     {

   942         iListBox->SetRect(ListBoxRect(Rect()));

   943         TRAP_IGNORE(SetupColumnsL(iListBox->ItemDrawer()->ColumnData()));

   944     }

   945 

   946     if (IsPopup())

   947     {

   948         TAknLayoutRect layoutRect; // used only temporarily for getting the layout for popup item's icons and text

   949 

   950         // Rect() includes also the margins so it cannot be used directly when layouting the popup icons and text.

   951         // popupRect is the rect that is available for the closed popup item (i.e. it does not include the margins).

   952         // popupRect is used as a parent rect when updating the rects of the popup icons and text.

   953         layoutRect.LayoutRect(Rect(),

   954                               AknLayoutScalable_Avkon::form2_midp_field_choice_group_pane().LayoutLine());

   955         TRect popupRect = layoutRect.Rect();

   956 

   957         // Layout for the element icon

   958         layoutRect.LayoutRect(popupRect,

   959                               AknLayoutScalable_Avkon::list_single_midp_graphic_pane_g4_cp(1).LayoutLine());

   960         iPopupIconRect = layoutRect.Rect();

   961 

   962         // Layout for the text

   963 

   964         iPopupTextLayout.LayoutText(popupRect,

   965                                     AknLayoutScalable_Avkon::list_single_midp_graphic_pane_t1_cp(1).LayoutLine());

   966     }

   967 }

   968 

   969 void CMIDChoiceGroupControl::PositionChanged()

   970 {

   971     if (IsPopup())

   972     {

   973         SizeChanged();

   974     }

   975 }

   976 

   977 // Calculates and returns the minimum size required by the control

   978 // The size is based on the number of items in the listbox, so that

   979 // the listbox does not need to be scrolled. In popup mode the height

   980 // is fixed.

   981 TSize CMIDChoiceGroupControl::MinimumSize() const

   982 {

   983     // Start with the current size

   984     TSize size = Size();

   985 

   986     TInt height = 0;

   987 

   988     // Get height of list box, if not popup, and there is one

   989     if (!IsPopup())

   990     {

   991         // Get current number of list box items.

   992         TInt numberOfItems = iModel->NumberOfItems();

   993 

   994         if (iListBox)

   995         {

   996             // Use item count to calculate listbox height

   997             height += iListBox->CalcHeightBasedOnNumOfItems(numberOfItems);

   998         }

   999         else

  1000         {

  1001             // If there is no iListBox, this cg is not added to form yet.

  1002             // In this case calculate the best estimate for the list box height

  1003             // here.

  1004             // Because none of layout seems to be suitable for this

  1005             // calculation, we have to do it in the same way as CEikLisBox

  1006             // (see CEikListBox::CalcHeightBasedOnNumOfItems in eiklbx.cpp).

  1007             height += (iEikonEnv->NormalFont()->HeightInPixels()

  1008                        + KEikListBoxItemVGap) * numberOfItems;

  1009         }

  1010 

  1011         height += (numberOfItems > 0)

  1012                   ? (iContentMargins.iTop + iContentMargins.iBottom)

  1013                   : iContentMargins.iBottom;

  1014     }

  1015     else // It is a popup

  1016     {

  1017         TAknLayoutRect layoutRect;

  1018         // layout in respect of the screen as only the height is needed

  1019         layoutRect.LayoutRect(iEikonEnv->ScreenDevice()->SizeInPixels(),

  1020                               AknLayoutScalable_Avkon::

  1021                               list_single_midp_graphic_pane_cp(1, 0).LayoutLine());

  1022         height += layoutRect.Rect().Height()

  1023                   + iContentMargins.iTop + iContentMargins.iBottom;

  1024     }

  1025 

  1026     // Adjust the size (height only) accordingly

  1027     size.iHeight = height;

  1028 

  1029     return size;

  1030 }

  1031 

  1032 void CMIDChoiceGroupControl::Draw(const TRect& /*aRect*/) const

  1033 {

  1034     if (IsPopup())

  1035     {

  1036         CMIDChoiceGroupElement* pElement = iModel->ElementAt(iModel->SelectedElement());

  1037 

  1038         if (pElement)

  1039         {

  1040             DrawIcon(pElement->Icon());

  1041             DrawText(pElement->Text());

  1042         }

  1043     }

  1044 }

  1045 

  1046 // Responds to focus change.

  1047 // From CCoeControl.

  1048 void CMIDChoiceGroupControl::FocusChanged(TDrawNow aDrawNow)

  1049 {

  1050     // call default CCoeControl's implementation

  1051     CCoeControl::FocusChanged(aDrawNow);

  1052 

  1053     // update focus state of listbox regarding to current focus state

  1054     if (iListBox)

  1055     {

  1056         iListBox->SetFocus(IsFocused(), aDrawNow);

  1057     }

  1058 }

  1059 

  1060 // Handles resource change.

  1061 // From CCoeControl.

  1062 void CMIDChoiceGroupControl::HandleResourceChange(TInt aType)

  1063 {

  1064     // call default CCoeControl's implementation

  1065     CCoeControl::HandleResourceChange(aType);

  1066 

  1067     // update listbox focus state when layout is switched

  1068     if (aType == KEikDynamicLayoutVariantSwitch && iListBox)

  1069     {

  1070         iListBox->SetFocus(IsFocused());

  1071     }

  1072 }

  1073 

  1074 TTypeUid::Ptr CMIDChoiceGroupControl::MopSupplyObject(TTypeUid aId)

  1075 {

  1076     return iItem->MopSupplyObject(aId);

  1077 }

  1078 

  1079 // Closes the popup if it is open

  1080 void CMIDChoiceGroupControl::ClosePopup()

  1081 {

  1082     if (iPopupList)

  1083     {

  1084         iPopupList->CancelPopup();

  1085     }

  1086 }

  1087 

  1088 // --- private functions ---

  1089 

  1090 // Draws an icon in the popup control using LAF as much as possible

  1091 void CMIDChoiceGroupControl::DrawIcon(CGulIcon* aIcon) const

  1092 {

  1093     // Sanity check

  1094     if (!aIcon)

  1095     {

  1096         return;

  1097     }

  1098 

  1099     // Extract parts - they're needed later anyway

  1100     CFbsBitmap* bmp = aIcon->Bitmap();

  1101     CFbsBitmap* mask = aIcon->Mask();

  1102 

  1103     CWindowGc& gc = SystemGc();

  1104     TRect iconRect = iPopupIconRect;

  1105 

  1106     // Draw the icon centered in its rect

  1107 

  1108     // Position in icon is (0,0), if the image fits. Else there's a

  1109     // need for a bit of recalc

  1110     TPoint posInIcon = TPoint(0, 0) + (bmp->SizeInPixels() - iconRect.Size());

  1111     posInIcon.iX /= 2;

  1112     posInIcon.iY /= 2;

  1113 

  1114     // If the thing is negative, the icon fits. Need to move the drawing

  1115     // rect a bit to make the icon draw in the middle

  1116     if (posInIcon.iX < 0)

  1117     {

  1118         // Shift right by amount left over

  1119         iconRect.iTl.iX -= posInIcon.iX;

  1120         posInIcon.iX = 0;

  1121     }

  1122 

  1123     if (posInIcon.iY < 0)

  1124     {

  1125         // Shift down by amount left over

  1126         iconRect.iTl.iY -= posInIcon.iY;

  1127         posInIcon.iY = 0;

  1128     }

  1129 

  1130     // Set the part of icon that is to be drawn

  1131     TRect drawRect(posInIcon, iconRect.Size());

  1132 

  1133     // Draw it

  1134     if (mask)