1 /*

     2 * Copyright (c) 2002 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:

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include <aknmultilinequerycontrol.h>   //This class

    22 #include <barsread.h>                   //For TResourceReader

    23 #include <eikenv.h>                     //For CEikEnv

    24 #include <AknLayoutDef.h>               //For layout definitions

    25 #include <AknLayout.lag>                //For layout macros

    26 #include <avkon.mbg>

    27 

    28 #include <AknsDrawUtils.h>

    29 #include <AknsFrameBackgroundControlContext.h>

    30 

    31 #include "akntextcontrol.h"

    32 #include "aknqueryeditorindicator.h"

    33 #include "AknQueryExtension.h"

    34 #include <skinlayout.cdl.h>

    35 #include "aknappui.h"

    36 #include "AknQueryExtension.h"

    37 

    38 #include <layoutmetadata.cdl.h>

    39 #include <AknLayout2ScalableDef.h>

    40 #include <aknlayoutscalable_avkon.cdl.h>

    41 

    42 #if defined( RD_SCALABLE_UI_V2)

    43 //class CAknButton is available from week 20 version 5.0 onwards

    44 #include <aknbutton.h>

    45 // For MAknMfneCommandObserver

    46 #include <aknmfnecommandobserver.h>

    47 #endif //if defined( RD_SCALABLE_UI_V2)

    48 

    49 #include <aknlocationed.h>

    50 #include <aknconsts.h>

    51 

    52 #include <touchfeedback.h>

    53 

    54 #include <AknTasHook.h> // for testability hooks

    55 

    56 

    57 EXPORT_C CAknMultilineQueryControl::CAknMultilineQueryControl() 

    58     : CAknQueryControl(), iLinePos(EFirstLine)

    59     {

    60     AKNTASHOOK_ADD( this, "CAknMultilineQueryControl" );

    61     }

    62 

    63 //

    64 //Destructor

    65 //

    66 EXPORT_C CAknMultilineQueryControl::~CAknMultilineQueryControl()

    67 

    68     {

    69     AKNTASHOOK_REMOVE();

    70     MTouchFeedback* feedback = MTouchFeedback::Instance();

    71     if ( feedback )

    72         {

    73         feedback->RemoveFeedbackForControl( this );

    74         }

    75     }

    76 

    77 /**

    78  *Initializes the member data from resource

    79  */

    80 void CAknMultilineQueryControl::ConstructQueryL(TResourceReader& aRes)

    81     {

    82     SetLinePosition();

    83 

    84     switch(iQueryType)

    85         {

    86         case EMultiDataFirstEdwin:

    87         case EMultiDataSecondEdwin:

    88             {

    89             iEdwin = new(ELeave)CEikEdwin;

    90             iEdwin->SetContainerWindowL(*this);

    91             iEdwin->ConstructFromResourceL(aRes);

    92             iEdwin->SetObserver(this);

    93             iEdwin->AddFlagToUserFlags(EEikEdwinNoWrap);

    94             }

    95             break;

    96         case EMultiDataFirstEdwinAllowEmpty:

    97             {

    98             iEdwin = new(ELeave)CEikEdwin;

    99             iEdwin->SetContainerWindowL(*this);

   100             iEdwin->ConstructFromResourceL(aRes);

   101             iEdwin->SetObserver(this);

   102             iEdwin->AddFlagToUserFlags(EEikEdwinNoWrap);

   103                 

   104             CAknQueryExtension* extension = QueryExtension();

   105             if( extension )

   106                 {

   107                 extension->iAllowEmptyInput = ETrue;

   108                 }

   109             iQueryType = EMultiDataFirstEdwin;

   110             }

   111             break;

   112         case EMultiDataSecondEdwinAllowEmpty:

   113             {

   114             iEdwin = new(ELeave)CEikEdwin;

   115             iEdwin->SetContainerWindowL(*this);

   116             iEdwin->ConstructFromResourceL(aRes);

   117             iEdwin->SetObserver(this);

   118             iEdwin->AddFlagToUserFlags(EEikEdwinNoWrap);

   119                 

   120             CAknQueryExtension* extension = QueryExtension();

   121             if( extension )

   122                 {

   123                 extension->iAllowEmptyInput = ETrue;

   124                 }

   125             iQueryType = EMultiDataSecondEdwin;

   126             }

   127             break;

   128         case EMultiDataFirstSecEd:

   129         case EMultiDataSecondSecEd:

   130             {

   131             iSecretEd = new(ELeave)CEikSecretEditor;

   132             iSecretEd->SetContainerWindowL(*this);

   133             iSecretEd->ConstructFromResourceL(aRes);

   134             iSecretEd->SetObserver(this);

   135             iSecretEd->SetSkinTextColorL(EAknsCIQsnTextColorsCG27);

   136             }

   137             break;

   138         case EMultiDataFirstTimeEd:

   139         case EMultiDataSecondTimeEd:

   140             {

   141             iTimeEdwin = new(ELeave)CEikTimeEditor;

   142             iTimeEdwin->SetContainerWindowL(*this);

   143             iTimeEdwin->ConstructFromResourceL(aRes);

   144             iTimeEdwin->SetSkinTextColorL(EAknsCIQsnTextColorsCG27);

   145 #if defined( RD_SCALABLE_UI_V2)

   146 

   147             if ( AknLayoutUtils::PenEnabled() )

   148                 {

   149                 iTimeEdwin->SetFeature( CEikMfne::EFingerSupport, CEikMfne::EnableWithAllHighlight );

   150                 }

   151                             

   152 #endif //if defined( RD_SCALABLE_UI_V2)

   153             }

   154             break;

   155         case EMultiDataFirstDateEd:

   156         case EMultiDataSecondDateEd:

   157             {

   158             iDateEdwin = new(ELeave)CEikDateEditor;

   159             iDateEdwin->SetContainerWindowL(*this);

   160             iDateEdwin->ConstructFromResourceL(aRes);

   161             iDateEdwin->SetSkinTextColorL(EAknsCIQsnTextColorsCG27);

   162 #if defined( RD_SCALABLE_UI_V2)

   163 

   164             if ( AknLayoutUtils::PenEnabled() )

   165                 {

   166                 iDateEdwin->SetFeature( CEikMfne::EFingerSupport, CEikMfne::EnableWithAllHighlight );

   167                 //SizeChanged();

   168                 }

   169     

   170 #endif //if defined( RD_SCALABLE_UI_V2)

   171             }

   172             break;

   173         case EMultiDataFirstDurEd:

   174         case EMultiDataSecondDurEd:

   175             {

   176             iDurationEdwin = new(ELeave)CEikDurationEditor;

   177             iDurationEdwin->SetContainerWindowL(*this);

   178             iDurationEdwin->ConstructFromResourceL(aRes);

   179             iDurationEdwin->SetSkinTextColorL(EAknsCIQsnTextColorsCG27);

   180             if ( AknLayoutUtils::PenEnabled() )

   181                 {

   182                 iDurationEdwin->SetFeature( CEikMfne::EFingerSupport, CEikMfne::EnableWithAllHighlight );

   183                 }

   184             }

   185             break;

   186         case EMultiDataFirstPhoneEd:

   187         case EMultiDataSecondPhoneEd:

   188             {

   189             iEdwin = new(ELeave)CEikEdwin;

   190             iEdwin->AddFlagToUserFlags(EEikEdwinAlternativeWrapping | EEikEdwinNoWrap);

   191             iEdwin->SetContainerWindowL(*this);

   192             iEdwin->SetEdwinObserver(this);

   193             iEdwin->ConstructFromResourceL(aRes);

   194             iEdwin->SetObserver(this);

   195             iEdwin->SetAknEditorInputMode(EAknEditorNumericInputMode);

   196             iEdwin->SetAknEditorAllowedInputModes(EAknEditorNumericInputMode);

   197             }

   198             break;

   199         case EMultiDataFirstNumEd:

   200         case EMultiDataSecondNumEd:

   201             {

   202             iNumberEdwin = new(ELeave)CAknIntegerEdwin;

   203             iNumberEdwin->SetContainerWindowL(*this);

   204             iNumberEdwin->ConstructFromResourceL(aRes);

   205             iNumberEdwin->SetObserver(this);

   206             iNumberEdwin->AddFlagToUserFlags(EEikEdwinNoWrap);

   207             }

   208             break;

   209         case EMultiDataFirstPinEd:

   210         case EMultiDataSecondPinEd:

   211             {

   212             iPinEdwin = new(ELeave)CAknNumericSecretEditor;

   213             iPinEdwin->SetContainerWindowL(*this);

   214             iPinEdwin->ConstructFromResourceL(aRes);

   215             iPinEdwin->SetObserver(this);

   216             iPinEdwin->SetSkinTextColorL(EAknsCIQsnTextColorsCG27);

   217             }

   218             break;

   219         case EMultiDataFirstLocationEd:

   220         case EMultiDataSecondLocationEd:

   221             {

   222             LocationEd() = new(ELeave)CAknLocationEditor;

   223             LocationEd()->SetContainerWindowL(*this);

   224             LocationEd()->ConstructFromResourceL(aRes);

   225             LocationEd()->SetObserver(this);

   226             LocationEd()->SetSkinTextColorL(EAknsCIQsnTextColorsCG27);

   227             if ( AknLayoutUtils::PenEnabled() )

   228                 {

   229                 LocationEd()->SetFeature( CEikMfne::EFingerSupport, CEikMfne::EnableWithAllHighlight );

   230                 }

   231             }

   232         default:

   233             break;

   234         }

   235 

   236     // Construct editor context

   237     CAknQueryExtension* extension = QueryExtension();

   238     if( extension )

   239         {

   240         extension->CreateEditorContextL();

   241         }

   242         

   243     MTouchFeedback* feedback = MTouchFeedback::Instance();

   244     CFeedbackSpec* spec = CFeedbackSpec::New();

   245     if ( feedback && spec )

   246         {

   247         spec->AddFeedback( ETouchEventStylusDown,

   248                            ETouchFeedbackSensitiveList );

   249         feedback->SetFeedbackArea( this, 0, Rect(), spec );

   250         delete spec;

   251         }

   252     }

   253 

   254 /** 

   255  * Layout rectangle (shift up and left by margins)

   256  */

   257 TRect CAknMultilineQueryControl::LayoutRect()

   258     {

   259     TPoint topLeft(0,0);

   260     TIndex LAFIndex(iLinePos,iFirstQueryPromptLines,iSecondQueryPromptLines);

   261 

   262     TAknLayoutRect layout;

   263     layout.LayoutRect(DialogRect(), AKN_LAYOUT_WINDOW_Combined_data_and_code_query_pop_up_window_graphics_Line_5(DialogRect(), LAFIndex.CDCPQWindowGraphicsLine5()));

   264 

   265     TRect rect(layout.Rect());

   266     topLeft.iX -= rect.iTl.iX;

   267     topLeft.iY -= rect.iTl.iY;

   268 

   269     TPoint bottomRight (topLeft);

   270     TSize  size (MinimumSize());

   271     bottomRight.iY += size.iHeight; 

   272     bottomRight.iX += size.iWidth;

   273 

   274     return TRect(topLeft,bottomRight);

   275     }

   276 

   277 

   278 /**

   279  * Depending on layout type determine control position in the dialog

   280  */

   281 void CAknMultilineQueryControl::SetLinePosition()

   282     {

   283     if ( iQueryType == EMultiDataSecondEdwin || iQueryType == EMultiDataSecondSecEd

   284         || iQueryType == EMultiDataSecondTimeEd || iQueryType == EMultiDataSecondDateEd

   285         || iQueryType == EMultiDataSecondDurEd  || iQueryType == EMultiDataSecondPhoneEd

   286         || iQueryType == EMultiDataSecondNumEd  || iQueryType == EMultiDataSecondPinEd 

   287         || iQueryType == EMultiDataSecondLocationEd

   288         )

   289         {   

   290         iLinePos = ESecondLine;

   291         }

   292     }

   293 

   294 /**

   295  * Set the line width for the prompt lines

   296  *

   297  * This is a virtual method called by CAknQueryControl::DoSetPromptL()

   298  *

   299  * Depending on LAF information and on weather we are the first or the second 

   300  * query line, we can work out the line widths by indexing the LAF tables.

   301  *

   302  */

   303 void CAknMultilineQueryControl::SetLineWidthsL()

   304     {

   305     if (!iLineWidths)

   306         return;

   307     

   308     iLineWidths->Reset();

   309 

   310     TAknLayoutRect parentLayoutRect;

   311     if (Layout_Meta_Data::IsLandscapeOrientation())

   312         parentLayoutRect.LayoutRect(iAvkonAppUi->ClientRect(), AKN_LAYOUT_WINDOW_popup_query_data_window(0));

   313     else

   314         parentLayoutRect.LayoutRect(iAvkonAppUi->ClientRect(), AKN_LAYOUT_WINDOW_popup_query_data_code_window(0));

   315     

   316     //parentLayoutRect.LayoutRect(iAvkonAppUi->ClientRect(), AKN_LAYOUT_WINDOW_popup_query_data_code_window(0));

   317     TAknLayoutText textRect;

   318 

   319     for (TInt i = 0; i < 2; i++)

   320         {

   321         if (iLinePos == EFirstLine || Layout_Meta_Data::IsLandscapeOrientation())

   322             {

   323             textRect.LayoutText(parentLayoutRect.Rect(), AKN_LAYOUT_TEXT_Combined_data_and_code_query_pop_up_window_texts_Line_1(0));

   324             iLineWidths->AppendL(textRect.TextRect().Width());

   325             }

   326         else if (iLinePos == ESecondLine)

   327             {

   328             textRect.LayoutText(parentLayoutRect.Rect(), AKN_LAYOUT_TEXT_Combined_data_and_code_query_pop_up_window_texts_Line_3(0));

   329             iLineWidths->AppendL(textRect.TextRect().Width());

   330             }

   331         }

   332     }

   333 

   334 /**

   335  * Set the number of prompt lines.

   336  *

   337  * The query dialog calls this method in order to communicate the number of prompt lines

   338  * in the other query line. Indexing into LAF tables depends on this.

   339  *

   340  */

   341 EXPORT_C void CAknMultilineQueryControl::SetNbrOfPromptLines( 

   342                                             TInt aNbrOfPromptLinesFirstLine, 

   343                                             TInt aNbrOfPromptLinesSecondLine)

   344     {

   345     iFirstQueryPromptLines  = aNbrOfPromptLinesFirstLine;

   346     iSecondQueryPromptLines = aNbrOfPromptLinesSecondLine;

   347     }       

   348 

   349 

   350 EXPORT_C CCoeControl* CAknMultilineQueryControl::ControlByLayoutOrNull(TInt aLayout)

   351     {

   352     CCoeControl* ctrl=NULL;

   353     switch ( aLayout )

   354         {

   355         case EMultiDataFirstEdwin:

   356         case EMultiDataSecondEdwin:

   357         case EMultiDataFirstPhoneEd:

   358         case EMultiDataSecondPhoneEd:

   359             ctrl=iEdwin;

   360             break;

   361         case EMultiDataFirstSecEd:

   362         case EMultiDataSecondSecEd:

   363             ctrl=iSecretEd;

   364             break;

   365         case EMultiDataFirstDateEd:

   366         case EMultiDataSecondDateEd:

   367             ctrl=iDateEdwin;

   368             break;

   369         case EMultiDataFirstTimeEd:

   370         case EMultiDataSecondTimeEd:

   371             ctrl=iTimeEdwin;

   372             break;

   373         case EMultiDataFirstDurEd:

   374         case EMultiDataSecondDurEd:

   375             ctrl=iDurationEdwin;

   376             break;

   377         case EMultiDataFirstNumEd:

   378         case EMultiDataSecondNumEd:

   379             ctrl=iNumberEdwin;

   380             break;

   381         case EMultiDataFirstPinEd:

   382         case EMultiDataSecondPinEd:

   383             ctrl=iPinEdwin;

   384             break;

   385         case EMultiDataFirstLocationEd:

   386         case EMultiDataSecondLocationEd:

   387             ctrl=LocationEd();

   388             break;

   389         default:

   390             break;

   391         }

   392     return ctrl;

   393     }

   394 

   395 EXPORT_C TBool CAknMultilineQueryControl::IsFirst() const

   396     {

   397     return iLinePos == EFirstLine;

   398     }

   399 

   400 EXPORT_C TBool CAknMultilineQueryControl::IsSecond() const

   401     {

   402     return !IsFirst();

   403     }

   404 

   405 /**

   406  * Return control minimum size

   407  *

   408  * Size is calculated by using LAF tables. Index in this table depends on the 

   409  * total number of prompt lines in both queries

   410  */

   411 EXPORT_C TSize CAknMultilineQueryControl::MinimumSize()

   412     {

   413     TAknLayoutRect layout;  

   414     TAknWindowLineLayout window;

   415     WindowLayout( window );    

   416     

   417     TRect mainPane;

   418     AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EPopupParent, mainPane );

   419     layout.LayoutRect( mainPane, window );

   420     TRect rect2(layout.Rect()); 

   421     TSize size = rect2.Size();

   422 

   423     if (IsFirst())

   424         {

   425         size.iHeight = FirstLineHeight(); 

   426         }

   427     else if (Layout_Meta_Data::IsLandscapeOrientation() && IsSecond())

   428         {

   429         size.iHeight = SecondLineHeight();

   430         }

   431     else if (IsSecond())

   432         {

   433         TAknWindowLineLayout layoutLine = AKN_LAYOUT_WINDOW_Combined_data_and_code_query_pop_up_window_graphics_Line_5(rect2/*DialogRect()*/,0);

   434         TAknLayoutRect layoutRect;

   435         layoutRect.LayoutRect(rect2/*DialogRect()*/, layoutLine);

   436         TRect rect(layoutRect.Rect());

   437         size.iHeight = rect.Height() - FirstLineHeight();

   438         }

   439       

   440     else

   441         __ASSERT_DEBUG(0,Panic(EAknPanicNotSupported));

   442     

   443     return size;

   444   }

   445 

   446 /**

   447  * Return height of first line control, use separator to determine this.

   448  */

   449 TInt16 CAknMultilineQueryControl::FirstLineHeight() const

   450     {

   451     TIndex LAFIndex(iLinePos,iFirstQueryPromptLines,iSecondQueryPromptLines);

   452     TAknWindowLineLayout separator;

   453     if(!AknLayoutUtils::PenEnabled())

   454     {

   455         separator = 

   456         AKN_LAYOUT_WINDOW_Combined_data_and_code_query_pop_up_window_elements_Line_3

   457             (LAFIndex.CDCQPWindowLine3());

   458     }   

   459     else

   460     {

   461         separator = AknLayoutScalable_Avkon::popup_query_data_code_window_g1(5);    

   462     }

   463 

   464     TAknLayoutRect layout;

   465     layout.LayoutRect(TRect(), separator);

   466     TRect rect(layout.Rect());

   467     return (TInt16)(rect.iTl.iY + rect.Height());

   468     }

   469 

   470 TInt16 CAknMultilineQueryControl::SecondLineHeight() const

   471     {

   472     TIndex LAFIndex(iLinePos,iSecondQueryPromptLines,iFirstQueryPromptLines);

   473     

   474     TAknWindowLineLayout separator;

   475     if(!AknLayoutUtils::PenEnabled())

   476     {

   477         separator = 

   478         AKN_LAYOUT_WINDOW_Combined_data_and_code_query_pop_up_window_elements_Line_3

   479             (LAFIndex.CDCQPWindowLine3());

   480     }

   481     else

   482     {

   483         separator = AknLayoutScalable_Avkon::popup_query_data_code_window_g1(5);    

   484     }

   485     TAknLayoutRect layout;

   486     layout.LayoutRect(TRect(), separator);

   487     TRect rect(layout.Rect());

   488     return (TInt16)(rect.iTl.iY + rect.Height());

   489     }

   490 

   491 

   492 /**

   493  * Draw method.

   494  *

   495  * Draw line between query lines only if we are the first line.

   496  */

   497 void CAknMultilineQueryControl::Draw(const TRect& aRect) const

   498     {

   499     if (Layout_Meta_Data::IsLandscapeOrientation())

   500         {

   501         CAknQueryControl::Draw(aRect);

   502         return;

   503         }

   504         

   505     CWindowGc& gc=SystemGc(); 

   506     TRect rect(Rect());    

   507     

   508     if (IsSecond())

   509         {                

   510         TAknWindowLineLayout dimension;

   511         WindowLayout( dimension );

   512 

   513         TAknLayoutRect layout;

   514         layout.LayoutRect(iAvkonAppUi->ClientRect(), dimension);

   515         TRect rect2(layout.Rect());

   516         TAknWindowLineLayout layoutLine = AKN_LAYOUT_WINDOW_Combined_data_and_code_query_pop_up_window_graphics_Line_5(rect2,0);

   517         TAknLayoutRect layoutRect;

   518         layoutRect.LayoutRect(rect2, layoutLine);

   519         TRect rect3(layoutRect.Rect());

   520         rect.iBr.iY += rect3.Height() - rect.Height();

   521         }           

   522 

   523     MAknsSkinInstance* skin = AknsUtils::SkinInstance();

   524     MAknsControlContext* cc = AknsDrawUtils::ControlContext( this );

   525 

   526     if( CAknEnv::Static()->TransparencyEnabled() )

   527         {

   528         RRegion clipReg;

   529         clipReg.AddRect( rect );

   530     

   531         if ( iHasEditor )

   532             {

   533             clipReg.SubRect( iEditorFrame.Rect() );

   534             }

   535     

   536         if ( iEditIndicator )

   537             {

   538             clipReg.SubRect( 

   539                 TRect( iEditIndicator->Position(),

   540                 iEditIndicator->Size() ) );

   541             }

   542 

   543         gc.SetClippingRegion( clipReg );

   544         clipReg.Close();

   545         

   546         AknsDrawUtils::Background( skin, cc, this, gc, rect, KAknsDrawParamNoClearUnderImage );

   547     

   548         clipReg.AddRect( rect );

   549 

   550         CCoeControl* ctrl = const_cast<CAknMultilineQueryControl*>(this)->ControlByLayoutOrNull( iQueryType );

   551         if ( ctrl )

   552             {

   553             clipReg.SubRect( ctrl->Rect() );

   554             }

   555 

   556         gc.CancelClippingRegion();        

   557         gc.SetClippingRegion( clipReg );

   558         clipReg.Close();

   559         }

   560     else

   561         {

   562         AknsDrawUtils::Background( skin, cc, this, gc, rect );

   563         }

   564 

   565     DrawEditorFrame(gc,rect);

   566  

   567     if( CAknEnv::Static()->TransparencyEnabled() )

   568         {

   569         gc.CancelClippingRegion();

   570         }

   571 

   572     //if (iLinePos == EFirstLine || !Layout_Meta_Data::IsLandscapeOrientation())

   573     //   iLayoutLineBetweenEntryFields.DrawRect(SystemGc());

   574     }

   575 

   576 void CAknMultilineQueryControl::WindowLayout( TAknWindowLineLayout& aLayout ) const

   577     {

   578     if (Layout_Meta_Data::IsLandscapeOrientation())

   579         {   

   580         TInt variety = 0;   

   581         TInt promptLines = ( iLinePos == EFirstLine ? iFirstQueryPromptLines-1 : iSecondQueryPromptLines-1 );       

   582         

   583         if (promptLines < 0)

   584             {

   585             promptLines = 0;

   586             }

   587             

   588         AknLayoutUtils::TAknCbaLocation cbaLocation = AknLayoutUtils::CbaLocation();

   589        

   590         if (cbaLocation == AknLayoutUtils::EAknCbaLocationRight)

   591             {

   592             static const TInt KPopupQueryDataWindowIndex[7] = 

   593                 {13, 12, 11, 10, 9, 8, 7}; // variety numbers for right CBA are 7-13 

   594             

   595             variety = KPopupQueryDataWindowIndex[promptLines];

   596             }

   597         else if (cbaLocation == AknLayoutUtils::EAknCbaLocationLeft)

   598             {

   599             static const TInt KPopupQueryDataWindowIndex[7] = 

   600                 {20, 19, 18, 17, 16, 15, 14}; // variety numbers for left CBA are 14-20 

   601             variety = KPopupQueryDataWindowIndex[promptLines];

   602             }

   603         else // bottom

   604             {

   605             static const TInt KPopupQueryDataWindowIndex[7] = 

   606                 {0, 1, 2, 3, 4, 5, 6}; // variety numbers for bottom CBA are 0-6

   607             variety = KPopupQueryDataWindowIndex[promptLines];

   608             }

   609             

   610         if(!AknLayoutUtils::PenEnabled())

   611             {

   612                 aLayout = AknLayoutScalable_Avkon::popup_query_data_window(variety);

   613             }

   614         else

   615             {

   616             TBool button=EFalse;

   617             

   618             if(button || promptLines)

   619                 {

   620                 aLayout = AknLayoutScalable_Avkon::popup_query_code_window(4);      

   621                 }

   622             else

   623                 {

   624                 aLayout = AknLayoutScalable_Avkon::popup_query_code_window(3);      

   625                 }

   626             }

   627         }

   628     else

   629         {

   630         if(!AknLayoutUtils::PenEnabled())

   631             {

   632             TIndex LAFIndex(iLinePos,iFirstQueryPromptLines,iSecondQueryPromptLines);

   633             aLayout = AKN_LAYOUT_WINDOW_popup_query_data_code_window(LAFIndex.MainPanePQDCWindow());        

   634             }                  

   635         else

   636             {

   637             aLayout = AknLayoutScalable_Avkon::popup_query_data_code_window(2); 

   638             }

   639         }

   640     }

   641 

   642 void CAknMultilineQueryControl::SizeChanged()

   643     {

   644     DialogSizeChanged();

   645 

   646     LayoutPrompt(ECombinedCodeDataQueryLayoutM);

   647     LayoutSeparator(ECombinedCodeDataQueryLayoutM);

   648     LayoutEditor(ECombinedCodeDataQueryLayoutM);

   649 

   650     CAknQueryExtension* extension = QueryExtension();

   651     if( iHasEditor && extension && extension->EditorContext() )

   652         {

   653         // Layout editor context

   654         TAknLayoutRect topLeft;

   655         TAknLayoutRect bottomRight;

   656         

   657         topLeft.LayoutRect(iEditorFrame.Rect(), SkinLayout::Input_field_skin_placing__general__Line_2());                

   658         bottomRight.LayoutRect(TRect(iEditorFrame.Rect().iBr, iEditorFrame.Rect().iBr), SkinLayout::Input_field_skin_placing__general__Line_5());

   659 

   660         TRect outerRect = TRect(topLeft.Rect().iTl, bottomRight.Rect().iBr);

   661         TRect innerRect = TRect(topLeft.Rect().iBr, bottomRight.Rect().iTl);

   662 

   663         extension->EditorContext()->SetFrameRects( outerRect, innerRect );

   664         // Chain with the background (since the frame doesn't occupy the entire

   665         // layout and it may even be transparent)

   666         extension->EditorContext()->SetParentContext( AknsDrawUtils::ControlContextOfParent( this ) );

   667          

   668         }

   669     

   670     MTouchFeedback* feedback = MTouchFeedback::Instance();

   671     if ( feedback )

   672         {

   673         feedback->ChangeFeedbackArea( this, 0, Rect() );

   674         feedback->EnableFeedbackForControl( this, !(IsFocused() || Layout_Meta_Data::IsLandscapeOrientation()) );

   675         }

   676     }

   677     

   678 EXPORT_C void CAknMultilineQueryControl::HandlePointerEventL(const TPointerEvent& aPointerEvent) 

   679     { 

   680     CAknQueryControl::HandlePointerEventL(aPointerEvent); 

   681     }    

   682 

   683 EXPORT_C void* CAknMultilineQueryControl::ExtensionInterface( TUid /*aInterface*/ ) 

   684     { 

   685     return NULL;

   686     }

   687 

   688 /**

   689  * Layout the query prompt

   690  */

   691 void CAknMultilineQueryControl::LayoutPrompt(const TLayoutMethod& /*aLayoutM*/)

   692     {

   693     TIndex LAFIndex(iLinePos,iFirstQueryPromptLines,iSecondQueryPromptLines);

   694 

   695     iPrompt->SetRect(DialogRect());

   696     TRect rect = LayoutRect();

   697     

   698     MAknsSkinInstance* skin = AknsUtils::SkinInstance();

   699     TRgb color;

   700     TInt error = AknsUtils::GetCachedColor( skin, color, KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG19 );

   701 

   702     for (TInt i = 0; i < NbrOfPromptLines(); i++)

   703         {

   704         if (iLinePos == EFirstLine || Layout_Meta_Data::IsLandscapeOrientation())

   705             AknLayoutUtils::LayoutLabel(iPrompt->Line(i), rect, 

   706                 AKN_LAYOUT_TEXT_Combined_data_and_code_query_pop_up_window_texts_Line_1

   707                     (LAFIndex.CDCQPWindowTextsLine1(i)));

   708         

   709         else if (iLinePos == ESecondLine)

   710         {

   711           if(!AknLayoutUtils::PenEnabled())

   712           {

   713             AknLayoutUtils::LayoutLabel(iPrompt->Line(i),rect,

   714                 AKN_LAYOUT_TEXT_Combined_data_and_code_query_pop_up_window_texts_Line_3

   715                     (LAFIndex.CDCQPWindowTextsLine3(i)));

   716           }

   717           else

   718           {

   719             TAknTextComponentLayout promtLineVariant;

   720             if(i == 0)

   721             {

   722                 promtLineVariant = AknLayoutScalable_Avkon::popup_query_data_code_window_t3(0);

   723             }           

   724             else 

   725             {   

   726                 promtLineVariant = AknLayoutScalable_Avkon::popup_query_data_code_window_t4(0);

   727             }

   728             AknLayoutUtils::LayoutLabel(iPrompt->Line(i),rect,promtLineVariant);    

   729           }

   730         }

   731         

   732         else

   733             __ASSERT_DEBUG(0,Panic(EAknPanicNotSupported));

   734         

   735         if (!error)      

   736             {

   737             TRAP_IGNORE( AknLayoutUtils::OverrideControlColorL( *iPrompt->Line(i), EColorLabelText, color ) );        

   738             }

   739 

   740         }

   741     }

   742 /**

   743  * Layout the separation line between the two queries

   744  */

   745 void CAknMultilineQueryControl::LayoutSeparator(const TLayoutMethod& /*aLayoutM*/)

   746     {

   747     TIndex LAFIndex(iLinePos,iFirstQueryPromptLines,iSecondQueryPromptLines);

   748 

   749     iLayoutLineBetweenEntryFields.LayoutRect(LayoutRect(), 

   750         AKN_LAYOUT_WINDOW_Combined_data_and_code_query_pop_up_window_elements_Line_3

   751             (LAFIndex.CDCQPWindowLine3()));

   752     }

   753 

   754 /**

   755  * Following four function classes allow passing the AknLayoutUtils fcn as as

   756  * parameter to DoLayoutEditor()

   757  */

   758 

   759 /**

   760  * Layout text editors 

   761  */

   762 class FLayoutEdwin

   763     {

   764 public:

   765     FLayoutEdwin() { }

   766     void operator() (CEikEdwin* aEd, const TRect& aRect, const TAknWindowComponentLayout& aLay, 

   767         const CFont* aFont, TBool aMinimizedView) const

   768         {

   769         TAknTextLineLayout lay = TAknWindowComponentLayout::ComposeText(aLay, AknLayoutScalable_Avkon::query_popup_data_pane_t1(0)).LayoutLine();

   770         AknLayoutUtils::LayoutEdwin(aEd,aRect,lay,EAknsCIQsnTextColorsCG27,aFont,aMinimizedView);

   771         AknsUtils::RegisterControlPosition(aEd);

   772         }

   773     };

   774 

   775 /**

   776  * Layout editors containing secret codes

   777  */

   778 class FLayoutSecretEditor

   779     {

   780 public:

   781     FLayoutSecretEditor() { }

   782     void operator() (CEikSecretEditor* aEd, const TRect& aRect, const TAknWindowComponentLayout& aLay,

   783         const CFont* /*aFont*/, TBool /*aMinimizedView*/) const

   784         { 

   785         TAknTextLineLayout lay = TAknWindowComponentLayout::ComposeText(aLay, AknLayoutScalable_Avkon::query_popup_pane_t1()).LayoutLine();

   786         AknLayoutUtils::LayoutSecretEditor(aEd,aRect,lay);

   787         AknsUtils::RegisterControlPosition(aEd);

   788         }

   789     };

   790 

   791 /**

   792  * Layout numeric editors 

   793  */

   794 class FLayoutNumericEdwin

   795     {

   796 public:

   797     FLayoutNumericEdwin() { }

   798     void operator() (CAknNumericEdwin* aEd, const TRect& aRect, const TAknWindowComponentLayout& aLay, 

   799         const CFont* aFont, TBool aMinimizedView) const

   800         {

   801         TAknTextLineLayout lay = TAknWindowComponentLayout::ComposeText(aLay, AknLayoutScalable_Avkon::query_popup_data_pane_t1(0)).LayoutLine();

   802         AknLayoutUtils::LayoutEdwin(aEd,aRect,lay,EAknsCIQsnTextColorsCG27,aFont,aMinimizedView);

   803         AknsUtils::RegisterControlPosition(aEd);

   804         }

   805     };

   806 

   807 /**

   808  * Layout multifield numeric editors (MFNEs) 

   809  */

   810 class FLayoutMfne

   811     {

   812 public:

   813     FLayoutMfne(){ }

   814     void operator() (CEikMfne* aEd, const TRect& aRect, const TAknWindowComponentLayout& aLay,

   815         const CFont* /*aFont*/, TBool /*aMinimizedView*/) const

   816         {

   817         TAknTextLineLayout lay = TAknWindowComponentLayout::ComposeText(aLay, AknLayoutScalable_Avkon::query_popup_pane_t1()).LayoutLine();

   818         AknLayoutUtils::LayoutMfne(aEd,aRect,lay);

   819         AknsUtils::RegisterControlPosition(aEd);

   820         }

   821     };

   822 

   823 /**

   824  * Layout a single editor

   825  */

   826 template<class Edt, class Fct> 

   827 void DoLayoutEditor(const TRect& aRect, Edt* aEd, Fct aFcn, const CAknMultilineQueryControl::TIndex& aLAFIndex,TBool aButton,TInt aNbrPromptLines,

   828     const CFont* aCustomFont=0, TBool aMinimizeEdwinView=EFalse)

   829     {

   830     if (aEd)

   831         {

   832         if (aLAFIndex.LinePos() == EFirstLine || Layout_Meta_Data::IsLandscapeOrientation())

   833             {

   834                 if(!AknLayoutUtils::PenEnabled() || !aButton)

   835                 {

   836             aFcn(aEd, aRect,

   837                 AknLayoutScalable_Avkon::query_popup_data_pane_cp2(aLAFIndex.CDCQPWindowTextsLine2()),aCustomFont,aMinimizeEdwinView);

   838                 }

   839                 else

   840                 {

   841                 TAknLayoutRect editRect;

   842                 editRect.LayoutRect(aRect,AknLayoutScalable_Avkon::cont_query_data_pane());

   843                 aFcn(aEd, editRect.Rect(),

   844                     AknLayoutScalable_Avkon::query_popup_pane_cp3(),aCustomFont,aMinimizeEdwinView);    

   845                 }

   846             }

   847     

   848         else if (aLAFIndex.LinePos() == ESecondLine)

   849             {

   850                 if(!AknLayoutUtils::PenEnabled())

   851                 {

   852             aFcn(aEd, aRect,

   853                 AknLayoutScalable_Avkon::query_popup_pane_cp2(aLAFIndex.CDCQPWindowTextsLine4()),aCustomFont,aMinimizeEdwinView);

   854                 }

   855                 else

   856                 {

   857                  if(!aButton)

   858                  {

   859                     if(aNbrPromptLines == 1)

   860                     {

   861                         aFcn(aEd, aRect,AknLayoutScalable_Avkon::query_popup_pane_cp2(5),aCustomFont,aMinimizeEdwinView);          

   862                     }

   863                     else //aNbrPromptLines = 2

   864                     {

   865                         aFcn(aEd, aRect,AknLayoutScalable_Avkon::query_popup_pane_cp2(0),aCustomFont,aMinimizeEdwinView);                               

   866                     }

   867                  }

   868                  else

   869                  {

   870                     TAknLayoutRect editRect;

   871                     editRect.LayoutRect(aRect,AknLayoutScalable_Avkon::cont_query_data_pane_cp1());

   872                     aFcn(aEd, editRect.Rect(),

   873                     AknLayoutScalable_Avkon::query_popup_pane_cp3(),aCustomFont,aMinimizeEdwinView);            

   874                  }    

   875                 }                                               

   876             }

   877         

   878         else

   879         #ifdef _DEBUG

   880             __ASSERT_DEBUG(0,Panic(EAknPanicNotSupported));

   881         #endif

   882         

   883         aEd->SetBorder(TGulBorder::ENone); 

   884         }

   885     }

   886 

   887 /**

   888  * Layout every editor

   889  *

   890  */

   891 void CAknMultilineQueryControl::LayoutEditor(const TLayoutMethod& aLayoutM)

   892     {

   893     TRect rect = LayoutRect();

   894     TIndex LAFIndex(iLinePos,iFirstQueryPromptLines,iSecondQueryPromptLines);

   895     TIndex LAFIndex2(iLinePos,iSecondQueryPromptLines,iSecondQueryPromptLines);

   896 

   897     const TIndex *index = &LAFIndex;

   898     if (Layout_Meta_Data::IsLandscapeOrientation() && iLinePos == ESecondLine)

   899         {

   900         index = &LAFIndex2;

   901         }

   902 

   903     iHasEditor = ETrue;

   904     LayoutEditorFrame(aLayoutM);

   905     LayoutEditorIndicator(aLayoutM);

   906 

   907     TBool button=EFalse;

   908     

   909     TInt nbrPromptLines = CAknQueryControl::NbrOfPromptLines();

   910     DoLayoutEditor(rect,iEdwin,FLayoutEdwin(),*index,button,nbrPromptLines,0,ETrue);

   911     DoLayoutEditor(rect,iSecretEd,FLayoutSecretEditor(),*index,button,nbrPromptLines);

   912     

   913     DoLayoutEditor(rect,iTimeEdwin,FLayoutMfne(),*index,button,nbrPromptLines);

   914     DoLayoutEditor(rect,iDateEdwin,FLayoutMfne(),*index,button,nbrPromptLines);

   915     

   916     DoLayoutEditor(rect,iDurationEdwin,FLayoutMfne(),*index,button,nbrPromptLines);

   917     DoLayoutEditor(rect,iNumberEdwin,FLayoutNumericEdwin(),*index,button,nbrPromptLines);

   918     

   919     DoLayoutEditor(rect,iPinEdwin,FLayoutSecretEditor(),*index,button,nbrPromptLines);

   920     DoLayoutEditor(rect,LocationEd(),FLayoutMfne(),*index,button,nbrPromptLines);

   921     }

   922 

   923 /**

   924  * Layout the editor frame

   925  */

   926 void CAknMultilineQueryControl::LayoutEditorFrame(const TLayoutMethod& /*aLayoutM*/)

   927     {

   928     TIndex LAFIndex(iLinePos,iFirstQueryPromptLines,iSecondQueryPromptLines);

   929     TIndex LAFIndex2(EFirstLine,iSecondQueryPromptLines,iSecondQueryPromptLines);

   930     TRect rect = LayoutRect();

   931 

   932     const TIndex *index = &LAFIndex;

   933     if (Layout_Meta_Data::IsLandscapeOrientation() && iLinePos == ESecondLine)

   934         {

   935         index = &LAFIndex2;

   936         }

   937     iEditorVerShadow.LayoutRect(rect, 

   938         AKN_LAYOUT_WINDOW_Combined_data_and_code_query_pop_up_window_elements_Line_1(!IsFocused(),index->CDCQPWindowLine1()));

   939     

   940     iEditorHorShadow.LayoutRect(rect, 

   941         AKN_LAYOUT_WINDOW_Combined_data_and_code_query_pop_up_window_elements_Line_2(!IsFocused(),index->CDCQPWindowLine2()));

   942 

   943     TBool button=EFalse;

   944     

   945     if(!AknLayoutUtils::PenEnabled())

   946         {

   947     iEditorFrame.LayoutRect    (rect, 

   948         AknLayout::Combined_data_and_code_query_pop_up_window_elements_Line_4(index->CDCQPWindowRectangles()));

   949         }

   950     else

   951         {

   952             if(!button)                       

   953             {

   954                if(iLinePos == EFirstLine || Layout_Meta_Data::IsLandscapeOrientation())

   955                {

   956                     if(NbrOfPromptLines() == 1)

   957                     {

   958                 iEditorFrame.LayoutRect(rect,AknLayoutScalable_Avkon::query_popup_pane_cp2(4));      

   959                     }                     

   960                     else //2 lines

   961                     {

   962                         iEditorFrame.LayoutRect(rect,AknLayoutScalable_Avkon::query_popup_data_pane_cp2(0));            

   963                     }

   964                }

   965                else

   966                {

   967                     if(NbrOfPromptLines() == 1)

   968                     {

   969                 iEditorFrame.LayoutRect(rect,AknLayoutScalable_Avkon::query_popup_pane_cp2(5));      

   970                     }

   971                     else

   972                     {

   973                        iEditorFrame.LayoutRect(rect,AknLayoutScalable_Avkon::query_popup_pane_cp2(0));                                               

   974                     }

   975                }

   976             }    

   977             else

   978             {

   979                 TAknLayoutRect rectEditorFrame;                

   980                 TAknLayoutRect popupRect;                                

   981                 if(iLinePos == EFirstLine || Layout_Meta_Data::IsLandscapeOrientation())

   982                 {

   983                     popupRect.LayoutRect(rect,AknLayoutScalable_Avkon::cont_query_data_pane());         

   984                 }

   985                 else

   986                 {

   987                     popupRect.LayoutRect(rect,AknLayoutScalable_Avkon::cont_query_data_pane_cp1());

   988                 }

   989             iEditorFrame.LayoutRect(popupRect.Rect(),AknLayoutScalable_Avkon::query_popup_pane_cp3());                          

   990             }

   991         }                                               

   992     }

   993 

   994 /**

   995  * Layout the editor indicator icons

   996  */

   997 void CAknMultilineQueryControl::LayoutEditorIndicator(const TLayoutMethod& /*aLayoutM*/)

   998     {

   999     CCoeControl* editor = ControlByLayoutOrNull(iQueryType);

  1000     TIndex LAFIndex(iLinePos,iFirstQueryPromptLines,iSecondQueryPromptLines);

  1001 

  1002     if (!iEditIndicator || !editor || iFlags.IsSet(EEditorIndicatorOff))

  1003         return;

  1004         

  1005     if (editor->IsFocused())

  1006         {

  1007         TAknWindowLineLayout indicatorLine;

  1008         

  1009         if ( Layout_Meta_Data::IsLandscapeOrientation() )

  1010             {

  1011             TInt promptLines = ( iLinePos == EFirstLine ?

  1012                 iFirstQueryPromptLines : iSecondQueryPromptLines );

  1013             

  1014             static const TInt lineTable[4] = { 2, 2, 1, 3 };

  1015                 

  1016             indicatorLine = AknLayoutScalable_Avkon::indicator_popup_pane_cp4( lineTable[promptLines] ).LayoutLine();

  1017             }

  1018         else

  1019             {

  1020                 if(iLinePos == ESecondLine && AknLayoutUtils::PenEnabled())

  1021                 {

  1022                     if(NbrOfPromptLines() == 1)

  1023                     {

  1024                     indicatorLine = AknLayoutScalable_Avkon::indicator_popup_pane_cp2(5);                       

  1025                     }

  1026                     else

  1027                     {

  1028                         indicatorLine = AknLayoutScalable_Avkon::indicator_popup_pane_cp2(0);

  1029                     }

  1030                 }

  1031                 else

  1032                 {

  1033             indicatorLine = AKN_LAYOUT_WINDOW_Combined_data_and_code_query_pop_up_window_elements_Line_5(LAFIndex.CDCQPWindowLine5());

  1034                 }

  1035             }

  1036             

  1037         AknLayoutUtils::LayoutControl( iEditIndicator, LayoutRect(), indicatorLine );

  1038         }

  1039     else

  1040         iEditIndicator->SetRect(TRect(TPoint(0,0),TPoint(0,0)));

  1041     }

  1042     

  1043 

  1044 EXPORT_C void CAknMultilineQueryControl::HandleResourceChange( TInt aType ) 

  1045     {

  1046     CCoeControl::HandleResourceChange( aType );

  1047         

  1048     if ( aType == KAknsMessageSkinChange )

  1049         {

  1050         CAknQueryExtension* extension = QueryExtension();

  1051         if( iHasEditor && extension && extension->EditorContext() )

  1052             {

  1053             extension->EditorContext()->SetParentContext( AknsDrawUtils::ControlContextOfParent( this ) );

  1054             }

  1055         }

  1056     else if( aType == KEikDynamicLayoutVariantSwitch ) // JLa 22.09.2006 

  1057         {

  1058         SizeChanged();

  1059         }

  1060     }    

  1061 

  1062 

  1063 /*****************************************************************

  1064  * CAknMultilineQueryControl::TIndex

  1065  *

  1066  * Manage indexes into LAF tables

  1067  *

  1068  * PQDC stands for 'Popup Query Data Code'

  1069  *

  1070  * CDCQP stands for 'Combined Data Code Query Popup'

  1071  ******************************************************************/

  1072 

  1073 /**

  1074  * Construction, iLinePos is the position of the current line, either first or

  1075  * second. iFirstLine is the numeber of prompt lines for the first query, either 1

  1076  * or 2. iSecondline is the number of prompt lines for the second query, either 1 or 2

  1077  */ 

  1078 CAknMultilineQueryControl::TIndex::TIndex(const TLinePosition& aLinePos, 

  1079                                                  TInt aFirstQueryPromptLines, TInt aSecondQueryPromptLines) :

  1080     iLinePos(aLinePos), iFirstQueryPromptLines(aFirstQueryPromptLines), iSecondQueryPromptLines(aSecondQueryPromptLines)

  1081         {

  1082         }

  1083 

  1084 /**

  1085  * Check that we are in a consistent state for retrieving correct indexes

  1086  *

  1087  */

  1088 void CAknMultilineQueryControl::TIndex::SelfTest() const

  1089     {

  1090     __ASSERT_DEBUG(iLinePos == EFirstLine || iLinePos == ESecondLine,

  1091         Panic(EAknPanicInvalidValue));

  1092     __ASSERT_DEBUG(iFirstQueryPromptLines >= 0  && iFirstQueryPromptLines <= 2, 

  1093         Panic(EAknPanicInvalidValue));

  1094     __ASSERT_DEBUG(iSecondQueryPromptLines >= 0 && iSecondQueryPromptLines <= 2, 

  1095         Panic(EAknPanicInvalidValue));

  1096     }

  1097 

  1098 /**

  1099  * We tolerate a null number of prompt lines. If this is the case we set

  1100  * the number of lines to 1 (empty query will use layout of a query with a

  1101  * line of text).

  1102  */

  1103 TInt CAknMultilineQueryControl::TIndex::FirstQueryPromptLines() const

  1104     {

  1105     SelfTest();

  1106     return iFirstQueryPromptLines > 0 ? iFirstQueryPromptLines - 1 : 1;

  1107     }

  1108 

  1109 /**

  1110  * We tolerate a null number of prompt lines. If this is the case we set

  1111  * the number of lines to 1 (empty query will use layout of a query with a

  1112  * line of text).

  1113  */

  1114 TInt CAknMultilineQueryControl::TIndex::SecondQueryPromptLines() const

  1115     {

  1116     SelfTest();

  1117     return iSecondQueryPromptLines > 0 ? iSecondQueryPromptLines - 1: 1;

  1118     }

  1119 

  1120 

  1121 /**

  1122  * Return index into Main Pane PQDC Window, which

  1123  * depends on total number of prompt lines minus 2, e.g.

  1124  * index 0 for 2 prompt lines total.

  1125  *

  1126  */

  1127 TInt CAknMultilineQueryControl::TIndex::MainPanePQDCWindow() const

  1128     {

  1129     SelfTest();

  1130     static const TInt KMainPanePQDCWindow[3] = {0,1,2}; 

  1131     return KMainPanePQDCWindow[FirstQueryPromptLines() + SecondQueryPromptLines()];

  1132     }

  1133 

  1134 /**