--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/javauis/eswt_akn/org.eclipse.ercp.swt.s60/native/src/swtcaptionedcontrol.cpp Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,1987 @@
+/*******************************************************************************
+ * Copyright (c) 2005, 2010 Nokia Corporation and/or its subsidiary(-ies).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Nokia Corporation - S60 implementation
+ *******************************************************************************/
+
+
+#include <eikimage.h>
+#include <AknsDrawUtils.h>
+#include <AknUtils.h>
+#include <swtlaffacade.h>
+#include "swtcontrolhelper.h"
+#include "swtfont.h"
+#include "swtcomposite.h"
+#include "swtcaptionedcontrol.h"
+
+
+// Default preferred size for an empty CaptionedControl
+const TInt KSwtCaptionedCtrlDefPrefSize = 50;
+const TInt KSwtDefaultCaptionMargin = 3;
+const TInt KSwtDefaultTrailMargin = 3;
+
+// ======== MEMBER FUNCTIONS ========
+
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::CControlProxy::CountComponentControls
+// ---------------------------------------------------------------------------
+//
+TInt CSwtCaptionedControl::CControlProxy::CountComponentControls() const
+{
+ return iChild ? 1 : 0;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::CControlProxy::ComponentControl
+// ---------------------------------------------------------------------------
+//
+CCoeControl* CSwtCaptionedControl::CControlProxy::ComponentControl(
+ TInt /*aIndex*/) const
+{
+ ASSERT(iChild);
+ return &(iChild->CoeControl());
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::CControlProxy::MinimumSize
+// ---------------------------------------------------------------------------
+//
+TSize CSwtCaptionedControl::CControlProxy::MinimumSize()
+{
+ TSize size(0, 0);
+ if (iChild)
+ {
+ // Use the computed size from the Java side. This way cover also
+ // those components that compute their size on the Java side.
+ size = iPreferredSize;
+ }
+ return size;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::CControlProxy::PositionChanged
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::CControlProxy::PositionChanged()
+{
+ iPrevPos = iPosition;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::CControlProxy::SizeChanged
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::CControlProxy::SizeChanged()
+{
+ if (iPosition != iPrevPos)
+ {
+ if (iChild)
+ {
+ iChild->CoeControl().SetPosition(iPosition);
+ }
+ iPrevPos = iPosition;
+ }
+
+ if (iChild)
+ {
+ iChild->CoeControl().SetSize(iSize);
+ }
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::NewL
+// ---------------------------------------------------------------------------
+//
+CSwtCaptionedControl* CSwtCaptionedControl::NewL(MSwtDisplay& aDisplay,
+ TSwtPeer aPeer, MSwtComposite& aParent, TInt aStyle)
+{
+ CSwtCaptionedControl* self = new(ELeave) CSwtCaptionedControl(aDisplay,
+ aPeer, aParent, aStyle);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ self->InitControlBaseL();
+ CleanupStack::Pop(self);
+ return self;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::CSwtCaptionedControl
+// ---------------------------------------------------------------------------
+//
+CSwtCaptionedControl::CSwtCaptionedControl(MSwtDisplay& aDisplay,
+ TSwtPeer aPeer, MSwtComposite& aParent, TInt aStyle)
+ : ASwtControlBase(aDisplay, aPeer, &aParent, aStyle)
+{
+ CCoeControl& coeParent = aParent.Control()->CoeControl();
+ CEikCaptionedControl::MakeVisible(coeParent.IsVisible());
+ CEikCaptionedControl::SetDimmed(coeParent.IsDimmed());
+ SetComponentsToInheritVisibility(ETrue);
+ SetFocusing(ETrue);
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::~CSwtCaptionedControl
+// ---------------------------------------------------------------------------
+//
+CSwtCaptionedControl::~CSwtCaptionedControl()
+{
+ // Own
+ ASSERT(iChildren.Count() == 0);
+ iChildren.Close();
+ if (iDefaultFont)
+ {
+ iDefaultFont->RemoveRef();
+ iDefaultFont = NULL;
+ }
+
+ // Not Own
+ iForegroundColor = NULL;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::ConstructL
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::ConstructL()
+{
+ SetContainerWindowL(GetParent()->Control()->CoeControl());
+
+ // Workaround - We need to set that now, so as the
+ // ConstructExtensionL is called inside the CaptionnedControl.
+ SetEditableL(EFalse);
+
+ // Retrieve default font
+ iDefaultFont = CSwtFont::NewL(iDisplay.Device(), iDisplay.Device().GetSystemFont()->Font());
+
+ iControl = new(ELeave) CControlProxy;
+ iControl->SetComponentsToInheritVisibility(ETrue);
+ iControl->SetContainerWindowL(*this); // Absolutely necessary
+ iControl->SetMopParent(this); // Absolutely necessary
+ iControl->SetFocusing(ETrue);
+ iControl->ActivateL();
+
+ SetDefaultForegroundL();
+ SetBackground(this); // Back will be drawn by ASwtControlBase::Draw
+ ActivateL();
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::Child
+// ---------------------------------------------------------------------------
+//
+inline const MSwtControl* CSwtCaptionedControl::Child() const
+{
+ ASSERT(iControl);
+ return static_cast<CControlProxy*>(iControl)->iChild;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::Child
+// ---------------------------------------------------------------------------
+//
+inline MSwtControl* CSwtCaptionedControl::Child()
+{
+ ASSERT(iControl);
+ return static_cast<CControlProxy*>(iControl)->iChild;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::CoeChild
+// ---------------------------------------------------------------------------
+//
+inline const CCoeControl* CSwtCaptionedControl::CoeChild() const
+{
+ const MSwtControl* child = Child();
+ return (child) ? &child->CoeControl() : NULL;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::CoeChild
+// ---------------------------------------------------------------------------
+//
+inline CCoeControl* CSwtCaptionedControl::CoeChild()
+{
+ MSwtControl* child = Child();
+ return (child) ? &child->CoeControl() : NULL;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::SetChild
+// ---------------------------------------------------------------------------
+//
+inline void CSwtCaptionedControl::SetChild(MSwtControl* aChild)
+{
+ ASSERT(iControl);
+ static_cast<CControlProxy*>(iControl)->iChild = aChild;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::SetEmphasis
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::SetEmphasis(TDrawNow /*aDrawNow*/)
+{
+ // If foreground color has not been set then update according to focus
+ if (!iForegroundColor)
+ {
+ TRAP_IGNORE(SetDefaultForegroundL());
+ }
+ Redraw();
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::ComputeInnerRect
+// ---------------------------------------------------------------------------
+//
+TRect CSwtCaptionedControl::ComputeInnerRect(const TRect& aRect) const
+{
+ TRect borderInnerRect(aRect);
+ TRect innerRect(aRect);
+
+ // Compute rect inside borders
+ TInt borderWidth = GetBorderWidth();
+ borderInnerRect.Shrink(borderWidth, borderWidth);
+
+ // Compute rect inside frame
+ innerRect.iTl = CSwtLafFacade::GetLayoutRect(
+ CSwtLafFacade::EInputFieldSkinPlacingGeneralLine2, aRect).Rect().iBr;
+ innerRect.iBr = CSwtLafFacade::GetLayoutRect(
+ CSwtLafFacade::EInputFieldSkinPlacingGeneralLine5, aRect).Rect().iTl;
+
+ // Merge computed rects
+ if (innerRect.iTl.iX < borderInnerRect.iTl.iX)
+ {
+ innerRect.iTl.iX = borderInnerRect.iTl.iX;
+ }
+ if (innerRect.iTl.iY < borderInnerRect.iTl.iY)
+ {
+ innerRect.iTl.iY = borderInnerRect.iTl.iY;
+ }
+ if (innerRect.iBr.iX > borderInnerRect.iBr.iX)
+ {
+ innerRect.iBr.iX = borderInnerRect.iBr.iX;
+ }
+ if (innerRect.iBr.iY > borderInnerRect.iBr.iY)
+ {
+ innerRect.iBr.iY = borderInnerRect.iBr.iY;
+ }
+
+ innerRect.Normalize();
+
+ return innerRect;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::DoSetSize
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::DoSetSize(const TSize& aSize)
+{
+ // Compute new inner rect
+ TRect newRect(Rect());
+ newRect.SetSize(aSize);
+ iInnerRect = ComputeInnerRect(newRect);
+
+ // Give iInnerRect to CEikCaptionedControl SetSize
+ TPoint realPosition(iPosition);
+ iPosition = iInnerRect.iTl;
+
+ // Save aSize before calling SetSize because it will modify iSize and aSize
+ // may be a reference to iSize. In this case, aSize would be modified
+ // whereas we want to use it as parameter of SetSizeWithoutNotification.
+ TSize realSizeToSet(aSize);
+ CEikCaptionedControl::SetSize(iInnerRect.Size());
+
+ // Set our rect to its real value
+ iPosition = realPosition;
+ CEikCaptionedControl::SetSizeWithoutNotification(realSizeToSet);
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::SetDefaultForegroundL
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::SetDefaultForegroundL()
+{
+ TRgb defaultColor;
+ TAknsQsnTextColorsIndex colorIndex;
+ if (iDisplay.UiUtils().NaviKeyInput() && IsFocusedOrChildIsFocused())
+ {
+ colorIndex = EAknsCIQsnTextColorsCG10;
+ }
+ else
+ {
+ colorIndex = EAknsCIQsnTextColorsCG8;
+ }
+ if (AknsUtils::GetCachedColor(AknsUtils::SkinInstance(), defaultColor,
+ KAknsIIDQsnTextColors, colorIndex) == KErrNone)
+ {
+ OverrideColorL(EColorLabelText, defaultColor);
+ }
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::GetRecursiveChildrenL
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::GetRecursiveChildrenL(RSwtControlArray& aAllChildren,
+ MSwtComposite& aParent)
+{
+ const RSwtControlArray* children = aParent.Children();
+ if (children)
+ {
+ for (TInt i = 0; i < children->Count(); ++i)
+ {
+ MSwtControl* child = (*children)[i];
+ ASSERT(child);
+ User::LeaveIfError(aAllChildren.Append(child));
+ MSwtComposite* composite = child->CompositeInterface();
+ if (composite)
+ {
+ GetRecursiveChildrenL(aAllChildren, *composite);
+ }
+ }
+ }
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::RealFontHeight
+// ---------------------------------------------------------------------------
+//
+TBool CSwtCaptionedControl::RealFontHeight(TInt& aHeight) const
+{
+ const MSwtFont* swtFont = GetFont();
+ ASSERT(swtFont);
+ const CFont& font = swtFont->Font();
+ const CFbsFont* fbsFont = NULL;
+ if (font.TypeUid() == KCFbsFontUid)
+ {
+ fbsFont = static_cast<const CFbsFont*>(&font);
+ }
+
+ if (fbsFont && fbsFont->IsOpenFont())
+ {
+ // font.AscentInPixels() and font.DescentInPixels() ( used by iCaption
+ // and iTrailer ( CEikLabel ) ) don't include the height of accents etc.
+ // Use the maximum possible ascent/decent instead.
+ aHeight = font.FontMaxHeight();
+ return ETrue;
+ }
+ else
+ {
+ return EFalse;
+ }
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::DefaultLeftMargin
+// ---------------------------------------------------------------------------
+//
+TInt CSwtCaptionedControl::DefaultLeftMargin() const
+{
+#if 0
+ TRect dummyRect(0, 0, KSwtCaptionedCtrlDefPrefSize,
+ KSwtCaptionedCtrlDefPrefSize);
+ return CSwtLafFacade::GetLayoutText(
+ CSwtLafFacade::EFormDataWideGraphicFieldTextsLine2, dummyRect).
+ TextRect().iTl.iX;
+#endif
+ return 0;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::CountComponentControls
+// From CCoeControl
+// ---------------------------------------------------------------------------
+//
+TInt CSwtCaptionedControl::CountComponentControls() const
+{
+ // We don't want iControl to be counted as a component control
+ CCoeControl* controls[] = { iBitmap, iCaption, iTrailer };
+ TInt count = 0;
+ TInt nrOfCtrls = sizeof(controls) / sizeof(CCoeControl*);
+ for (TUint i = 0; i < nrOfCtrls; i++)
+ {
+ if (controls[i])
+ {
+ count++;
+ }
+ }
+ return count;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::ComponentControl
+// From CCoeControl
+// ---------------------------------------------------------------------------
+//
+CCoeControl* CSwtCaptionedControl::ComponentControl(TInt aIndex) const
+{
+ // We don't want iControl to be counted as a component control
+ CCoeControl* controls[] = { iBitmap, iCaption, iTrailer };
+ TInt nrOfCtrls = sizeof(controls) / sizeof(CCoeControl*);
+ for (TUint i = 0; i < nrOfCtrls; i++)
+ {
+ if (controls[i] && aIndex-- == 0)
+ {
+ return controls[i];
+ }
+ }
+ return NULL;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::MakeVisible
+// From CCoeControl
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::MakeVisible(TBool aVisible)
+{
+ CEikCaptionedControl::MakeVisible(aVisible);
+ MSwtControl* child = Child();
+
+ // This prevents making visible controls invisible on their own
+ if (child && !(child->Flags() & EFlagInvisible))
+ {
+ child->CoeControl().MakeVisible(aVisible);
+ }
+
+ FocusabilityChanged();
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::SetDimmed
+// From CCoeControl
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::SetDimmed(TBool aDimmed)
+{
+ CEikCaptionedControl::SetDimmed(aDimmed);
+ MSwtControl* child = Child();
+
+ // This prevents undimming controls dimmed on their own
+ if (child && !(child->Flags() & EFlagDisabled))
+ {
+ child->CoeControl().SetDimmed(aDimmed);
+ }
+
+ if (iCaption)
+ {
+ iCaption->SetDimmed(aDimmed);
+ }
+ if (iTrailer)
+ {
+ iTrailer->SetDimmed(aDimmed);
+ }
+
+ FocusabilityChanged();
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::OfferKeyEventL
+// From CCoeControl
+// ---------------------------------------------------------------------------
+//
+TKeyResponse CSwtCaptionedControl::OfferKeyEventL(const TKeyEvent& aEvent,
+ TEventCode aType)
+{
+ return HandleKeyL(aEvent, aType, ETrue);
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::MinimumSize
+// From CCoeControl
+// ---------------------------------------------------------------------------
+//
+TSize CSwtCaptionedControl::MinimumSize()
+{
+ // Default left margin for caption and control
+ TInt leftMargin = DefaultLeftMargin();
+
+ // First line
+ TSize firstLineSize(0, 0);
+
+ // Bitmap
+ if (iBitmap)
+ {
+ TSize bitmapSize(iBitmap->MinimumSize());
+ firstLineSize = bitmapSize;
+ firstLineSize.iHeight += KSwtDefaultCaptionMargin;
+ }
+
+ // Left margin
+ if (firstLineSize.iWidth < leftMargin)
+ {
+ firstLineSize.iWidth = leftMargin;
+ }
+
+ // Caption
+ if (iCaption && !(iCaption->Text()->Length()))
+ {
+ delete iCaption;
+ iCaption = NULL;
+ }
+
+ if (iCaption)
+ {
+ TSize capSize(iCaption->MinimumSize());
+
+ // Fix is needed for minimum height in case used font is an open font
+ TInt captionRealMinHeight;
+ if (RealFontHeight(captionRealMinHeight))
+ {
+ if (capSize.iHeight < captionRealMinHeight)
+ {
+ capSize.iHeight = captionRealMinHeight;
+ }
+ }
+ firstLineSize.iWidth += capSize.iWidth;
+ if (capSize.iHeight + KSwtDefaultCaptionMargin > firstLineSize.iHeight)
+ {
+ firstLineSize.iHeight = capSize.iHeight + KSwtDefaultCaptionMargin;
+ }
+ }
+
+ // Second line
+ // Control
+ TSize secondLineSize(iControl->MinimumSize());
+
+ // Left margin
+ secondLineSize.iWidth += leftMargin;
+
+ // Trailing
+ if (iTrailer)
+ {
+ TSize trailSize(iTrailer->MinimumSize());
+
+ // Fix is needed for minimum height in case used font is an open font
+ TInt captionRealMinHeight;
+ if (RealFontHeight(captionRealMinHeight))
+ {
+ if (trailSize.iHeight < captionRealMinHeight)
+ {
+ trailSize.iHeight = captionRealMinHeight;
+ }
+ }
+ secondLineSize.iWidth += trailSize.iWidth;
+ secondLineSize.iWidth += KSwtDefaultTrailMargin;
+ if (trailSize.iHeight > secondLineSize.iHeight)
+ {
+ secondLineSize.iHeight = trailSize.iHeight;
+ }
+ }
+
+ // Total size
+ TSize size(firstLineSize);
+ if (secondLineSize.iWidth > size.iWidth)
+ {
+ size.iWidth = secondLineSize.iWidth;
+ }
+ size.iHeight += secondLineSize.iHeight;
+
+ return size;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::HandleResourceChange
+// From CCoeControl
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::HandleResourceChange(TInt aType)
+{
+ TRAP_IGNORE(SwtHandleResourceChangeL(aType));
+}
+
+#ifdef RD_SCALABLE_UI_V2
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::HandlePointerEventL
+// From CCoeControl
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::HandlePointerEventL(const TPointerEvent& aPointerEvent)
+{
+ MSwtControl* child = Child();
+ if (child)
+ {
+ TPointerEvent pointerEvent(aPointerEvent);
+ TRect childRect(child->CoeControl().Rect());
+ TBool childRectContainsPoint(childRect.Contains(pointerEvent.iPosition));
+
+#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK
+ if (!IsFocusedOrChildIsFocused())
+ {
+ //feedback on first tap
+ child->DoControlSpecificFeedback(ETrue, childRectContainsPoint, aPointerEvent);
+ }
+ else
+ {
+ //feedback on second tap
+ child->DoControlSpecificFeedback(EFalse, childRectContainsPoint, aPointerEvent);
+ }
+#endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK
+
+ // It is important here to check first if the child is focusable.
+ // If the child is a Composite that is not focusable (has focusable children),
+ // the child will pass the focus to its children in HandlePointerEventL.
+ // So this check here is needed to avoid calling SetSwtFocus twice, which
+ // can lead in some situations to Texts opening VKB when gaining focus.
+ if (child->IsFocusable())
+ {
+ child->SetSwtFocus(KSwtFocusByPointer);
+ }
+
+ if (!childRectContainsPoint)
+ {
+ childRect.Shrink(2, 2); // well inside the edges
+ if (pointerEvent.iPosition.iX < childRect.iTl.iX)
+ {
+ pointerEvent.iPosition.iX = childRect.iTl.iX;
+ }
+ if (pointerEvent.iPosition.iY < childRect.iTl.iY)
+ {
+ pointerEvent.iPosition.iY = childRect.iTl.iY;
+ }
+ if (pointerEvent.iPosition.iX > childRect.iBr.iX)
+ {
+ pointerEvent.iPosition.iX = childRect.iBr.iX;
+ }
+ if (pointerEvent.iPosition.iY > childRect.iBr.iY)
+ {
+ pointerEvent.iPosition.iY = childRect.iBr.iY;
+ }
+ }
+
+ if (aPointerEvent.iType == TPointerEvent::EButton1Up)
+ iPointerGrabbingControl = NULL;
+ else
+ iPointerGrabbingControl = child;
+
+ child->CoeControl().HandlePointerEventL(pointerEvent);
+
+ // It is possible that the pointer position did not intersect the children.
+ if (!IsFocusedOrChildIsFocused())
+ {
+ SetSwtFocus(KSwtFocusByPointer);
+ }
+ }
+ else
+ {
+ iPointerGrabbingControl = NULL;
+ ASwtControlBase::SetSwtFocus(KSwtFocusByPointer);
+ }
+}
+#endif // RD_SCALABLE_UI_V2
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::SwtHandleResourceChangeL
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::SwtHandleResourceChangeL(TInt aType)
+{
+ if (aType == KAknsMessageSkinChange || aType == KEikDynamicLayoutVariantSwitch)
+ {
+ if (!iForegroundColor)
+ {
+ SetDefaultForegroundL();
+ }
+ }
+
+ CEikCaptionedControl::HandleResourceChange(aType);
+
+ CCoeControl* coeChild = CoeChild();
+ if (coeChild)
+ {
+ coeChild->HandleResourceChange(aType);
+ }
+
+ if (aType == KAknsMessageSkinChange || aType == KEikDynamicLayoutVariantSwitch)
+ {
+ if (iDefaultFont)
+ {
+ iDefaultFont->RemoveRef();
+ iDefaultFont = NULL;
+ }
+
+ const CFont* font = &iDisplay.Device().GetSystemFont()->Font();
+ iDefaultFont = CSwtFont::NewL(iDisplay.Device(), *font);
+
+ // If captionedcontrol uses default font, then update components
+ // fonts because of resource change
+ if (!iFont)
+ {
+ if (iCaption)
+ {
+ iCaption->SetFont(&iDefaultFont->Font());
+ iCaption->SetAllMarginsTo(0);
+ }
+ if (iTrailer)
+ {
+ iTrailer->SetFont(&iDefaultFont->Font());
+ iTrailer->SetAllMarginsTo(0);
+ }
+
+ TInt captionRealFontHeight;
+ if (RealFontHeight(captionRealFontHeight))
+ {
+ if (iCaption)
+ {
+ iCaption->iMargin.iTop = captionRealFontHeight
+ - font->HeightInPixels();
+ }
+ if (iTrailer)
+ {
+ iTrailer->iMargin.iTop = captionRealFontHeight
+ - font->HeightInPixels();
+ }
+ }
+ }
+ }
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::SetForegroundL
+// From CCoeControl
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::SetForegroundL(const MSwtColor* aColor)
+{
+ ASwtControlBase::DoSetForegroundL(aColor);
+ SetColorL(EColorLabelText, aColor);
+ if (!aColor)
+ {
+ SetDefaultForegroundL();
+ }
+ iForegroundColor = aColor;
+ Redraw();
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::FocusChanged
+// From CCoeControl
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::FocusChanged(TDrawNow aDrawNow)
+{
+ HandleFocusChanged(aDrawNow);
+ SetEmphasis(aDrawNow);
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::SizeChanged
+// From CCoeControl
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::SizeChanged()
+{
+ TRect rect(Rect());
+
+ // Default left margin for caption and control
+ TInt leftMargin = DefaultLeftMargin();
+
+ // First line
+ TInt firstLineHeight = 0;
+ // Initial position for caption after bitmap layout or
+ // gap between border and caption if there is no bitmap
+ TInt captionLeftMargin = leftMargin;
+
+ // Bitmap
+ if (iBitmap)
+ {
+ TSize bitmapSize(iBitmap->MinimumSize());
+ if (bitmapSize.iWidth > rect.Width())
+ {
+ bitmapSize.iWidth = rect.Width();
+ }
+
+ if (bitmapSize.iHeight > rect.Height() - KSwtDefaultCaptionMargin)
+ {
+ bitmapSize.iHeight = rect.Height() - KSwtDefaultCaptionMargin;
+ }
+
+ if (AknLayoutUtils::LayoutMirrored())
+ {
+ TPoint bitmapPos(0, 0);
+ // in the mirrored layout bitmap is on right side
+ bitmapPos.iX = rect.iTl.iX + rect.Width() - bitmapSize.iWidth;
+ bitmapPos.iY = rect.iTl.iY;
+
+ iBitmap->SetExtent(bitmapPos, bitmapSize);
+ }
+ else
+ {
+ iBitmap->SetExtent(rect.iTl, bitmapSize);
+ }
+
+ firstLineHeight = bitmapSize.iHeight;
+ if (captionLeftMargin < bitmapSize.iWidth)
+ {
+ captionLeftMargin = bitmapSize.iWidth;
+ }
+ }
+
+ // Caption
+ if (iCaption)
+ {
+ if (captionLeftMargin > rect.Width())
+ {
+ captionLeftMargin = rect.Width();
+ }
+ TInt captionPosX = rect.iTl.iX + captionLeftMargin;
+ TInt availableWidth = rect.iBr.iX - captionPosX;
+ TSize capSize(iCaption->MinimumSize());
+
+ if (capSize.iHeight > rect.Height() - KSwtDefaultCaptionMargin)
+ {
+ capSize.iHeight = rect.Height() - KSwtDefaultCaptionMargin;
+ }
+
+ if (capSize.iHeight > firstLineHeight)
+ {
+ firstLineHeight = capSize.iHeight;
+ }
+
+ if (AknLayoutUtils::LayoutMirrored())
+ {
+ // in mirrored layout caption is on right side
+ iCaption->SetExtent(rect.iTl, TSize(availableWidth, firstLineHeight));
+ }
+ else
+ {
+ iCaption->SetExtent(TPoint(captionPosX, rect.iTl.iY),
+ TSize(availableWidth, firstLineHeight));
+ }
+ }
+ //Increase size of first line by margin
+ if (iBitmap || iCaption)
+ {
+ firstLineHeight += KSwtDefaultCaptionMargin;
+ }
+
+ // Second Line
+ rect.iTl.iY += firstLineHeight;
+
+ // Trailing
+ if (iTrailer)
+ {
+ TInt availableWidth = Max(0, rect.Width() - iControl->MinimumSize().iWidth -
+ leftMargin - KSwtDefaultTrailMargin);
+ TSize trailSize(iTrailer->MinimumSize());
+ if (trailSize.iWidth > availableWidth)
+ {
+ trailSize.iWidth = availableWidth;
+ }
+ if (trailSize.iHeight > rect.Height())
+ {
+ trailSize.iHeight = rect.Height();
+ }
+
+ if (AknLayoutUtils::LayoutMirrored())
+ {
+ // in mirrored layout trailing text is on left side
+ iTrailer->SetExtent(TPoint(rect.iTl.iX, rect.iTl.iY), trailSize);
+ rect.iTl.iX += trailSize.iWidth;
+ rect.iTl.iX += KSwtDefaultTrailMargin;
+ rect.iBr.iX -= leftMargin;
+ }
+ else
+ {
+ rect.iTl.iX += leftMargin;
+ TInt trailPosX = rect.iBr.iX - trailSize.iWidth;
+ iTrailer->SetExtent(TPoint(trailPosX, rect.iTl.iY), trailSize);
+ rect.iBr.iX = trailPosX;
+ rect.iBr.iX = Max(0, rect.iBr.iX - KSwtDefaultTrailMargin);
+ }
+ }
+ else
+ {
+ if (AknLayoutUtils::LayoutMirrored())
+ {
+ // in mirrored layout margin is on rightside
+ rect.iBr.iX -= leftMargin;
+ }
+ else
+ {
+ rect.iTl.iX += leftMargin;
+ }
+ }
+
+ rect.Normalize();
+
+ // Control
+ iControl->SetRect(rect);
+
+ // Crop
+ if (iCaption)
+ {
+ TRAP_IGNORE(iCaption->SetTextL(*iCaptionText));
+ iCaption->CropText();
+ }
+
+ HandleSizeChanged();
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::PositionChanged
+// From CCoeControl
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::PositionChanged()
+{
+ const TPoint oldPos(iPrevPos);
+ const TRect newRect(Rect());
+
+ // Replace old position for future use
+ iPrevPos = newRect.iTl;
+
+ // Refresh inner rect
+ iInnerRect = ComputeInnerRect(newRect);
+
+ // Forward to base
+ CEikCaptionedControl::PositionChanged();
+
+ // Forward new position to child
+ if (newRect.iTl != oldPos)
+ {
+ iControl->SetPosition(iControl->Position() + newRect.iTl - oldPos);
+ }
+
+ // The moved event is sent from ASwtControlBase::SetLocation
+ HandlePositionChanged();
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::CoeControl
+// From MSwtControl
+// ---------------------------------------------------------------------------
+//
+CCoeControl& CSwtCaptionedControl::CoeControl()
+{
+ return *this;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::CoeControl
+// From MSwtControl
+// ---------------------------------------------------------------------------
+//
+const CCoeControl& CSwtCaptionedControl::CoeControl() const
+{
+ return *this;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::IsFocusable
+// From MSwtControl
+// ---------------------------------------------------------------------------
+//
+TBool CSwtCaptionedControl::IsFocusable(TInt aReason /*=KSwtFocusByApi*/) const
+{
+ if (aReason == KSwtFocusByForce)
+ {
+ return ASwtControlBase::IsFocusable(KSwtFocusByForce);
+ }
+ else
+ {
+ // The captioned control itself is focusable if there is no focusable child
+ return ASwtControlBase::IsFocusable()
+ && (CountFocusableChildren(1, NULL, EFalse) == 0);
+ }
+}
+
+// ---------------------------------------------------------------------------
+// CSwtButton::FocusBackgroundPolicy
+// From MSwtControl
+// ---------------------------------------------------------------------------
+//
+TInt CSwtCaptionedControl::FocusBackgroundPolicy() const
+{
+ return ECaptionedCtrlFocusBackground;
+};
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::ProcessKeyEventL
+// From MSwtControl
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::ProcessKeyEventL(const TKeyEvent& aKeyEvent,
+ TEventCode aType)
+{
+ MSwtControl* child = Child();
+ if (child)
+ {
+ CEikCaptionedControl::OfferKeyEventL(aKeyEvent, aType);
+ }
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::SetSwtFocus
+// From MSwtControl
+// ---------------------------------------------------------------------------
+//
+TBool CSwtCaptionedControl::SetSwtFocus(TInt aReason /*=KSwtFocusByApi*/)
+{
+ MSwtControl* child = Child();
+
+ if ((aReason != KSwtFocusByForce) && child && child->SetSwtFocus(aReason))
+ {
+ return ETrue;
+ }
+
+ return ASwtControlBase::SetSwtFocus(aReason);
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::ClientRect
+// From MSwtControl
+// ---------------------------------------------------------------------------
+//
+TRect CSwtCaptionedControl::ClientRect() const
+{
+ TRect r(ComputeInnerRect(Rect()));
+
+ TInt firstLineHeight = 0;
+ if (iBitmap)
+ {
+ firstLineHeight = iBitmap->Size().iHeight;
+ }
+ if (iCaption)
+ {
+ TInt captionHeight = iCaption->Size().iHeight;
+ if (captionHeight > firstLineHeight)
+ {
+ firstLineHeight = captionHeight;
+ }
+ }
+
+ r.iTl.iY += firstLineHeight;
+ r.iTl.iY += KSwtDefaultCaptionMargin;
+
+ if (iTrailer)
+ {
+ if (AknLayoutUtils::LayoutMirrored())
+ {
+ r.iTl.iX += iTrailer->Size().iWidth;
+ r.iTl.iX += KSwtDefaultTrailMargin;
+ }
+ else
+ {
+ r.iBr.iX -= iTrailer->Size().iWidth;
+ r.iBr.iX = Max(0, r.iBr.iX - KSwtDefaultTrailMargin);
+ }
+ }
+
+ TInt leftMargin = DefaultLeftMargin();
+
+ if (AknLayoutUtils::LayoutMirrored())
+ {
+ r.iBr.iX -= leftMargin;
+ }
+ else
+ {
+ r.iTl.iX += leftMargin;
+ }
+
+
+ if (r.iBr.iX < r.iTl.iX)
+ {
+ r.iBr.iX = r.iTl.iX;
+ }
+ if (r.iTl.iY > r.iBr.iY)
+ {
+ r.iTl.iY = r.iBr.iY;
+ }
+
+ return r;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::ComputeSizeL
+// From MSwtControl
+// ---------------------------------------------------------------------------
+//
+TSize CSwtCaptionedControl::ComputeSizeL(TInt aWHint, TInt aHHint)
+{
+ ResetMinimumSizes();
+
+ // Save caption and trailer size as they may be modified when calling
+ // MinimumSize() because CEikLabel::MinimumSize is used and this does set
+ // its iSize
+ TSize capSize(TSize::EUninitialized);
+ TSize trailSize(TSize::EUninitialized);
+ if (iCaption)
+ {
+ capSize = iCaption->Size();
+ }
+ if (iTrailer)
+ {
+ trailSize = iTrailer->Size();
+ }
+
+ // Get CEikCaptionedControl preferred size
+ TSize size(MinimumSize());
+
+ // Restore caption and trailer size if needed
+ if ((iCaption) && (iCaption->Size() != capSize))
+ {
+ iCaption->SetSize(capSize);
+ }
+ if ((iTrailer) && (iTrailer->Size() != trailSize))
+ {
+ iTrailer->SetSize(trailSize);
+ }
+
+ // Add frame and border size
+ TRect outerRect(0, 0, KSwtCaptionedCtrlDefPrefSize,
+ KSwtCaptionedCtrlDefPrefSize);
+ TRect innerRect = ComputeInnerRect(outerRect);
+ size += outerRect.Size() - innerRect.Size();
+
+ if (aWHint != KSwtDefault)
+ {
+ size.iWidth = aWHint;
+ }
+ if (aHHint != KSwtDefault)
+ {
+ size.iHeight = aHHint;
+ }
+
+ return size;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::SetWidgetSize
+// From MSwtControl
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::SetWidgetSize(const TSize& aNewSize)
+{
+ TRect oldRect(Rect());
+ TRect newRect(Position(), aNewSize);
+
+ // Do not invalidate outside parent's visible client area.
+ if (iParent)
+ {
+ TRect parentVisibleRect(iParent->Control()->CoeControl().Rect());
+ oldRect.Intersection(parentVisibleRect);
+ newRect.Intersection(parentVisibleRect);
+ }
+
+ // Invalidate uncovered regions.
+ RRegion invalidRegion;
+ invalidRegion.Clear();
+ invalidRegion.AddRect(oldRect);
+ invalidRegion.SubRect(newRect);
+ if (!invalidRegion.IsEmpty())
+ {
+ ASSERT(invalidRegion.Count() <= 2);
+ for (TInt i = 0; i < invalidRegion.Count(); i++)
+ {
+ // Invalidate our old rect
+ Invalidate(invalidRegion[i]);
+ }
+ }
+ invalidRegion.Close();
+
+ DoSetSize(aNewSize);
+
+ if (!(iStyle & KSwtStyleNoRedrawResize))
+ {
+ // Invalidate our new rect
+ Redraw();
+ }
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::SetFontL
+// From MSwtControl
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::SetFontL(const MSwtFont* aFont)
+{
+ ASwtControlBase::DoSetFontL(aFont);
+
+ const MSwtFont* swtFont = GetFont();
+ ASSERT(swtFont);
+ const CFont& font = (swtFont->Font());
+
+ if (iCaption)
+ {
+ iCaption->SetFont(&font);
+ iCaption->SetAllMarginsTo(0);
+ }
+
+ if (iTrailer)
+ {
+ iTrailer->SetFont(&font);
+ iTrailer->SetAllMarginsTo(0);
+ }
+
+ TInt captionRealFontHeight;
+ if (RealFontHeight(captionRealFontHeight))
+ {
+ if (iCaption)
+ {
+ iCaption->iMargin.iTop = captionRealFontHeight
+ - font.HeightInPixels();
+ }
+ if (iTrailer)
+ {
+ iTrailer->iMargin.iTop = captionRealFontHeight
+ - font.HeightInPixels();
+ }
+ }
+
+ // We force a call to ( private ) SizeChanged to resize the components.
+ ResetMinimumSizes();
+ SetWidgetSize(iSize);
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::SetBounds
+// From MSwtControl
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::SetBounds(const TRect& aRect)
+{
+ // Must NOT call SetExtent if we want component controls to be relocated.
+
+ TSize oldSize(Size());
+ TPoint oldLocation(GetLocation());
+ TPoint newLocation(iParent->Scrollable()->Control()->ClientRect().iTl + aRect.iTl);
+ TRect oldRect(Rect());
+ TRect newRect(newLocation, aRect.Size());
+
+ // Do not invalidate outside parent's visible client area.
+ if (iParent)
+ {
+ TRect parentVisibleRect(iParent->Control()->CoeControl().Rect());
+ oldRect.Intersection(parentVisibleRect);
+ newRect.Intersection(parentVisibleRect);
+ }
+
+ // Invalidate uncovered regions.
+ if (newRect.Intersects(oldRect))
+ {
+ RRegion invalidRegion;
+ invalidRegion.Clear();
+ invalidRegion.AddRect(oldRect);
+ invalidRegion.SubRect(newRect);
+ ASSERT(invalidRegion.Count() <= 4);
+ for (TInt i = 0; i < invalidRegion.Count(); i++)
+ {
+ Invalidate(invalidRegion[i]);
+ }
+ invalidRegion.Close();
+ }
+ else
+ {
+ Invalidate(oldRect);
+ }
+
+ // Set and invalidate new rect
+ if (oldLocation != newLocation)
+ {
+ CEikCaptionedControl::SetPosition(newLocation);
+ }
+ if (oldSize != aRect.Size())
+ {
+ DoSetSize(aRect.Size());
+ }
+ if (!(iStyle & KSwtStyleNoRedrawResize))
+ {
+ Redraw();
+ }
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::CompositeInterface
+// From MSwtControl
+// ---------------------------------------------------------------------------
+//
+MSwtComposite* CSwtCaptionedControl::CompositeInterface() const
+{
+ const MSwtComposite* composite = this;
+ return const_cast<MSwtComposite*>(composite);
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::ComputeTabListL
+// From MSwtControl
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::ComputeTabListL(RSwtControlArray& aList)
+{
+ ASwtControlBase::ComputeTabListL(aList);
+ MSwtControl* child = Child();
+ if (child)
+ {
+ child->ComputeTabListL(aList);
+ }
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::CaptionedControlInterface
+// From MSwtControl
+// ---------------------------------------------------------------------------
+//
+MSwtCaptionedControl* CSwtCaptionedControl::CaptionedControlInterface() const
+{
+ const MSwtCaptionedControl* composite = this;
+ return const_cast<MSwtCaptionedControl*>(composite);
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::UpdateDoNotDrawFlag
+// From MSwtControl
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::UpdateDoNotDrawFlag()
+{
+ ASwtControlBase::UpdateDoNotDrawFlag();
+ MSwtControl* child = Child();
+ if (child)
+ {
+ child->UpdateDoNotDrawFlag();
+ }
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::DefaultFont
+// From ASwtControlBase
+// ---------------------------------------------------------------------------
+//
+const MSwtFont& CSwtCaptionedControl::DefaultFont() const
+{
+ ASSERT(iDefaultFont);
+ return *iDefaultFont;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::Control
+// From MSwtScrollable
+// ---------------------------------------------------------------------------
+//
+MSwtControl* CSwtCaptionedControl::Control()
+{
+ return this;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::ComputeTrim
+// From MSwtScrollable
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::ComputeTrim(TRect& aRect) const
+{
+ TInt leftMargin = DefaultLeftMargin();
+ aRect.iTl.iX -= leftMargin;
+
+ if (iTrailer)
+ {
+ aRect.iBr.iX += iTrailer->Size().iWidth;
+ TInt deltaHeight = iTrailer->Size().iHeight - aRect.Height();
+ if (deltaHeight > 0)
+ {
+ aRect.iBr.iY += deltaHeight;
+ }
+ }
+
+ TSize firstLineSize(0, 0);
+ if (iBitmap)
+ {
+ firstLineSize = iBitmap->Size();
+ }
+ if (firstLineSize.iWidth < leftMargin)
+ {
+ firstLineSize.iWidth = leftMargin;
+ }
+ if (iCaption)
+ {
+ firstLineSize.iWidth += iCaption->Size().iWidth;
+ TInt captionHeight = iCaption->Size().iHeight;
+ if (captionHeight > firstLineSize.iHeight)
+ {
+ firstLineSize.iHeight = captionHeight;
+ }
+ }
+
+ aRect.iTl.iY -= firstLineSize.iHeight;
+
+ TInt deltaWidth = firstLineSize.iWidth - aRect.Width();
+ if (deltaWidth > 0)
+ {
+ aRect.iBr.iX += deltaWidth;
+ }
+
+ // Add frame and border size
+ TRect outerRect(0, 0, KSwtCaptionedCtrlDefPrefSize,
+ KSwtCaptionedCtrlDefPrefSize);
+ TRect innerRect = ComputeInnerRect(outerRect);
+ aRect.iTl -= innerRect.iTl - outerRect.iTl;
+ aRect.iBr += outerRect.iBr - innerRect.iBr;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::CreateScrollBarL
+// From MSwtScrollable
+// ---------------------------------------------------------------------------
+//
+MSwtScrollBar* CSwtCaptionedControl::CreateScrollBarL(TSwtPeer /*aPeer*/,
+ TInt /*aStyle*/)
+{
+ return NULL;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::SetVisibleScrollBar
+// From MSwtScrollable
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::SetVisibleScrollBar(TInt /*aStyle*/,
+ TBool /*aVisible*/)
+{
+ // Should never be called
+ ASSERT(EFalse);
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::ScrollBarDestroyed
+// From MSwtScrollable
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::ScrollBarDestroyed(
+ const MSwtScrollBar* /*aScrollbar*/)
+{
+ // Should never be called
+ ASSERT(EFalse);
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::Scrollable
+// From MSwtComposite
+// ---------------------------------------------------------------------------
+//
+MSwtScrollable* CSwtCaptionedControl::Scrollable()
+{
+ return this;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::RegisterChildL
+// From MSwtComposite
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::RegisterChildL(MSwtControl& aChild)
+{
+ MSwtControl* oldChild = Child();
+
+ ASSERT(oldChild != &aChild);
+ ASSERT(!aChild.CoeControl().IsFocused());
+ ASSERT(!aChild.IsShell());
+
+ MSwtShell& shell = GetShell();
+
+ // Remove previous child
+ if (oldChild)
+ {
+ UnregisterChild(*oldChild);
+ }
+
+ // Add child
+ User::LeaveIfError(iChildren.Append(&aChild));
+ SetChild(&aChild);
+
+ // Reset iPreferredSize as we have a new child
+ SetChildPreferredSize(TSize(0, 0));
+
+ // Take care of tab stopping
+ shell.ResetTabList();
+
+ // Take care of focus
+ if (iDisplay.UiUtils().GetActiveShell() == &shell)
+ {
+ MSwtControl* focusedCtrl = shell.FocusControl();
+ if ((!focusedCtrl || focusedCtrl == this) && aChild.IsFocusable())
+ {
+ aChild.CoeControl().SetFocus(ETrue);
+ }
+ }
+
+ // Set the child at our client area's origin
+ aChild.SetLocation(TPoint(0, 0));
+
+ // We force a call to ( private ) SizeChanged to resize the components.
+ ResetMinimumSizes();
+ SetWidgetSize(iSize);
+
+ aChild.CoeControl().SetMopParent(this);
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::UnregisterChild
+// From MSwtComposite
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::UnregisterChild(MSwtControl& aChild)
+{
+ // If the child to unregister is not our current child, it means it is an
+ // old child ( means another control was added to the captionedcontrol
+ // after this old child, this can be done as captionedcontrol inherits
+ // from composite ). This happens in the dispose of composite that
+ // disposes all its children. As captionedcontrol doesn't use this old
+ // child anymore in the native side, nothing has to be done.
+ if (Child() != &aChild)
+ {
+ return;
+ }
+
+ // Unregister default buttons, focus memory, etc.
+ MSwtShell& shell = GetShell();
+ if (shell.UrgentPaintControl() == &aChild)
+ {
+ shell.SetUrgentPaintControl(NULL);
+ }
+
+ MSwtDecorations* deco = shell.Decorations();
+ MSwtButton* button = aChild.ButtonInterface();
+ if (button && button == deco->OriginalDefaultButton())
+ {
+ deco->SetDefaultButton(NULL);
+ }
+ shell.CheckFocusMemory(aChild);
+
+ // Pass focus to next focusable controls
+ if (aChild.CoeControl().IsFocused())
+ {
+ MSwtControl* newFocus = NULL;
+ TRAP_IGNORE((newFocus = shell.FindTraversalTargetL(ESwtTraverseParent, aChild)));
+ if (newFocus)
+ {
+ newFocus->CoeControl().SetFocus(ETrue);
+ }
+ else
+ {
+ aChild.CoeControl().SetFocus(EFalse);
+ }
+ }
+ ASSERT(!aChild.CoeControl().IsFocused());
+
+ // Remove child
+ TInt index = iChildren.Find(&aChild);
+ ASSERT(index != KErrNotFound);
+ iChildren.Remove(index);
+ SetChild(NULL);
+ ResetMinimumSizes();
+
+ // Take care of tab stopping
+ shell.ResetTabList();
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::GetChildrenPeersL
+// From MSwtComposite
+// ---------------------------------------------------------------------------
+//
+CSwtPeerArray* CSwtCaptionedControl::GetChildrenPeersL()
+{
+ MSwtControl* child = Child();
+ if (!child)
+ {
+ return NULL;
+ }
+
+ CSwtPeerArray* array = new(ELeave) CSwtPeerArray(1);
+ CleanupStack::PushL(array);
+ array->AppendL(child->JavaPeer());
+ CleanupStack::Pop(array);
+ return array;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::Children
+// From MSwtComposite
+// ---------------------------------------------------------------------------
+//
+const RSwtControlArray* CSwtCaptionedControl::Children() const
+{
+ return &iChildren;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::ChildFocusChanged
+// From MSwtComposite
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::ChildFocusChanged(MSwtControl& aControl)
+{
+ SetEmphasis(ENoDrawNow);
+ GetParent()->ChildFocusChanged(aControl);
+}
+
+// ---------------------------------------------------------------------------
+// CSwtComposite::CountFocusableChildren
+// From MSwtComposite
+// ---------------------------------------------------------------------------
+//
+TInt CSwtCaptionedControl::CountFocusableChildren(TInt aTryBreakAfter /*= -1 */,
+ const MSwtControl* aExclude /*= NULL */,
+ TBool aVisualFocusCount /*= ETrue*/) const
+{
+ TInt res = 0;
+ const MSwtControl* ctrl = Child();
+ if (!ctrl)
+ {
+ return res;
+ }
+
+ if (ctrl->IsFocusable()
+ && ((!aVisualFocusCount) || (aVisualFocusCount && ctrl->FocusBackgroundPolicy() != ENoFocusBackground))
+ && ((!aExclude) || (aExclude && ctrl != aExclude && !ctrl->IsDescentOf(*aExclude))))
+ {
+ res++;
+ if (res >= aTryBreakAfter)
+ {
+ return res;
+ }
+ }
+
+ if (ctrl->CompositeInterface())
+ {
+ res += ctrl->CompositeInterface()->CountFocusableChildren(aTryBreakAfter - res,
+ aExclude, aVisualFocusCount);
+ }
+
+ return res;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::SetTabListL
+// From MSwtComposite
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::SetTabListL(MSwtControl** /*aControls*/,
+ TInt /*aCount*/)
+{
+ // There can be only one control, so nothing to do here
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::GetTabListL
+// From MSwtComposite
+// ---------------------------------------------------------------------------
+//
+CSwtPeerArray* CSwtCaptionedControl::GetTabListL() const
+{
+ CSwtPeerArray* array = new(ELeave) CSwtPeerArray(1);
+ CleanupStack::PushL(array);
+
+ const MSwtControl* child = Child();
+ if (child && child->IsFocusable())
+ {
+ array->AppendL(child->JavaPeer());
+ }
+
+ CleanupStack::Pop(array);
+ return array;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::MoveChildAbove
+// From MSwtComposite
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::MoveChildAbove(MSwtControl& /*aChild1*/,
+ const MSwtControl* /*aChild2*/)
+{
+ // Will never be called, a CaptionedControl has at most one child
+ ASSERT(EFalse);
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::MoveChildBelow
+// From MSwtComposite
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::MoveChildBelow(MSwtControl& /*aChild1*/,
+ const MSwtControl* /*aChild2*/)
+{
+ // Will never be called, a CaptionedControl has at most one child
+ ASSERT(EFalse);
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::NotifyRadioGroup
+// From MSwtComposite
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::NotifyRadioGroup(MSwtButton* /*aSelectedButton*/)
+{
+ // The CaptionedControl have only one children so don't manage RadioGroupButton.
+ ASSERT(EFalse);
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::GetPointerGrabbingControl
+// From MSwtComposite
+// ---------------------------------------------------------------------------
+//
+MSwtControl* CSwtCaptionedControl::GetPointerGrabbingControl() const
+{
+ return iPointerGrabbingControl;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::SetScrolledCompositeContentL
+// From MSwtComposite
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::SetScrolledCompositeContentL(MSwtControl* /*aContent*/)
+{
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::ScrolledCompositeContent
+// From MSwtComposite
+// ---------------------------------------------------------------------------
+//
+MSwtControl* CSwtCaptionedControl::ScrolledCompositeContent() const
+{
+ return NULL;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::ScrolledCompositePysicsAction
+// From MSwtComposite
+// ---------------------------------------------------------------------------
+//
+TInt CSwtCaptionedControl::ScrolledCompositePysicsAction() const
+{
+ return 0;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::DrawScrollBarBackground
+// From MSwtComposite
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::DrawScrollBarBackground(const TRect& /*aRect*/) const
+{
+ // Do nothing
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::Composite
+// From MSwtCaptionedControl
+// ---------------------------------------------------------------------------
+//
+MSwtComposite* CSwtCaptionedControl::Composite() const
+{
+ return CompositeInterface();
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::SetTextL
+// From MSwtCaptionedControl
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::SetTextL(const TDesC& aString)
+{
+ CEikCapCLabel* oldCaption = iCaption;
+
+ SetCaptionL(aString);
+
+ delete iCaptionText;
+ iCaptionText=0;
+ iCaptionText = aString.AllocL();
+
+ if (iCaption && iCaption != oldCaption)
+ {
+ iCaption->SetContainerWindowL(*this); // Absolutely necessary
+ iCaption->SetMopParent(this); // Absolutely necessary
+ iCaption->MakeVisible(IsVisible());
+ iCaption->SetDimmed(IsDimmed());
+ SetEmphasis(ENoDrawNow);
+ if (AknLayoutUtils::LayoutMirrored())
+ {
+ iCaption->SetAlignment(EHRightVCenter);
+ }
+ else
+ {
+ iCaption->SetAlignment(EHLeftVCenter);
+ }
+ iCaption->ActivateL();
+ }
+
+ if (iCaption)
+ {
+ const MSwtFont* swtFont = GetFont();
+ ASSERT(swtFont);
+ const CFont& font = (swtFont->Font());
+ iCaption->SetFont(&font);
+
+ iCaption->SetAllMarginsTo(0);
+ TInt captionRealFontHeight;
+ if (RealFontHeight(captionRealFontHeight))
+ {
+ iCaption->iMargin.iTop = captionRealFontHeight - font.HeightInPixels();
+ }
+ }
+
+ // We force a call to ( private ) SizeChanged to resize the components.
+ ResetMinimumSizes();
+ SetWidgetSize(iSize);
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::SetTrailingTextL
+// From MSwtCaptionedControl
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::SetTrailingTextL(const TDesC& aString)
+{
+ CEikLabel* oldTrailer = iTrailer;
+
+ if (!aString.Length())
+ {
+ delete iTrailer;
+ iTrailer = NULL;
+ }
+ else
+ {
+ SetTrailerL(aString);
+ }
+
+ if (iTrailer && iTrailer != oldTrailer)
+ {
+ iTrailer->SetContainerWindowL(*this); // Absolutely necessary
+ iTrailer->SetMopParent(this); // Absolutely necessary
+ iTrailer->MakeVisible(IsVisible());
+ iTrailer->SetDimmed(IsDimmed());
+ SetEmphasis(ENoDrawNow);
+ iTrailer->ActivateL();
+ }
+
+ if (iTrailer)
+ {
+ const MSwtFont* swtFont = GetFont();
+ ASSERT(swtFont);
+ const CFont& font = (swtFont->Font());
+ iTrailer->SetFont(&font);
+ iTrailer->SetAllMarginsTo(0);
+
+ TInt captionRealFontHeight;
+ if (RealFontHeight(captionRealFontHeight))
+ {
+ iTrailer->iMargin.iTop = captionRealFontHeight - font.HeightInPixels();
+ }
+ }
+
+ // We force a call to ( private ) SizeChanged to resize the components.
+ ResetMinimumSizes();
+ SetWidgetSize(iSize);
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::GetText
+// From MSwtCaptionedControl
+// ---------------------------------------------------------------------------
+//
+const TDesC* CSwtCaptionedControl::GetText() const
+{
+ return iCaption? iCaption->Text() : NULL;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::GetTrailingText
+// From MSwtCaptionedControl
+// ---------------------------------------------------------------------------
+//
+const TDesC* CSwtCaptionedControl::GetTrailingText() const
+{
+ return iTrailer? iTrailer->Text() : NULL;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::SetImageL
+// From MSwtCaptionedControl
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::SetImageL(MSwtImage* aImage)
+{
+ if (aImage)
+ {
+ CFbsBitmap* bitmap = SwtControlHelper::GetCopyOfBitmapLC(
+ &aImage->Bitmap());
+ CFbsBitmap* mask = SwtControlHelper::GetInvertedCopyOfMonoBitmapLC(
+ aImage->MaskBitmap());
+
+ ASSERT(bitmap);
+ if (!mask)
+ {
+ // Captioned Control drawing does not support images with a NULL mask.
+ mask = new(ELeave) CFbsBitmap;
+ CleanupStack::PushL(mask);
+ User::LeaveIfError(mask->Create(bitmap->SizeInPixels(), EGray2));
+
+ CFbsBitmapDevice* device = CFbsBitmapDevice::NewL(mask);
+ CleanupStack::PushL(device);
+ CFbsBitGc* gc = CFbsBitGc::NewL();
+ CleanupStack::PushL(gc);
+
+ gc->Activate(device);
+ gc->SetPenStyle(CGraphicsContext::ENullPen);
+ gc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ gc->SetBrushColor(KRgbBlack);
+ gc->DrawRect(TRect(bitmap->SizeInPixels()));
+
+ CleanupStack::PopAndDestroy(gc);
+ CleanupStack::PopAndDestroy(device);
+ }
+
+ // After SetIconL, the CEikCaptionedControl owns bitmap and mask.
+ SetIconL(bitmap, mask);
+ CleanupStack::Pop(mask);
+ CleanupStack::Pop(bitmap);
+ }
+ else
+ {
+ SetIconL(NULL, NULL);
+ }
+
+ if (iBitmap)
+ {
+ iBitmap->SetContainerWindowL(*this); // Absolutely necessary
+ iBitmap->SetMopParent(this); // Absolutely necessary
+ }
+
+ // We force a call to ( private ) SizeChanged to resize the components.
+ ResetMinimumSizes();
+ SetWidgetSize(iSize);
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::SetChildPreferredSize
+// From MSwtCaptionedControl
+// ---------------------------------------------------------------------------
+//
+void CSwtCaptionedControl::SetChildPreferredSize(const TSize& aSize)
+{
+ ASSERT(iControl);
+ static_cast<CControlProxy*>(iControl)->iPreferredSize = aSize;
+}
+
+// ---------------------------------------------------------------------------
+// CSwtCaptionedControl::GetImageControl
+// From MSwtCaptionedControl
+// ---------------------------------------------------------------------------
+//
+const CCoeControl* CSwtCaptionedControl::GetImageControl() const
+{
+ return iBitmap;
+}