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 #ifdef RD_JAVA_S60_RELEASE_9_2

   311 /**

   312  * Fuction sets ESingleClickDisabledHighlight - item drawer flags

   313  * and reports current highlight element change event

   314  */

   315 void CMIDChoiceGroupControl::SingleClickDisableHighlightL(TBool aDisable)

   316 {

   317     // Highlight should be disabled when listbox element taped

   318     if (iListBox)

   319     {

   320         iListBox->SingleClickDisableHighlightL(aDisable);

   321     }

   322 }

   323 #endif

   324 

   325 // msk

   326 void CMIDChoiceGroupControl::CurrentItemChanged()

   327 {

   328     if (iItem)

   329     {

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

   331         iItem->UpdateCommands();

   332     }

   333     // redraw

   334     DrawNow();

   335 }

   336 

   337 // msk

   338 TBool CMIDChoiceGroupControl::IsCurrentItemSelected()

   339 {

   340     if (iListBox)

   341     {

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

   343     }

   344 

   345     return EFalse;

   346 }

   347 

   348 // msk

   349 // Posts always the java event

   350 void CMIDChoiceGroupControl::ToggleCurrentItemSelectionL()

   351 {

   352     if (iListBox)

   353     {

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

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

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

   357         {

   358 #ifdef RD_JAVA_S60_RELEASE_9_2

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

   360             {

   361 #endif // RD_JAVA_S60_RELEASE_9_2             

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

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

   364 #ifdef RD_JAVA_S60_RELEASE_9_2

   365             }

   366 #endif // RD_JAVA_S60_RELEASE_9_2

   367         }

   368     }

   369 }

   370 

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

   372 TInt CMIDChoiceGroupControl::NumberOfElements() const

   373 {

   374     ASSERT(iModel);

   375     return iModel->NumberOfItems();

   376 }

   377 

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

   379 

   380 

   381 // Inserts a new element in the choice

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

   383 {

   384     ASSERT(iModel);

   385 

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

   387 

   388     // Reserve space for the new element

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

   390 

   391     // Stuff it in

   392     iModel->InsertElementL(aIndex, pElement);

   393 

   394     CListBoxView* view = NULL;

   395 

   396     if (iListBox)

   397     {

   398         view = iListBox->View();

   399     }

   400     else if (iPopupList)

   401     {

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

   403     }

   404 

   405     if (view)

   406     {

   407         TInt current = view->CurrentItemIndex();

   408 

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

   410         {

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

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

   413             // as before insertion.

   414             view->SetCurrentItemIndex(++current);

   415         }

   416     }

   417 

   418     CleanupStack::Pop(pElement);

   419 }

   420 

   421 

   422 // Deletes an element from the choice

   423 void CMIDChoiceGroupControl::DeleteElementL(TInt aIndex)

   424 {

   425     ASSERT(iModel);

   426     TInt current = 0;

   427     if (iListBox)

   428     {

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

   430     }

   431     iModel->DeleteElementL(aIndex);

   432 

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

   434             iModel->NumberOfItems() > 0 &&

   435             aIndex <= current)

   436     {

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

   438         {

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

   440             {

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

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

   443                 // as before the deletion

   444                 --current;

   445             }

   446             iListBox->SetCurrentItemIndex(current);

   447         }

   448         else

   449         {

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

   451         }

   452     }

   453 

   454 }

   455 

   456 

   457 // Deletes all elements

   458 void CMIDChoiceGroupControl::DeleteAllL()

   459 {

   460     ASSERT(iModel);

   461     if (iListBox)

   462     {

   463         iListBox->SetCurrentItemIndex(0);

   464     }

   465     iModel->DeleteAllL();

   466 }

   467 

   468 

   469 // Sets properties of element at <aIndex>

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

   471 {

   472     ASSERT(iModel);

   473 

   474     if (aImage)

   475     {

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

   477 

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

   479         CleanupStack::PushL(bitmap);

   480 

   481         CFbsBitmap* mask = NULL;

   482         if (bitmapImage->AlphaBitmap())

   483         {

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

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

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

   487         }

   488 

   489         CleanupStack::PushL(mask);

   490 

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

   492 

   493         CleanupStack::Pop(mask);

   494         CleanupStack::Pop(bitmap);

   495 

   496         bitmapImage->RemoveRef();

   497     }

   498     else

   499     {

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

   501     }

   502 }

   503 

   504 

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

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

   507 // in CMIDChoiceGroupItem just simply calls this method.

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

   509 {

   510     SelectElementL(aIndex, aSelected, EFalse);

   511 }

   512 

   513 

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

   515 TBool CMIDChoiceGroupControl::IsSelected(TInt aIndex)

   516 {

   517     ASSERT(iModel);

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

   519 

   520     if (pElement)

   521     {

   522         return pElement->IsSelected();

   523     }

   524 

   525     return EFalse;

   526 }

   527 

   528 

   529 // Sets element text font

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

   531 {

   532     ASSERT(iModel);

   533 }

   534 

   535 

   536 // Sets element text fit policy

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

   538 {

   539     ASSERT(iModel);

   540 }

   541 

   542 

   543 // --- from MMIDChoiceGroupModelObserver ---

   544 

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

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

   547 void CMIDChoiceGroupControl::HandleChoiceGroupModelEventL(

   548     CMIDChoiceGroupModel* aModel,

   549     TChoiceGroupModelEvent aEvent)

   550 {

   551     ASSERT(iModel);

   552 

   553     // If not from our model, ignore

   554     if (aModel != iModel)

   555     {

   556         return;

   557     }

   558 

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

   560     TBool bRedraw = ETrue;

   561     TBool bResize = ETrue;

   562 

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

   564     switch (aEvent)

   565     {

   566     case EElementAdded:

   567         if (iListBox)

   568         {

   569             iListBox->HandleItemAdditionL();

   570         }

   571         break;

   572     case EElementDeleted:

   573         if (iListBox)

   574         {

   575             iListBox->HandleItemRemovalL();

   576         }

   577         break;

   578     case EUpdateEnded:

   579         if (iListBox)

   580         {

   581             iListBox->Reset();

   582         }

   583         break;

   584     case EElementModified:

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

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

   587         // of the whole form is not needed.

   588         SizeChanged();

   589         bResize = EFalse;

   590         break;

   591     case EElementSelected:

   592         // Just a redraw will do

   593         bResize = EFalse;

   594         break;

   595     case EUpdateStarted:

   596     default:

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

   598         bRedraw = EFalse;

   599         bResize = EFalse;

   600         break;

   601     }

   602 

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

   604     if (iPopupList)

   605     {

   606         UpdatePopupListAppearanceL(aEvent);

   607     }

   608 

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

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

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

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

   613     // cause a form layout and redraw anyway.

   614     if (bRedraw && !bResize)

   615     {

   616         // Do safe redraw

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

   618         {

   619             iListBox->DrawDeferred();

   620         }

   621         else

   622         {

   623             // Seems to be a popup - redraw myself

   624             if (DrawableWindow())

   625             {

   626                 DrawDeferred();

   627             }

   628         }

   629     }

   630 }

   631 

   632 

   633 // --- from MEikListBoxObserver ---

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

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

   636 {

   637     if (aControl != iListBox)

   638     {

   639         return;

   640     }

   641 

   642     ASSERT(iModel);

   643 

   644     switch (aEventType)

   645     {

   646         // These should all cause a selection change

   647     case MEikListBoxObserver::EEventEnterKeyPressed:

   648     case MEikListBoxObserver::EEventItemActioned:

   649         ToggleCurrentItemSelectionL();

   650         break;

   651 #ifdef RD_JAVA_S60_RELEASE_9_2

   652     case MEikListBoxObserver::EEventPenDownOnItem:

   653         if (iListBox)

   654         {

   655             iListBox->SetHighlight(EFalse);

   656         }

   657         break;

   658 #endif

   659 

   660     default:

   661         break;

   662     }

   663 }

   664 

   665 

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

   667 TKeyResponse CMIDChoiceGroupControl::OfferKeyEventL(

   668     const TKeyEvent& aKeyEvent,

   669     TEventCode aType)

   670 {

   671     TKeyResponse resp = EKeyWasNotConsumed;

   672 

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

   674     if (IsPopup())

   675     {

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

   677         {

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

   679             DoPopupL();

   680             resp = EKeyWasConsumed;

   681         }

   682 

   683         return resp;

   684     }

   685 

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

   687 

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

   689     TInt oldSelected = iModel->SelectedElement();

   690     TInt oldCurrentIndex = -1;

   691 #ifdef RD_JAVA_S60_RELEASE_9_2

   692     TBool wasHighlighted = EFalse;

   693 #endif // RD_JAVA_S60_RELEASE_9_2

   694 

   695     if (iListBox)

   696     {

   697 #ifdef RD_JAVA_S60_RELEASE_9_2

   698         wasHighlighted = iListBox->GetHighlight();

   699 #endif // RD_JAVA_S60_RELEASE_9_2

   700 

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

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

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

   704 

   705 #ifdef RD_JAVA_S60_RELEASE_9_2

   706         wasHighlighted = (iListBox->GetHighlight() && !wasHighlighted) ? EFalse : ETrue;

   707 #endif // RD_JAVA_S60_RELEASE_9_2

   708     }

   709 

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

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

   712     // Choicegroup element need to be focused and selected

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

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

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

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

   717 #ifdef RD_JAVA_S60_RELEASE_9_2

   718             && (wasHighlighted && iListBox->GetHighlight())

   719 #endif // RD_JAVA_S60_RELEASE_9_2

   720        )

   721     {

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

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

   724         TInt cntOpt = displayable.NumCommandsForOkOptionsMenu();

   725 

   726         // set first command from command list,

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

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

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

   730                                       NULL);

   731 

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

   733         if (iItem->DefaultCommand())

   734         {

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

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

   737 

   738             resp =  EKeyWasConsumed;

   739         }

   740         else

   741         {

   742             TInt numScreenOrHelpCommands = displayable.NumCommandsForScreenOrHelpOptionsMenu();

   743 

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

   745             if (cntOpt > 1)

   746             {

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

   748                 resp = EKeyWasConsumed;

   749             }

   750             else if (cntOpt == 0 && numScreenOrHelpCommands > 1)

   751             {

   752                 // If there is more than one screen command on form

   753                 // and there is no ok/item commands then show menu

   754                 displayable.MenuHandler()->ShowMenuL(CMIDMenuHandler::EOptionsMenu);

   755                 resp = EKeyWasConsumed;

   756             }

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

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

   759             {

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

   761                 resp =  EKeyWasConsumed;

   762             }

   763             else

   764             {

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

   766                 resp =  EKeyWasConsumed;

   767             }

   768         }

   769     }

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

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

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

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

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

   775             (resp != EKeyWasNotConsumed))

   776     {

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

   778         RequestScrollIfNeededL();

   779     }

   780 

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

   782     {

   783         CurrentItemChanged();

   784 #ifdef RD_JAVA_S60_RELEASE_9_2

   785         ShowInfoPopup();

   786 #endif // RD_JAVA_S60_RELEASE_9_2        

   787     }

   788     return resp;

   789 }

   790 

   791 #ifdef RD_SCALABLE_UI_V2

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

   793 {

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

   795     {

   796 

   797 #ifdef RD_TACTILE_FEEDBACK

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

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

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

   801         if (IsPopup() &&

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

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

   804         {

   805 #ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

   806             iFeedback->InstantFeedback(ETouchFeedbackList);

   807 #else

   808             iFeedback->InstantFeedback(ETouchFeedbackBasic);

   809 #endif // RD_JAVA_ADVANCED_TACTILE_FEEDBACK

   810         }

   811 #endif // RD_TACTILE_FEEDBACK

   812 

   813         return;

   814     }

   815 

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

   817     TBool oldSelected = IsSelected(nOldCurrent);

   818 

   819     switch (aPointerEvent.iType)

   820     {

   821     case TPointerEvent::EDrag:

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

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

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

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

   826         iListBox->HandlePointerEventL(aPointerEvent);

   827         break;

   828     case TPointerEvent::EButtonRepeat:

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

   830         // is dragged out of main pane area.

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

   832         break;

   833     case TPointerEvent::EButton1Down:

   834     {

   835 #ifdef RD_JAVA_S60_RELEASE_9_2

   836         // Hide pop-up note if visible.

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

   838         if (form)

   839         {

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

   841         }

   842 #endif // RD_JAVA_S60_RELEASE_9_2

   843 

   844         iPointerDragHasStarted = EFalse;

   845 

   846 #ifdef RD_TACTILE_FEEDBACK

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

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

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

   850         {

   851 #ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

   852             iFeedback->InstantFeedback(ETouchFeedbackList);

   853 #else

   854             iFeedback->InstantFeedback(ETouchFeedbackBasic);

   855 #endif // RD_JAVA_ADVANCED_TACTILE_FEEDBACK

   856         }

   857 #endif // RD_TACTILE_FEEDBACK

   858         CCoeControl::HandlePointerEventL(aPointerEvent);

   859 

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

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

   862         {

   863             TRect mainPane;

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

   865 

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

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

   868 

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

   870             TInt scroll = 0;

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

   872             {

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

   874             }

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

   876             {

   877                 scroll = -rect.iTl.iY;

   878             }

   879 

   880             if (scroll != 0)

   881             {

   882                 ReportEventL(MMIDChoiceGroupControlObserver::EScrollRequest,

   883                              (TAny*)scroll);

   884             }

   885         }

   886         break;

   887     }

   888     case TPointerEvent::EButton1Up:

   889     {

   890 #ifdef RD_JAVA_S60_RELEASE_9_2

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

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

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

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

   895         // hide listbox highlight.

   896         if (iItem->LongTapDetected())

   897         {

   898             CCoeControl::HandlePointerEventL(aPointerEvent);

   899             return;

   900         }

   901 #endif // RD_JAVA_S60_RELEASE_9_2

   902 #ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

   903         switch (iType)

   904         {

   905         case MMIDChoiceGroup::EMultiple:

   906             iFeedback->InstantFeedback(ETouchFeedbackCheckbox);

   907             break;

   908         default:

   909             iFeedback->InstantFeedback(ETouchFeedbackList);

   910             break;

   911         }

   912 #endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

   913 

   914         CCoeControl::HandlePointerEventL(aPointerEvent);

   915 

   916         TInt idx;

   917 

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

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

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

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

   922 

   923         if (!iPointerDragHasStarted &&

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

   925                  toggleAfterScroll))

   926         {

   927             ToggleCurrentItemSelectionL();

   928         }

   929 

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

   931         // then possible default Command is executed.

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

   933         {

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

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

   936             {

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

   938             }

   939         }

   940 

   941         iFocusChangingWithPen = EFalse;

   942         break;

   943     }

   944     default:

   945         CCoeControl::HandlePointerEventL(aPointerEvent);

   946         break;

   947     }

   948 

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

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

   951     {

   952         iFocusChangingWithPen = ETrue;

   953         CurrentItemChanged();

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

   955         {

   956             iPointerDragHasStarted = ETrue;

   957         }

   958     }

   959 }

   960 

   961 #endif //RD_SCALABLE_UI_V2

   962 

   963 // Count component controls in this compound control

   964 TInt CMIDChoiceGroupControl::CountComponentControls() const

   965 {

   966     if (iListBox)

   967         return 1;

   968 

   969     return 0;

   970 }

   971 

   972 

   973 // Return requested component control

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

   975 {

   976     return iListBox;

   977 }

   978 

   979 

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

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

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

   983     this controls chance to update its position.

   984 

   985 */

   986 void CMIDChoiceGroupControl::SizeChanged()

   987 {

   988     if (iListBox)

   989     {

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

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

   992     }

   993 

   994     if (IsPopup())

   995     {

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

   997 

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

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

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

  1001         layoutRect.LayoutRect(Rect(),

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

  1003         TRect popupRect = layoutRect.Rect();

  1004 

  1005         // Layout for the element icon

  1006         layoutRect.LayoutRect(popupRect,

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

  1008         iPopupIconRect = layoutRect.Rect();

  1009 

  1010         // Layout for the text

  1011 

  1012         iPopupTextLayout.LayoutText(popupRect,

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

  1014     }

  1015 }

  1016 

  1017 void CMIDChoiceGroupControl::PositionChanged()

  1018 {

  1019     if (IsPopup())

  1020     {

  1021         SizeChanged();

  1022     }

  1023 }

  1024 

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

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

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

  1028 // is fixed.

  1029 TSize CMIDChoiceGroupControl::MinimumSize() const

  1030 {

  1031     // Start with the current size

  1032     TSize size = Size();

  1033 

  1034     TInt height = 0;

  1035 

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

  1037     if (!IsPopup())

  1038     {

  1039         // Get current number of list box items.

  1040         TInt numberOfItems = iModel->NumberOfItems();

  1041 

  1042         if (iListBox)

  1043         {

  1044             // Use item count to calculate listbox height

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

  1046         }

  1047         else

  1048         {

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

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

  1051             // here.

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

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

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

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

  1056                        + KEikListBoxItemVGap) * numberOfItems;

  1057         }

  1058 

  1059         height += (numberOfItems > 0)

  1060                   ? (iContentMargins.iTop + iContentMargins.iBottom)

  1061                   : iContentMargins.iBottom;

  1062     }

  1063     else // It is a popup

  1064     {

  1065         TAknLayoutRect layoutRect;

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

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

  1068                               AknLayoutScalable_Avkon::

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

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

  1071                   + iContentMargins.iTop + iContentMargins.iBottom;

  1072     }

  1073 

  1074     // Adjust the size (height only) accordingly

  1075     size.iHeight = height;

  1076 

  1077     return size;

  1078 }

  1079 

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

  1081 {

  1082     if (IsPopup())

  1083     {

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

  1085 

  1086         if (pElement)

  1087         {

  1088             DrawIcon(pElement->Icon());

  1089             DrawText(pElement->Text());

  1090         }

  1091     }

  1092 }

  1093 

  1094 // Responds to focus change.

  1095 // From CCoeControl.

  1096 void CMIDChoiceGroupControl::FocusChanged(TDrawNow aDrawNow)

  1097 {

  1098     // call default CCoeControl's implementation

  1099     CCoeControl::FocusChanged(aDrawNow);

  1100 

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

  1102     if (iListBox)

  1103     {

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

  1105     }

  1106 }

  1107 

  1108 // Handles resource change.

  1109 // From CCoeControl.

  1110 void CMIDChoiceGroupControl::HandleResourceChange(TInt aType)

  1111 {

  1112     // call default CCoeControl's implementation

  1113     CCoeControl::HandleResourceChange(aType);

  1114 

  1115     // update listbox focus state when layout is switched

  1116     if (aType == KEikDynamicLayoutVariantSwitch && iListBox)

  1117     {

  1118         iListBox->SetFocus(IsFocused());

  1119     }

  1120 }

  1121 

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

  1123 {

  1124     return iItem->MopSupplyObject(aId);

  1125 }

  1126 

  1127 // Closes the popup if it is open

  1128 void CMIDChoiceGroupControl::ClosePopup()

  1129 {

  1130     if (iPopupList)

  1131     {

  1132         iPopupList->CancelPopup();

  1133     }

  1134 }