1 /*******************************************************************************

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

     3  * All rights reserved. This program and the accompanying materials

     4  * are made available under the terms of the Eclipse Public License v1.0

     5  * which accompanies this distribution, and is available at

     6  * http://www.eclipse.org/legal/epl-v10.html

     7  *

     8  * Contributors:

     9  *     Nokia Corporation - S60 implementation

    10  *******************************************************************************/

    11 

    12 

    13 #include <AknsDrawUtils.h>

    14 #include <AknUtils.h>

    15 #include <eiklbi.h>

    16 #include <eikenv.h>

    17 #include <AknsUtils.h>

    18 #include <aknconsts.h>

    19 #include <AknLayoutFont.h>

    20 #include <AknBidiTextUtils.h>

    21 #include <swtlaffacade.h>

    22 #include <avkon.mbg>

    23 #include "swtlabel.h"

    24 #include "swtcontrolbase.h"

    25 #include "swtfont.h"

    26 

    27 

    28 const TInt KBorderMargin = 1;

    29 

    30 

    31 // ======== MEMBER FUNCTIONS ========

    32 

    33 

    34 // ---------------------------------------------------------------------------

    35 // CSwtLabel::CSwtLabel

    36 // ---------------------------------------------------------------------------

    37 //

    38 CSwtLabel::CSwtLabel(MSwtDisplay& aDisplay, TSwtPeer aPeer,

    39                      MSwtComposite& aParent, TInt aStyle)

    40         : ASwtControlBase(aDisplay, aPeer, &aParent, aStyle)

    41         , iOriginalText(NULL)

    42 {

    43     SetFocusing(EFalse);

    44 }

    45 

    46 // ---------------------------------------------------------------------------

    47 // CSwtLabel::~CSwtLabel

    48 // ---------------------------------------------------------------------------

    49 //

    50 CSwtLabel::~CSwtLabel()

    51 {

    52     delete iEikLabel;

    53     delete iSeparatorHead;

    54     delete iSeparatorHeadMask;

    55     delete iSeparatorCenter;

    56     delete iSeparatorCenterMask;

    57     delete iSeparatorTail;

    58     delete iSeparatorTailMask;

    59     delete iOriginalText;

    60 

    61     if (iDefaultFont)

    62     {

    63         iDefaultFont->RemoveRef();

    64     }

    65 

    66     if (iImage != NULL)

    67         iImage->RemoveRef();

    68 

    69 #ifdef _lint

    70     iDefaultFont = NULL;

    71     iImage       = NULL;

    72     iForegroundColor = NULL;

    73 #endif

    74 }

    75 

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

    77 // CSwtLabel::ConstructL

    78 // ---------------------------------------------------------------------------

    79 //

    80 void CSwtLabel::ConstructL()

    81 {

    82     CCoeControl& coeParent = iParent->Control()->CoeControl();

    83 

    84     SetContainerWindowL(coeParent);

    85 

    86     CAknControl::MakeVisible(coeParent.IsVisible());

    87     CAknControl::SetDimmed(coeParent.IsDimmed());

    88 

    89     if (iStyle & KSwtStyleSeparator)

    90     {

    91         CreateSeparatorL();

    92     }

    93     else

    94     {

    95         CreateTextL();

    96     }

    97 

    98     SetBackground(this);   // Back will be drawn by ASwtControlBase::Draw

    99     ActivateL();

   100 }

   101 

   102 // ---------------------------------------------------------------------------

   103 // CSwtLabel::CreateTextL

   104 // ---------------------------------------------------------------------------

   105 //

   106 void CSwtLabel::CreateTextL()

   107 {

   108     ASSERT(!(iStyle & KSwtStyleSeparator));

   109     ASSERT(!iEikLabel);

   110 

   111     iEikLabel = new(ELeave) CEikLabel();

   112     iEikLabel->SetFocusing(EFalse);

   113     iEikLabel->SetContainerWindowL(*this);

   114     iEikLabel->MakeVisible(EFalse);

   115     iEikLabel->SetDimmed(IsDimmed());

   116     iEikLabel->SetTextL(KNullDesC);

   117     SetAlignment(iStyle & KSwtAlignmentMask);

   118     RetrieveDefaultFontL();

   119     DoSetFontL(&iDefaultFont->Font());

   120     UpdateTextColor();

   121 

   122     // Correct position of CEikLabel will be set in PositionChanged()

   123 }

   124 

   125 // ---------------------------------------------------------------------------

   126 // CSwtLabel::CreateSeparatorL

   127 // ---------------------------------------------------------------------------

   128 //

   129 void CSwtLabel::CreateSeparatorL()

   130 {

   131     ASSERT(!iEikLabel);

   132     ASSERT(!iImage);

   133 

   134     delete iSeparatorHead;

   135     iSeparatorHead = NULL;

   136     delete iSeparatorHeadMask;

   137     iSeparatorHeadMask = NULL;

   138     delete iSeparatorCenter;

   139     iSeparatorCenter = NULL;

   140     delete iSeparatorCenterMask;

   141     iSeparatorCenterMask = NULL;

   142     delete iSeparatorTail;

   143     iSeparatorTail = NULL;

   144     delete iSeparatorTailMask;

   145     iSeparatorTailMask = NULL;

   146 

   147     // Get skin and bitmap ids

   148     TAknsItemID separatorHeadSkinId;

   149     TAknsItemID separatorCenterSkinId;

   150     TAknsItemID separatorTailSkinId;

   151 

   152     TInt separatorCenterId;

   153     TInt separatorCenterMaskId;

   154 

   155     if (iStyle & KSwtStyleVertical)

   156     {

   157 

   158         if (iStyle & KSwtStyleShadowIn)

   159         {

   160             separatorHeadSkinId.Set(KAknsIIDQsnFrSeparatorVTShdwin);

   161             separatorCenterSkinId.Set(KAknsIIDQsnFrSeparatorVMShdwin);

   162             separatorTailSkinId.Set(KAknsIIDQsnFrSeparatorVBShdwin);

   163         }

   164         else if (iStyle & KSwtStyleShadowOut)

   165         {

   166             separatorHeadSkinId.Set(KAknsIIDQsnFrSeparatorVTShdwout);

   167             separatorCenterSkinId.Set(KAknsIIDQsnFrSeparatorVMShdwout);

   168             separatorTailSkinId.Set(KAknsIIDQsnFrSeparatorVBShdwout);

   169         }

   170         else

   171         {

   172             separatorHeadSkinId.Set(KAknsIIDQsnFrSeparatorVTShdwnone);

   173             separatorCenterSkinId.Set(KAknsIIDQsnFrSeparatorVMShdwnone);

   174             separatorTailSkinId.Set(KAknsIIDQsnFrSeparatorVBShdwnone);

   175         }

   176     }

   177     else

   178     {

   179 

   180         if (iStyle & KSwtStyleShadowIn)

   181         {

   182             separatorHeadSkinId.Set(KAknsIIDQsnFrSeparatorHLShdwin);

   183             separatorCenterSkinId.Set(KAknsIIDQsnFrSeparatorHMShdwin);

   184             separatorTailSkinId.Set(KAknsIIDQsnFrSeparatorHRShdwin);

   185         }

   186         else if (iStyle & KSwtStyleShadowOut)

   187         {

   188             separatorHeadSkinId.Set(KAknsIIDQsnFrSeparatorHLShdwout);

   189             separatorCenterSkinId.Set(KAknsIIDQsnFrSeparatorHMShdwout);

   190             separatorTailSkinId.Set(KAknsIIDQsnFrSeparatorHRShdwout);

   191         }

   192         else

   193         {

   194             separatorHeadSkinId.Set(KAknsIIDQsnFrSeparatorHLShdwnone);

   195             separatorCenterSkinId.Set(KAknsIIDQsnFrSeparatorHMShdwnone);

   196             separatorTailSkinId.Set(KAknsIIDQsnFrSeparatorHRShdwnone);

   197         }

   198     }

   199 

   200 

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

   202 

   203 

   204     // first, try to get separator specific images from skin

   205     _LIT(KNoneFile," ");

   206     TInt err(KErrNone);

   207 

   208     TRAP(err, AknsUtils::CreateIconL(

   209              skin,

   210              separatorHeadSkinId,

   211              iSeparatorHead,

   212              iSeparatorHeadMask,

   213              KNoneFile,

   214              0,

   215              0));

   216 

   217 

   218     if (err == KErrNone)

   219     {

   220 

   221         TRAP(err, AknsUtils::CreateIconL(

   222                  skin,

   223                  separatorCenterSkinId,

   224                  iSeparatorCenter,

   225                  iSeparatorCenterMask,

   226                  KNoneFile,

   227                  0,

   228                  0));

   229     }

   230 

   231     if (err == KErrNone)

   232     {

   233 

   234         TRAP(err, AknsUtils::CreateIconL(

   235                  skin,

   236                  separatorTailSkinId,

   237                  iSeparatorTail,

   238                  iSeparatorTailMask,

   239                  KNoneFile,

   240                  0,

   241                  0));

   242     }

   243 

   244     if (err != KErrNone)

   245         // if separator specific images are not available from skin

   246         // try to use dashed line image from skin, or from image file

   247     {

   248 

   249         if (iStyle & KSwtStyleVertical)

   250         {

   251             separatorCenterSkinId = KAknsIIDQgnGrafLinePrimaryVerticalDashed;

   252             separatorCenterId = EMbmAvkonQgn_graf_line_primary_vertical_dashed;

   253             separatorCenterMaskId = EMbmAvkonQgn_graf_line_primary_vertical_dashed_mask;

   254 

   255         }

   256         else

   257         {

   258             separatorCenterSkinId = KAknsIIDQgnGrafLinePrimaryHorizontalDashed;

   259             separatorCenterId = EMbmAvkonQgn_graf_line_primary_horizontal_dashed;

   260             separatorCenterMaskId = EMbmAvkonQgn_graf_line_primary_horizontal_dashed_mask;

   261         }

   262 

   263         AknsUtils::CreateIconL(

   264             skin,

   265             separatorCenterSkinId,

   266             iSeparatorCenter,

   267             iSeparatorCenterMask,

   268             KAvkonBitmapFile,

   269             separatorCenterId,

   270             separatorCenterMaskId);

   271 

   272         delete iSeparatorHead;

   273         iSeparatorHead = NULL;

   274         delete iSeparatorHeadMask;

   275         iSeparatorHeadMask =NULL;

   276         delete iSeparatorTail;

   277         iSeparatorTail = NULL;

   278         delete iSeparatorTailMask;

   279         iSeparatorTailMask = NULL;

   280         iDashedLineSeparatorInUse =  ETrue;

   281     }

   282 

   283 

   284     // Get separator thickness

   285     TAknLayoutRect layoutRect;

   286     const TInt KBigEnough(50);

   287     if (iStyle & KSwtStyleVertical)

   288     {

   289         layoutRect = CSwtLafFacade::GetLayoutRect(CSwtLafFacade::ESeparatorVerticalPane,

   290                      TRect(0, 0, KBigEnough, KBigEnough), 0);

   291         iSeparatorThickness = layoutRect.Rect().Size().iWidth;

   292     }

   293     else

   294     {

   295         layoutRect = CSwtLafFacade::GetLayoutRect(CSwtLafFacade::ESeparatorHorizontalPane,

   296                      TRect(0, 0, KBigEnough, KBigEnough), 0);

   297         iSeparatorThickness = layoutRect.Rect().Size().iHeight;

   298     }

   299 

   300     if (iDashedLineSeparatorInUse)

   301     {

   302         iSeparatorThickness = 1;

   303     }

   304 

   305     ResizeSeparatorImages();

   306 

   307 }

   308 

   309 // ---------------------------------------------------------------------------

   310 // CSwtLabel::NewL

   311 // ---------------------------------------------------------------------------

   312 //

   313 CSwtLabel* CSwtLabel::NewL(MSwtDisplay& aDisplay,

   314                            TSwtPeer aPeer, MSwtComposite& aParent, TInt aStyle)

   315 {

   316     CSwtLabel* self = new(ELeave) CSwtLabel(aDisplay, aPeer, aParent, aStyle);

   317     CleanupStack::PushL(self);

   318     self->ConstructL();

   319     self->InitControlBaseL();

   320     CleanupStack::Pop(self);

   321     return self;

   322 }

   323 

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

   325 // CSwtLabel::ClipTextL

   326 // ---------------------------------------------------------------------------

   327 //

   328 void  CSwtLabel::ClipTextL(TInt aWHint)

   329 {

   330     if (iOriginalText == NULL || aWHint <= 0 || !iEikLabel)

   331     {

   332         return;

   333     }

   334 

   335     RBuf textToClip;

   336     textToClip.Create(*iOriginalText);

   337     textToClip.CleanupClosePushL();

   338 

   339     const CFont* font = iEikLabel->Font();

   340     if (iOriginalTextLineCount == 1)

   341     {

   342         if (aWHint > font->CharWidthInPixels(CEditableText::EEllipsis))

   343         {

   344             AknTextUtils::ClipToFit(textToClip, *font, aWHint);

   345         }

   346     }

   347     iEikLabel->SetTextL(textToClip);

   348 

   349     CleanupStack::PopAndDestroy(); // textToClip

   350 }

   351 

   352 // ---------------------------------------------------------------------------

   353 // CSwtLabel::ComputeTextSizeL

   354 // ---------------------------------------------------------------------------

   355 //

   356 TSize CSwtLabel::ComputeTextSizeL(TInt aWHint, TInt aHHint)

   357 {

   358     // Return non default hints

   359     if (aWHint != KSwtDefault && aHHint != KSwtDefault)

   360     {

   361         return TSize(aWHint, aHHint);

   362     }

   363 

   364     // Compute size

   365     TSize prefSize(0, 0);

   366     if ((iStyle & KSwtStyleWrap) && !(aWHint == KSwtDefault && aHHint == KSwtDefault))

   367     {

   368         // Wrap text with a default hint

   369         if (aWHint != KSwtDefault)

   370         {

   371             prefSize.iWidth = aWHint;

   372             prefSize.iHeight = CalcWrappedTextHeightL(aWHint);

   373         }

   374         else

   375         {

   376             prefSize.iHeight = aHHint;

   377             prefSize.iWidth = CalcWrappedTextWidth(aHHint);

   378         }

   379     }

   380     else

   381     {

   382         // This will return the width of the longer line and height that fits all lines

   383         prefSize = MinimumSize();

   384     }

   385 

   386     // Avoid text touching the border

   387     prefSize += TPoint(2 * KBorderMargin, 2 * KBorderMargin);

   388 

   389     if (aHHint != KSwtDefault)

   390     {

   391         prefSize.iHeight = aHHint;

   392     }

   393 

   394     if (aWHint != KSwtDefault)

   395     {

   396         prefSize.iWidth = aWHint;

   397     }

   398 

   399     return prefSize;

   400 }

   401 

   402 // ---------------------------------------------------------------------------

   403 // CSwtLabel::CalcWrappedTextHeightL

   404 // ---------------------------------------------------------------------------

   405 //

   406 TInt CSwtLabel::CalcWrappedTextHeightL(TInt aWidth)

   407 {

   408     if (iOriginalText == NULL || aWidth <= 0 || !iEikLabel)

   409     {

   410         return 0;

   411     }

   412 

   413     // Calculate the number of lines when wrapping text to the given rectangle

   414     const TInt ARRAY_GRANULARITY = 4;

   415     CArrayFixFlat<TPtrC>* wrappedArray = new(ELeave) CArrayFixFlat<TPtrC>(ARRAY_GRANULARITY);

   416     CleanupStack::PushL(wrappedArray);

   417     const CFont* font(iEikLabel->Font());

   418 

   419     // NOTE!!! AknTextUtils::WrapToArrayL behaves strange for strings that

   420     // contain '-' (dash) char. Sometimes return one lesser line if several

   421     // dashes are encountered.

   422 

   423     AknTextUtils::WrapToArrayL(*iOriginalText, aWidth, *font, *wrappedArray);

   424     TInt nbStrings = wrappedArray->Count();

   425     if (nbStrings < 1)

   426     {

   427         // It happens when aWidth < Char's width

   428         // here just set nBStrings to 1

   429         // so something can be visible.

   430         nbStrings = 1;

   431     }

   432 

   433     // Calculate text height

   434     const TInt result(MinimumHeight(nbStrings));

   435 

   436     wrappedArray->Reset();

   437     CleanupStack::PopAndDestroy(wrappedArray);

   438 

   439     return result;

   440 }

   441 

   442 // ---------------------------------------------------------------------------

   443 // CSwtLabel::CalcWrappedTextWidth

   444 // ---------------------------------------------------------------------------

   445 //

   446 TInt CSwtLabel::CalcWrappedTextWidth(TInt aHeight)

   447 {

   448     if (iOriginalText == NULL || aHeight <= 0)

   449     {

   450         return 0;

   451     }

   452     // This will return the width of the longer line and height that fits all lines

   453     return MinimumWidth();

   454 }

   455 

   456 // ---------------------------------------------------------------------------

   457 // CSwtLabel::WrapTextL

   458 // ---------------------------------------------------------------------------

   459 //

   460 void CSwtLabel::WrapTextL(TSize aSize)

   461 {

   462     WrapTextL(aSize.iWidth, aSize.iHeight);

   463 }

   464 

   465 // ---------------------------------------------------------------------------

   466 // CSwtLabel::WrapTextL

   467 // ---------------------------------------------------------------------------

   468 //

   469 void CSwtLabel::WrapTextL(TInt aWHint, TInt aHHint)

   470 {

   471     if (iOriginalText == NULL || aWHint <= 0 || aHHint <= 0 || !iEikLabel)

   472     {

   473         return;

   474     }

   475 

   476     const CFont* font = iEikLabel->Font();

   477 

   478     // Estimate how many text rows within given rectangle

   479     TInt textPaneHeight = GetFontHeight(font);

   480     const TInt gap = iEikLabel->PixelGapBetweenLines();

   481 

   482     // The last row in label does not add a gap after it. So...

   483     // aHHint = rows * textPaneHeight + (rows - 1) * gap; and therefore...

   484     TInt rows = (aHHint + gap) / (textPaneHeight + gap);

   485     if (rows < 1)

   486     {

   487         // It happens when hint height < Char's height

   488         // here just set nBStrings to 1

   489         // so something can be visible.

   490         rows = 1;

   491     }

   492 

   493     // Setup width arrray

   494     CArrayFixFlat< TInt >* widthsArray = new(ELeave) CArrayFixFlat< TInt >(rows);

   495     CleanupStack::PushL(widthsArray);

   496     widthsArray->SetReserveL(rows);

   497     TInt i;

   498     for (i = 0; i < rows; ++i)

   499     {

   500         widthsArray->AppendL(aWHint);

   501     }

   502 

   503     // Convert text into wrapped text with AKnTextUtils

   504     RBuf wrappedBuffer;

   505     const TInt KDouble(2);

   506     wrappedBuffer.CreateL(KDouble *(iOriginalText->Length()));

   507     wrappedBuffer.CleanupClosePushL();

   508     AknTextUtils::WrapToStringAndClipL(*iOriginalText, *widthsArray, *font, wrappedBuffer);

   509 

   510     // Set wrapped text

   511     iEikLabel->SetTextL(wrappedBuffer);

   512 

   513     CleanupStack::PopAndDestroy(); // wrappedBuffer

   514     CleanupStack::PopAndDestroy(widthsArray);

   515 }

   516 

   517 // ---------------------------------------------------------------------------

   518 // CSwtLabel::RetrieveDefaultFontL

   519 // ---------------------------------------------------------------------------

   520 //

   521 void CSwtLabel::RetrieveDefaultFontL()

   522 {

   523     ASSERT(iEikLabel);

   524     if (iDefaultFont)

   525     {

   526         iDefaultFont->RemoveRef();

   527         iDefaultFont = NULL;

   528     }

   529     // Same as Button's

   530     iDefaultFont = CSwtFont::NewL(iDisplay.Device(), iDisplay.Device().GetSystemFont()->Font());

   531 }

   532 

   533 // ---------------------------------------------------------------------------

   534 // CSwtLabel::MinimumSize

   535 // Replaces CEikLabel's MinimumSize to fix some texts getting ellipsed and clipped

   536 // ---------------------------------------------------------------------------

   537 //

   538 TSize CSwtLabel::MinimumSize() const

   539 {

   540     const TInt height = MinimumHeight();

   541     const TInt width = MinimumWidth();

   542     return TSize(width, height);

   543 }

   544 

   545 // ---------------------------------------------------------------------------

   546 // CSwtLabel::MinimumWidth

   547 // Replaces CEikLabel's MinimumWidth to fix some texts getting ellipsed.

   548 // ---------------------------------------------------------------------------

   549 //

   550 TInt CSwtLabel::MinimumWidth() const

   551 {

   552     if (!iEikLabel || !iOriginalText)

   553     {

   554         return 0;

   555     }

   556 

   557     TInt result = 0;

   558     TPtrC ptr(iOriginalText->Des());

   559     const CFont* font = iEikLabel->Font();

   560     CFont::TMeasureTextInput::TFlags order = CFont::TMeasureTextInput::EFVisualOrder;

   561     if (AknLayoutUtils::LayoutMirrored())

   562     {

   563         order = CFont::TMeasureTextInput::EFVisualOrderRightToLeft;

   564     }

   565 

   566     FOREVER

   567     {

   568         const TInt pos = ptr.Locate('\n');

   569         TPtrC left = ptr;

   570         if (pos >= 0)

   571         {

   572             left.Set(ptr.Left(pos));

   573         }

   574         TInt lineW = AknBidiTextUtils::MeasureTextBoundsWidth(*font, left, order);

   575         if (lineW > result)

   576         {

   577             result = lineW;

   578         }

   579         if (pos < 0 || pos == ptr.Length() - 1)

   580         {

   581             break;

   582         }

   583         ptr.Set(ptr.Mid(pos + 1));

   584     }

   585 

   586     return result;

   587 }

   588 

   589 // ---------------------------------------------------------------------------

   590 // CSwtLabel::MinimumHeight

   591 // Replaces CEikLabel's MinimumHeight to fix some texts getting clipped

   592 // ---------------------------------------------------------------------------

   593 //

   594 TInt CSwtLabel::MinimumHeight() const

   595 {

   596     return(MinimumHeight(iOriginalTextLineCount));

   597 }

   598 

   599 // ---------------------------------------------------------------------------

   600 // CSwtLabel::MinimumHeight

   601 // Replaces CEikLabel's MinimumHeight to fix some texts getting clipped

   602 // ---------------------------------------------------------------------------

   603 //

   604 TInt CSwtLabel::MinimumHeight(TInt aLineCount) const

   605 {

   606     if (!iEikLabel)

   607     {

   608         return 0;

   609     }

   610 

   611     // Compared to CEikLabel's MinimumHeight() we add one more gap.

   612     // This is to fix some fonts getting clipped from above.

   613     // Do not change this ever, as wrapping will surely brake.

   614     return aLineCount * iEikLabel->PixelGapBetweenLines()

   615            + aLineCount * GetFontHeight(iEikLabel->Font());

   616 }

   617 

   618 // ---------------------------------------------------------------------------

   619 // CSwtLabel::DoSetFontL

   620 // ---------------------------------------------------------------------------

   621 //

   622 void CSwtLabel::DoSetFontL(const CFont* aFont)

   623 {

   624     if (!iEikLabel)

   625     {

   626         return;

   627     }

   628     iEikLabel->SetFont(aFont);

   629     if (aFont)

   630     {

   631         // The gap must be set exaclty in the same way as in AknLayoutUtils::LayoutLabel().

   632         // So, do not modify this unless CEikLabel does too!

   633         iEikLabel->SetPixelGapBetweenLines(

   634             Max(aFont->FontLineGap() - aFont->HeightInPixels(), KSwtMinLinePadding));

   635 

   636         // This is to fix some fonts getting to much space after last line.

   637         iEikLabel->iMargin.iTop = aFont->FontMaxDescent();

   638 

   639         TRAP_IGNORE(ClipTextL(iEikLabel->Size().iWidth));

   640     }

   641 }

   642 

   643 // ---------------------------------------------------------------------------

   644 // CSwtLabel::GetFontHeight

   645 // ---------------------------------------------------------------------------

   646 //

   647 TInt CSwtLabel::GetFontHeight(const CFont* aFont) const

   648 {

   649     if (!aFont)

   650     {

   651         return 0;

   652     }

   653 

   654 #ifdef RD_JAVA_S60_RELEASE_9_2

   655     return aFont->FontMaxHeight();

   656 #else

   657     return aFont->HeightInPixels();

   658 #endif

   659 }

   660 

   661 // ---------------------------------------------------------------------------

   662 // CSwtLabel::Draw

   663 // From CCoeControl

   664 // ---------------------------------------------------------------------------

   665 //

   666 void CSwtLabel::Draw(const TRect& aRect) const

   667 {

   668     ASSERT(!(iCtrlFlags & EFlagDoNotDraw));

   669 

   670     const TRect clientRect(BorderInnerRect());

   671     TRect dirtyClientRect(clientRect);

   672     dirtyClientRect.Intersection(aRect);

   673 

   674     CWindowGc& gc = SystemGc();

   675 

   676     // Draw the image if we have one

   677     if (iImage != NULL && !iEikLabel->IsVisible())   //lint !e613 iEikLabel cannot be NULL if iImage is not

   678     {

   679         const TSize imgSize(iImage->GetBounds().Size());

   680         TPoint imgPos(TPoint::EUninitialized);

   681 

   682 

   683         const TBool leftToRight((iStyle & KSwtStyleRightToLeft)

   684                                 || AknLayoutUtils::LayoutMirrored());

   685         if (iStyle & KSwtStyleCenter)

   686         {

   687             imgPos.iX = clientRect.iTl.iX + (clientRect.Width() - imgSize.iWidth) / 2;

   688         }

   689         else if (((iStyle & KSwtStyleTrail) && (!leftToRight))

   690                  || ((iStyle &  KSwtStyleLead) && leftToRight))

   691         {

   692             imgPos.iX = clientRect.iBr.iX - imgSize.iWidth;

   693         }

   694         else

   695         {

   696             imgPos.iX = clientRect.iTl.iX;

   697         }

   698 

   699         // Vertical alignment ( always centered )

   700         imgPos.iY = clientRect.iTl.iY + (clientRect.Height() - imgSize.iHeight) / 2;

   701 

   702         TRect drawRect(imgPos, imgSize);

   703         drawRect.Intersection(dirtyClientRect);

   704 

   705         if (!drawRect.IsEmpty())

   706         {

   707             TRect imgRect(drawRect);

   708             imgRect.Move(-imgPos);

   709 

   710             const CFbsBitmap& bitmap = iImage->Bitmap();

   711             const CFbsBitmap* mask   = iImage->MaskBitmap();

   712             if (mask == NULL)

   713                 gc.BitBlt(drawRect.iTl, &bitmap, imgRect);

   714             else

   715                 gc.BitBltMasked(drawRect.iTl, &bitmap, imgRect, mask, EFalse);

   716         }

   717     }

   718     else if (iSeparatorCenter)

   719     {

   720         DrawSeparator(gc);

   721     }

   722 }

   723 

   724 // ---------------------------------------------------------------------------

   725 // CSwtLabel::FocusChanged

   726 // From CCoeControl

   727 // ---------------------------------------------------------------------------

   728 //

   729 void CSwtLabel::FocusChanged(TDrawNow aDrawNow)

   730 {

   731     // Labels are not supposed to gain focus on their own, but they may still

   732     // get it through ForceFocus().

   733     TBool focused = IsFocused();

   734     if (iEikLabel)

   735     {

   736         iEikLabel->SetFocus(focused);

   737     }

   738 

   739     HandleFocusChanged(aDrawNow);

   740 }

   741 

   742 // ---------------------------------------------------------------------------

   743 // CSwtLabel::SetDimmed

   744 // From CCoeControl

   745 // ---------------------------------------------------------------------------

   746 //

   747 void CSwtLabel::SetDimmed(TBool aDimmed)

   748 {

   749     CAknControl::SetDimmed(aDimmed);

   750     if (iEikLabel)

   751     {

   752         iEikLabel->SetDimmed(aDimmed);

   753     }

   754 }

   755 

   756 // ---------------------------------------------------------------------------

   757 // CSwtLabel::ComponentControl

   758 // From CCoeControl

   759 // ---------------------------------------------------------------------------

   760 //

   761 CCoeControl* CSwtLabel::ComponentControl(TInt /*aIndex*/) const

   762 {

   763     if (iEikLabel)

   764     {

   765         return static_cast< CCoeControl* >(iEikLabel);

   766     }

   767     else

   768     {

   769         return NULL;

   770     }

   771 } //lint !e1763

   772 

   773 // ---------------------------------------------------------------------------

   774 // CSwtLabel::CountComponentControls

   775 // From CCoeControl

   776 // ---------------------------------------------------------------------------

   777 //

   778 TInt CSwtLabel::CountComponentControls() const

   779 {

   780     if (iEikLabel)

   781     {

   782         return 1;

   783     }

   784     else

   785     {

   786         return 0;

   787     }

   788 }

   789 

   790 // ---------------------------------------------------------------------------

   791 // CSwtLabel::OfferKeyEventL

   792 // From CCoeControl

   793 // ---------------------------------------------------------------------------

   794 //

   795 TKeyResponse CSwtLabel::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

   796 {

   797     return HandleKeyL(aKeyEvent, aType, ETrue);

   798 }

   799 

   800 // ---------------------------------------------------------------------------

   801 // CSwtLabel::HandleResourceChange

   802 // From CCoeControl

   803 // ---------------------------------------------------------------------------

   804 //

   805 void CSwtLabel::HandleResourceChange(TInt aType)

   806 {

   807     TRAP_IGNORE(SwtHandleResourceChangeL(aType));

   808 }

   809 

   810 // ---------------------------------------------------------------------------

   811 // CSwtLabel::SwtHandleResourceChangeL

   812 // ---------------------------------------------------------------------------

   813 //

   814 void CSwtLabel::SwtHandleResourceChangeL(TInt aType)

   815 {

   816     CAknControl::HandleResourceChange(aType);

   817     if (aType == KAknsMessageSkinChange || aType == KEikDynamicLayoutVariantSwitch)

   818     {

   819         if (iEikLabel)

   820         {

   821             RetrieveDefaultFontL();

   822             if (!iFont)

   823             {

   824                 iEikLabel->SetFont(&iDefaultFont->Font());

   825             }

   826         }

   827         else if (iStyle & KSwtStyleSeparator)

   828         {

   829             CreateSeparatorL();

   830         }

   831 

   832         if (aType == KAknsMessageSkinChange)

   833         {

   834             UpdateTextColor();

   835         }

   836     }

   837     else if (aType == KEikDynamicLayoutVariantSwitch)

   838     {

   839         SetAlignment(iStyle & KSwtAlignmentMask);

   840     }

   841 }

   842 

   843 // ---------------------------------------------------------------------------

   844 // CSwtLabel::PositionChanged

   845 // From CCoeControl

   846 // ---------------------------------------------------------------------------

   847 //

   848 void CSwtLabel::PositionChanged()

   849 {

   850     if (iEikLabel)

   851     {

   852         TRect clientRect(BorderInnerRect());

   853         if (HasBorderStyle())

   854         {

   855             // The text should not touch the border

   856             iEikLabel->SetPosition(clientRect.iTl + TPoint(KBorderMargin, KBorderMargin));

   857         }

   858         else

   859         {

   860             iEikLabel->SetPosition(clientRect.iTl);

   861         }

   862     }

   863     else if (iSeparatorCenter)

   864     {

   865         ResizeSeparatorImages();

   866     }

   867 

   868     HandlePositionChanged();

   869 }

   870 

   871 // ---------------------------------------------------------------------------

   872 // CSwtLabel::SizeChanged

   873 // From CCoeControl

   874 // ---------------------------------------------------------------------------

   875 //

   876 void CSwtLabel::SizeChanged()

   877 {

   878     if (iEikLabel)

   879     {

   880         const TRect clientRect(BorderInnerRect());

   881         if (HasBorderStyle())

   882         {

   883             // The text should not touch the border

   884             iEikLabel->SetSize(clientRect.Size() - TPoint(2 * KBorderMargin, 2 * KBorderMargin));

   885         }

   886         else

   887         {

   888             iEikLabel->SetSize(clientRect.Size());

   889         }

   890 

   891         if (iStyle & KSwtStyleWrap)

   892         {

   893             TRAP_IGNORE(WrapTextL(iEikLabel->Size()));

   894         }

   895         else

   896         {

   897             TRAP_IGNORE(ClipTextL(iEikLabel->Size().iWidth));

   898         }

   899     }

   900     else if (iSeparatorCenter)

   901     {

   902         ResizeSeparatorImages();

   903     }

   904 

   905     HandleSizeChanged();

   906 }

   907 

   908 // ---------------------------------------------------------------------------

   909 // CSwtLabel::MopSupplyObject

   910 // From CCoeControl

   911 // ---------------------------------------------------------------------------

   912 //

   913 TTypeUid::Ptr CSwtLabel::MopSupplyObject(TTypeUid aId)

   914 {

   915     TTypeUid::Ptr id = ASwtControlBase::SwtMopSupplyObject(aId);

   916 

   917     if (id.Pointer() == NULL)

   918     {

   919         return CAknControl::MopSupplyObject(aId);

   920     }

   921     else

   922     {

   923         return id;

   924     }

   925 }

   926 

   927 // ---------------------------------------------------------------------------

   928 // CSwtLabel::CoeControl

   929 // From MSwtControl

   930 // ---------------------------------------------------------------------------

   931 //

   932 CCoeControl& CSwtLabel::CoeControl()

   933 {

   934     return *this;

   935 }

   936 

   937 // ---------------------------------------------------------------------------

   938 // CSwtLabel::CoeControl

   939 // From MSwtControl

   940 // ---------------------------------------------------------------------------

   941 //

   942 const CCoeControl& CSwtLabel::CoeControl() const

   943 {

   944     return *this;

   945 }

   946 

   947 // ---------------------------------------------------------------------------

   948 // CSwtLabel::IsFocusable

   949 // From MSwtControl

   950 // ---------------------------------------------------------------------------

   951 //

   952 TBool CSwtLabel::IsFocusable(TInt aReason /*=KSwtFocusByApi*/) const

   953 {

   954     const CCoeControl& coeCtrl = CoeControl();

   955 

   956     // Invisible or disabled controls can never get the focus ( not even forced )

   957     if (!coeCtrl.IsVisible() || coeCtrl.IsDimmed())

   958         return EFalse;

   959     else

   960         return aReason == KSwtFocusByForce;

   961 }

   962 

   963 // ---------------------------------------------------------------------------

   964 // CSwtLabel::ProcessKeyEventL

   965 // From MSwtControl

   966 // ---------------------------------------------------------------------------

   967 //

   968 void CSwtLabel::ProcessKeyEventL(const TKeyEvent& /*aKeyEvent*/, TEventCode /*aType*/)

   969 {

   970     // Do nothing

   971 }

   972 

   973 // ---------------------------------------------------------------------------

   974 // CSwtLabel::ComputeSizeL

   975 // From MSwtControl

   976 // ---------------------------------------------------------------------------

   977 //

   978 TSize CSwtLabel::ComputeSizeL(TInt aWHint, TInt aHHint)

   979 {

   980     if (aWHint != KSwtDefault && aHHint != KSwtDefault)

   981     {

   982         return TSize(aWHint, aHHint);

   983     }

   984 

   985     TSize prefSize(0, 0);

   986     if (iSeparatorCenter)

   987     {

   988         if (aHHint != KSwtDefault)

   989         {

   990             prefSize.iHeight = aHHint;

   991         }

   992         else if (!(iStyle & KSwtStyleVertical))

   993         {

   994             prefSize.iHeight = Min(iSeparatorThickness, prefSize.iHeight);

   995         }

   996 

   997         if (aWHint != KSwtDefault)

   998         {

   999             prefSize.iWidth = aWHint;

  1000         }

  1001         else if (iStyle & KSwtStyleVertical)

  1002         {

  1003             prefSize.iWidth = Min(iSeparatorThickness, prefSize.iWidth);

  1004         }

  1005     }

  1006 

  1007     if (iImage)

  1008     {

  1009         prefSize = iImage->GetBounds().Size();

  1010     }

  1011     else

  1012     {

  1013         prefSize = ComputeTextSizeL(aWHint, aHHint);

  1014     }

  1015 

  1016     if (!iSeparatorCenter)

  1017     {

  1018         prefSize += BorderSizeDelta();

  1019     }

  1020 

  1021     if (aWHint != KSwtDefault)

  1022     {

  1023         prefSize.iWidth = aWHint;

  1024     }

  1025     if (aHHint != KSwtDefault)

  1026     {

  1027         prefSize.iHeight = aHHint;

  1028     }

  1029 

  1030     return prefSize;

  1031 }

  1032 

  1033 // ---------------------------------------------------------------------------

  1034 // CSwtLabel::DrawSeparator

  1035 // ---------------------------------------------------------------------------

  1036 //

  1037 void CSwtLabel::DrawSeparator(CWindowGc& aGc) const

  1038 {

  1039     aGc.SetBrushStyle(CGraphicsContext::ENullBrush);

  1040 

  1041     if (iSeparatorHead && iSeparatorHeadMask)

  1042     {

  1043         aGc.BitBltMasked(iSeparatorHeadRect.iTl, iSeparatorHead,

  1044                          iSeparatorHeadRect.Size(), iSeparatorHeadMask, ETrue);

  1045     }

  1046     else if (iSeparatorHead)

  1047     {

  1048         aGc.BitBlt(iSeparatorHeadRect.iTl, iSeparatorHead, iSeparatorHeadRect.Size());

  1049     }

  1050 

  1051     if (iSeparatorCenter && iSeparatorCenterMask)

  1052     {

  1053         aGc.BitBltMasked(iSeparatorCenterRect.iTl, iSeparatorCenter,

  1054                          iSeparatorCenterRect.Size(), iSeparatorCenterMask, ETrue);

  1055     }

  1056     else if (iSeparatorCenter)

  1057     {

  1058         aGc.BitBlt(iSeparatorCenterRect.iTl, iSeparatorCenter, iSeparatorCenterRect.Size());

  1059     }

  1060 

  1061     if (iSeparatorTail && iSeparatorTailMask)

  1062     {

  1063         aGc.BitBltMasked(iSeparatorTailRect.iTl, iSeparatorTail,

  1064                          iSeparatorTailRect.Size(), iSeparatorTailMask, ETrue);

  1065     }

  1066     else if (iSeparatorTail)

  1067     {

  1068         aGc.BitBlt(iSeparatorTailRect.iTl, iSeparatorTail, iSeparatorTailRect.Size());

  1069     }

  1070 }

  1071 

  1072 // ---------------------------------------------------------------------------

  1073 // CSwtLabel::CalcAndUpdateSeparatorRect

  1074 // ---------------------------------------------------------------------------

  1075 //

  1076 TRect CSwtLabel::CalcAndUpdateSeparatorRect()

  1077 {

  1078     TRect rect(Rect());

  1079 

  1080     TRect separatorRect;

  1081     TAknLayoutRect layoutRect;

  1082     if (iStyle & KSwtStyleVertical)

  1083     {

  1084         layoutRect = CSwtLafFacade::GetLayoutRect(CSwtLafFacade::ESeparatorVerticalPane, rect, 0);

  1085         separatorRect =  layoutRect.Rect();

  1086         if (iDashedLineSeparatorInUse)

  1087         {

  1088             separatorRect.SetWidth(iSeparatorThickness);

  1089         }

  1090         // adjust seperator's width according to the width of the parent

  1091         if (separatorRect.Width() > rect.Width())

  1092         {

  1093             separatorRect.iTl.iX = rect.iTl.iX;

  1094             separatorRect.iBr.iX = rect.iBr.iX;

  1095         }

  1096 

  1097         // move to center

  1098         TInt xPos = rect.iTl.iX + Max(0, (rect.Width() - separatorRect.Width()) / 2);

  1099         separatorRect.SetRect(TPoint(xPos, separatorRect.iTl.iY), separatorRect.Size());

  1100 

  1101         if (iDashedLineSeparatorInUse)

  1102         {

  1103             iSeparatorCenterRect = separatorRect;

  1104         }

  1105         else

  1106         {

  1107             layoutRect = CSwtLafFacade::GetLayoutRect(CSwtLafFacade::ESeparatorVerticalPaneG1, separatorRect, 0);

  1108             iSeparatorHeadRect = layoutRect.Rect();

  1109             layoutRect = CSwtLafFacade::GetLayoutRect(CSwtLafFacade::ESeparatorVerticalPaneG2, separatorRect, 0);

  1110             iSeparatorCenterRect = layoutRect.Rect();

  1111             layoutRect = CSwtLafFacade::GetLayoutRect(CSwtLafFacade::ESeparatorVerticalPaneG3, separatorRect, 0);

  1112             iSeparatorTailRect = layoutRect.Rect();

  1113 

  1114             // adjust seperator's height according to the height of the parent

  1115             if ((iSeparatorHeadRect.Height()

  1116                     + iSeparatorTailRect.Height()) > separatorRect.Height())

  1117             {

  1118                 iSeparatorHeadRect = separatorRect;

  1119                 iSeparatorHeadRect.iBr.iY  = separatorRect.Center().iY;

  1120                 iSeparatorTailRect = separatorRect;

  1121                 iSeparatorTailRect.iTl.iY  = iSeparatorHeadRect.iBr.iY;

  1122             }

  1123         }

  1124 

  1125     }

  1126     else

  1127     {

  1128         layoutRect = CSwtLafFacade::GetLayoutRect(CSwtLafFacade::ESeparatorHorizontalPane, rect, 0);

  1129         separatorRect =  layoutRect.Rect();

  1130         if (iDashedLineSeparatorInUse)

  1131         {

  1132             separatorRect.SetHeight(iSeparatorThickness);

  1133         }

  1134         // adjust seperator's height according to height of the parent

  1135         if (separatorRect.Height() > rect.Height())