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 <biditext.h>

    14 #include <aknappui.h>

    15 #include <aknnavi.h>

    16 #include <aknnavide.h>

    17 #include <akntabgrp.h>

    18 #include <coecntrl.h>

    19 #include <eikon.hrh>

    20 #include <AknsDrawUtils.h>

    21 #include <swtlaffacade.h>

    22 #include <coreuiavkoneswt.h>

    23 #include "eswtmobileextensions.h"

    24 #include "swtcontrolbase.h"

    25 #include "swtuiutils.h"

    26 #include "swtjavabufferdrawer.h"

    27 

    28 

    29 // ======== MEMBER FUNCTIONS ========

    30 

    31 

    32 EXPORT_C ASwtControlBase::ASwtControlBase(MSwtDisplay& aDisplay, TSwtPeer aPeer,

    33         MSwtComposite* aParent, TInt aStyle)

    34         : iDisplay(aDisplay)

    35         , iPeer(aPeer)

    36         , iParent(aParent)

    37         , iCtrlFlags(0)

    38         , iStyle(aStyle)

    39         , iFont(NULL)

    40         , iPopupMenu(NULL)

    41         , iIsOnControlStack(EFalse)

    42         , iStackedSetRedrawFalseNb(0)

    43         , iBackgrdDefaultUsed(ETrue)

    44         , iFocusFrame(NULL)

    45         , iFocusChanged(EFalse)

    46 {

    47     ASSERT(iPeer!=NULL);

    48 

    49     // Orientation not specified, find default

    50     TInt orientation = iStyle & KSwtOrientationMask;

    51     if (orientation!=KSwtStyleLeftToRight && orientation!=KSwtStyleRightToLeft)

    52     {

    53         if (iParent != NULL) // Inherit from parent

    54             orientation = iParent->Control()->Style() & KSwtOrientationMask;

    55         else                 // Based on user's locale

    56             orientation = (TBidiText::ScriptDirectionality(User::Language())==TBidiText::ELeftToRight) ?

    57                           KSwtStyleLeftToRight : KSwtStyleRightToLeft;

    58 

    59         iStyle &= ~KSwtOrientationMask;

    60         iStyle |= orientation;

    61     }

    62 }

    63 

    64 void ASwtControlBase::CreateFocusBackgroundL()

    65 {

    66     ASSERT(!iFocusFrame);

    67 

    68     TRect rect(CoeControl().Rect());

    69     TRect innerRect;

    70     innerRect.iTl = CSwtLafFacade::GetLayoutRect(

    71                         CSwtLafFacade::EInputFieldSkinPlacingGeneralLine2, rect, 0).Rect().iBr;

    72     innerRect.iBr = CSwtLafFacade::GetLayoutRect(

    73                         CSwtLafFacade::EInputFieldSkinPlacingGeneralLine5, rect, 0).Rect().iTl;

    74 

    75     iFocusFrame = CAknsFrameBackgroundControlContext::NewL(

    76                       KAknsIIDQsnFrInput, rect, innerRect, EFalse /*parent absolute*/);

    77 

    78     if (iBackgrdDefaultUsed)

    79     {

    80         iFocusFrame->SetParentContext(SwtMopSupplyCtrlContext(EFalse));

    81     }

    82 }

    83 

    84 CAknsBasicBackgroundControlContext* ASwtControlBase::FocusBackgroundNow() const

    85 {

    86     if (HasHighlight(EFalse)) // not checking parents

    87     {

    88         return iFocusFrame;

    89     }

    90     else

    91     {

    92         return NULL;

    93     }

    94 }

    95 

    96 void ASwtControlBase::RedrawFocusBackground()

    97 {

    98     MSwtCaptionedControl* captCtrl = GetNearestCaptionedControl();

    99     if (captCtrl)

   100     {

   101         captCtrl->Composite()->Control()->Redraw();

   102     }

   103     else

   104     {

   105         Redraw();

   106     }

   107 }

   108 

   109 void ASwtControlBase::InitControlBaseL()

   110 {

   111     RegisterWithParentL();

   112 }

   113 

   114 EXPORT_C ASwtControlBase::~ASwtControlBase()

   115 {

   116     delete iFocusFrame;

   117 

   118     // RemoveRef here in case it goes through destruction before being

   119     // registered (and Dispose() is not called)

   120     if (iFont != NULL)

   121         iFont->RemoveRef();

   122 

   123 #ifdef _lint

   124     //lint -esym(1740, ASwtControlBase::iPeer)

   125     //lint -esym(1740, ASwtControlBase::iParent)

   126     iFont      = NULL;

   127     iPopupMenu = NULL;

   128 #endif

   129 }

   130 

   131 // From class MCoeControlBackground.

   132 // Draw the Background. This method was called by the eSWT and Symbian drawing framework.

   133 // If the control is a Composite then make sure not to draw the background to

   134 // the areas that will be painted by the children. This is to avoid painting

   135 // over them as this would cause flickering.

   136 //

   137 EXPORT_C void ASwtControlBase::Draw(CWindowGc& aGc, const CCoeControl& aControl,

   138                                     const TRect& aRect) const

   139 {

   140     RRegion* clippingRegion = NULL;

   141     const MSwtComposite* composite = CompositeInterface();

   142     if (composite)

   143     {

   144         clippingRegion = SetupChildClippingRegion(composite, aGc, aRect);

   145     }

   146 

   147     TBool isDialogShell = IsShell() && iParent;

   148     TBool isTaskTip = isDialogShell && ShellInterface()->IsTaskTip();

   149 

   150     // Draw the background.

   151     if (!IsDefaultBackgroundUse()

   152 #ifdef RD_JAVA_S60_RELEASE_9_2

   153             // Fill the round corners

   154             || (isDialogShell && !isTaskTip)

   155 #endif // RD_JAVA_S60_RELEASE_9_2

   156        )

   157     {

   158         aGc.SetBrushColor(GetBackground());

   159         aGc.Clear(aRect);

   160     }

   161 

   162     // Hopefully the highlight back is always semi transparent,

   163     // otherwise the back color is lost.

   164     MAknsControlContext* cc = SwtMopSupplyCtrlContext();

   165     AknsDrawUtils::Background(AknsUtils::SkinInstance(), cc, &aControl, aGc, aRect);

   166 

   167     // Cancel & destroy the clipping region

   168     CancelChildClippingRegion(clippingRegion, aGc);

   169 }

   170 

   171 EXPORT_C void ASwtControlBase::DrawBorder(const TRect& /*aRect*/) const

   172 {

   173     TInt borderWidth = GetBorderWidth();

   174     if (borderWidth > 0)

   175     {

   176         CWindowGc& gc = CoeControl().SystemGc();

   177         gc.SetBrushStyle(CGraphicsContext::ENullBrush);

   178         gc.SetPenColor(UiUtils().GetSystemColor(ESwtColorWidgetBorder));

   179         gc.SetPenStyle(CGraphicsContext::ESolidPen);

   180         gc.SetPenSize(TSize(borderWidth, borderWidth));

   181         gc.DrawRect(CoeControl().Rect());

   182     }

   183 }

   184 

   185 // In eSWT all border should have the same width/height.

   186 EXPORT_C TInt ASwtControlBase::GetBorderWidth() const

   187 {

   188     if (HasBorderStyle())

   189     {

   190         return 1;

   191     }

   192     else

   193     {

   194         return 0;

   195     }

   196 }

   197 

   198 // Window coords

   199 EXPORT_C TRect ASwtControlBase::ClientRect() const

   200 {

   201     return BorderInnerRect();

   202 }

   203 

   204 TBool ASwtControlBase::HasBorderStyle() const

   205 {

   206     TBool res = (iStyle & KSwtStyleBorder);

   207     const MSwtShell* shell = ShellInterface();

   208     if (shell)

   209     {

   210         // TaskTip shells have the border.

   211         res = shell->IsTaskTip() || (res && !(iStyle & KSwtStyleNoTrim) && iParent);

   212     }

   213     return res;

   214 }

   215 

   216 TSize ASwtControlBase::BorderSizeDelta() const

   217 {

   218     return TSize(GetBorderWidth()*2, GetBorderWidth()*2) ;

   219 }

   220 

   221 // Window coords

   222 EXPORT_C TRect ASwtControlBase::BorderInnerRect() const

   223 {

   224     TRect borderInnerRect = CoeControl().Rect();

   225 

   226     if (borderInnerRect.Height() != 0 && borderInnerRect.Width() != 0)

   227     {

   228         TInt w(GetBorderWidth());

   229         borderInnerRect.Shrink(w, w);

   230     }

   231 

   232     return borderInnerRect;

   233 }

   234 

   235 EXPORT_C TRect ASwtControlBase::BorderOuterRect(const TRect& aRect) const

   236 {

   237     TRect borderOuterRect(aRect);

   238     borderOuterRect.Grow(GetBorderWidth(), GetBorderWidth());

   239 

   240     return borderOuterRect;

   241 }

   242 

   243 TKeyResponse ASwtControlBase::HandleDiagonalKeysL(const TKeyEvent& aKeyEvent, TEventCode aType,

   244         TBool aTraversalDoIt, const TUint key1, const TStdScanCode scanCode1,

   245         const TUint key2, const TStdScanCode scanCode2)

   246 {

   247     TKeyEvent keyTemp;

   248     // send first event

   249     keyTemp.iRepeats = 0;

   250     keyTemp.iScanCode = scanCode1;

   251     keyTemp.iModifiers = 32768;

   252     keyTemp.iCode = 0;

   253     HandleKeyL(keyTemp, EEventKeyDown, aTraversalDoIt);     //DOWN

   254     keyTemp = aKeyEvent;

   255     keyTemp.iCode = key1;

   256     keyTemp.iScanCode = scanCode1;

   257     TKeyResponse firstResponse = HandleKeyL(keyTemp, aType, aTraversalDoIt);     // KEYCODE

   258     keyTemp.iRepeats = 0;

   259     keyTemp.iScanCode = scanCode1;

   260     keyTemp.iModifiers = 32768;

   261     keyTemp.iCode = 0;

   262     HandleKeyL(keyTemp, EEventKeyUp, aTraversalDoIt);      // UP

   263 

   264     // send second event

   265     keyTemp.iRepeats = 0;

   266     keyTemp.iScanCode = scanCode2;

   267     keyTemp.iModifiers = 32768;

   268     keyTemp.iCode = 0;

   269     HandleKeyL(keyTemp, EEventKeyDown, aTraversalDoIt);     // DOWN

   270     keyTemp = aKeyEvent;

   271     keyTemp.iCode = key2;

   272     keyTemp.iScanCode = scanCode2;

   273     TKeyResponse secondResponse = HandleKeyL(keyTemp, aType, aTraversalDoIt);     // KEYCODE

   274     keyTemp.iRepeats = 0;

   275     keyTemp.iScanCode = scanCode2;

   276     keyTemp.iModifiers = 32768;

   277     keyTemp.iCode = 0;

   278     HandleKeyL(keyTemp, EEventKeyUp, aTraversalDoIt);       // UP

   279 

   280     TKeyResponse response = EKeyWasNotConsumed;

   281     if (EKeyWasConsumed == firstResponse && EKeyWasConsumed == secondResponse)

   282     {

   283         response = EKeyWasConsumed;

   284     }

   285 

   286     return response;

   287 }

   288 

   289 void ASwtControlBase::DrawComponentControls(const CCoeControl& aControl,

   290         const TRect& aRect, CWindowGc& aGc, TBool aCanDrawOutsideRect)

   291 {

   292     const TInt count = aControl.CountComponentControls();

   293     for (TInt i=0; i<count; ++i)

   294     {

   295         CCoeControl& compCtrl = *aControl.ComponentControl(i);

   296         if (compCtrl.IsVisible())

   297         {

   298             if (compCtrl.OwnsWindow())

   299             {

   300             }

   301             else

   302             {

   303                 TRect drawRect(compCtrl.Rect());

   304                 drawRect.Intersection(aRect);

   305                 if (!drawRect.IsEmpty())

   306                 {

   307                     aGc.Reset();

   308                     aGc.SetClippingRect(drawRect);

   309                     compCtrl.DrawBackground(drawRect);

   310                     compCtrl.DrawForeground(drawRect);

   311                 }

   312 

   313                 if (aCanDrawOutsideRect)

   314                 {

   315                     DrawComponentControls(compCtrl, aRect, aGc, aCanDrawOutsideRect);

   316                 }

   317                 else if (!drawRect.IsEmpty())

   318                 {

   319                     DrawComponentControls(compCtrl, drawRect, aGc, aCanDrawOutsideRect);

   320                 }

   321             }

   322         }

   323     }

   324 }

   325 

   326 TBool ASwtControlBase::RectContainsRect(const TRect& aContainer, const TRect& aContainee)

   327 {

   328     return (aContainer.iTl.iX <= aContainee.iTl.iX

   329             && aContainer.iTl.iY <= aContainee.iTl.iY

   330             && aContainer.iBr.iX >= aContainee.iBr.iX

   331             && aContainer.iBr.iY >= aContainee.iBr.iY);

   332 }

   333 

   334 void ASwtControlBase::FlushJavaBuffer(MSwtGc* aGc, TInt* aIntParams, TInt aIntCount, HBufC* aStrParams, RWindow* aWindow, const TRect& aDrawRect) const

   335 {

   336     iDisplay.JavaBufferDrawer().Draw(aGc, aIntParams, aIntCount, aStrParams, aWindow, aDrawRect);

   337 }

   338 

   339 EXPORT_C void ASwtControlBase::PostMouseEventL(const TPointerEvent& aPointerEvent)

   340 {

   341     TPoint eventPosition(aPointerEvent.iPosition);

   342 

   343     // Is is essential that the coordinates posted to the queue are in screen

   344     // coordinates to ensure the case where late mouse events are handled

   345     // after the control has moved away from the current position.

   346     TPoint pos(WindowToScreen(eventPosition));

   347 

   348     // Compute the state mask

   349     TInt stateMask = UiUtils().GetPointerEventStateMask(aPointerEvent.iModifiers);

   350 

   351     // Handle double click (must be issued between Down and Up)

   352     if (aPointerEvent.iModifiers & EModifierDoubleClick)

   353         iDisplay.PostMouseEventL(iPeer, ESwtEventMouseDoubleClick, 0, pos, stateMask);

   354 

   355     // Compute the event type and button number

   356     TSwtEventType type;

   357     TInt          button = 0;

   358     switch (aPointerEvent.iType)

   359     {

   360     case TPointerEvent::EButton1Down:

   361         type   = ESwtEventMouseDown;

   362         button = KSwtMouseButton1;

   363         break;

   364     case TPointerEvent::EButton1Up:

   365         type   = ESwtEventMouseUp;

   366         button = KSwtMouseButton1;

   367         break;

   368     case TPointerEvent::EButton2Down:

   369         type   = ESwtEventMouseDown;

   370         button = KSwtMouseButton2;

   371         break;

   372     case TPointerEvent::EButton2Up:

   373         type   = ESwtEventMouseUp;

   374         button = KSwtMouseButton2;

   375         break;

   376     case TPointerEvent::EButton3Down:

   377         type   = ESwtEventMouseDown;

   378         button = KSwtMouseButton3;

   379         break;

   380     case TPointerEvent::EButton3Up:

   381         type   = ESwtEventMouseUp;

   382         button = KSwtMouseButton3;

   383         break;

   384     case TPointerEvent::EDrag:

   385     case TPointerEvent::EMove:

   386         type = ESwtEventMouseMove;

   387         break;

   388     default:

   389         return;

   390     }

   391 

   392     iDisplay.PostMouseEventL(iPeer, type, button, pos, stateMask);

   393 }

   394 

   395 EXPORT_C void ASwtControlBase::EnableFocusHighlight(TBool /*aEnable*/)

   396 {

   397     // Method is used only on 9.2 for list controls (Lists, ListView,

   398     // ListBox and Table)

   399 }

   400 

   401 TPoint ASwtControlBase::ComputeLocationToSet(const TPoint& aLocation)

   402 {

   403     ASSERT(!IsShell());

   404     return aLocation + iParent->Scrollable()->Control()->ClientRect().iTl; //lint !e613

   405 }

   406 

   407 EXPORT_C MSwtShell& ASwtControlBase::GetShell() const

   408 {

   409     if (!iShell)

   410     {

   411         MSwtShell* selfAsShell = const_cast<MSwtShell*>(ShellInterface());

   412         if (selfAsShell)

   413             iShell = selfAsShell;

   414         else

   415             iShell = &iParent->Control()->GetShell();

   416     }

   417     ASSERT(iShell);

   418     return *iShell;

   419 }

   420 

   421 void ASwtControlBase::Invalidate(const TRect& aRect)

   422 {

   423     if (!aRect.IsEmpty() && CoeControl().IsVisible() && !(iCtrlFlags & MSwtControl::EFlagDoNotDraw))

   424         ForceInvalidate(aRect);

   425 }

   426 

   427 void ASwtControlBase::ForceInvalidate(const TRect& aRect)

   428 {

   429     if (aRect.IsEmpty())

   430     {

   431         return;

   432     }

   433 

   434     MSwtShell& shell = GetShell();

   435     MSwtControl* urgentPaintControl = shell.UrgentPaintControl();

   436     if (urgentPaintControl)

   437     {

   438         // Redraw requests outside urgently painted controls are ignored.

   439         if (IsDescentOf(*urgentPaintControl))

   440         {

   441             urgentPaintControl->PaintUrgently(aRect);

   442         }

   443     }

   444     else

   445     {

   446         if (shell.AsyncPainting())

   447         {

   448             TRect dirtyRect(aRect);

   449             MSwtControl* controlShell = shell.Control();

   450 

   451             // Convert to Screen Coordinate

   452             dirtyRect.Move(controlShell->CoeControl().PositionRelativeToScreen());

   453 

   454             TBool mergeable = !(iStyle & KSwtStyleNoMergePaints);

   455             TRAP_IGNORE(iDisplay.PostPaintEventL(JavaPeer(), controlShell->JavaPeer(), dirtyRect, mergeable));

   456         }

   457         else

   458         {

   459             static_cast<RWindow*>(shell.Control()->CoeControl().DrawableWindow())->Invalidate(aRect);

   460         }

   461     }

   462 }

   463 

   464 EXPORT_C void ASwtControlBase::DoPaint(const TRect& aRect) const

   465 {

   466     ASSERT(!IsShell());

   467     const CCoeControl& ctrl = CoeControl();

   468     ctrl.DrawBackground(aRect);

   469     ctrl.DrawForeground(aRect);

   470 }

   471 

   472 EXPORT_C void ASwtControlBase::SetColorL(TLogicalColor aLogicalColor, const MSwtColor* aColor)

   473 {

   474     CCoeControl& coeCtrl = CoeControl();

   475     TRgb color((aColor!=NULL) ? aColor->RgbValue() : iDisplay.CoeEnv()->Color(aLogicalColor));

   476     coeCtrl.OverrideColorL(aLogicalColor, color);

   477 }

   478 

   479 EXPORT_C CSwtUiUtils& ASwtControlBase::UiUtils() const

   480 {

   481     return static_cast<CSwtUiUtils&>(iDisplay.UiUtils());

   482 }

   483 

   484 EXPORT_C void ASwtControlBase::DoDelete()

   485 {

   486     delete this;

   487 }

   488 

   489 EXPORT_C TRect ASwtControlBase::VisibleRect(TBool aVisibleBounds) const

   490 {

   491     // WINDOW COORDINATES!

   492     if (!CoeControl().IsVisible())

   493         return TRect(); // This is (0,0,0,0)

   494 

   495     TRect rect((aVisibleBounds)? CoeControl().Rect() : ClientRect());

   496 

   497     if (!IsShell())

   498     {

   499         rect = ClipToVisibleRect(rect);

   500     }

   501 

   502     return rect;

   503 }

   504 

   505 EXPORT_C TBool ASwtControlBase::HasHighlight(TBool aIncludingParents /*= ETrue*/) const

   506 {

   507     TBool res = iHighlightEnabled;

   508     if (!res && aIncludingParents)

   509     {

   510         res = res || (iParent && iParent->Control()->HasHighlight(ETrue));

   511     }

   512     return res;

   513 }

   514 

   515 EXPORT_C void ASwtControlBase::SetHighlight(TBool aEnabled)

   516 {

   517     iHighlightEnabled = aEnabled;

   518 

   519     // Prepare the frame

   520     if (aEnabled && !iFocusFrame)

   521     {

   522         TRAP_IGNORE(const_cast<ASwtControlBase*>(this)->CreateFocusBackgroundL());

   523     }

   524 

   525     HandleHighlightChange();

   526 }

   527 

   528 EXPORT_C void ASwtControlBase::HandleHighlightChange()

   529 {

   530     // Do nothing here. Inherit where needed.

   531 }

   532 

   533 EXPORT_C void ASwtControlBase::PrepareForTraverse()

   534 {

   535     // Do nothing here. Inherit where needed.

   536 }

   537 

   538 TRect ASwtControlBase::ClipToVisibleRect(const TRect& aRect) const

   539 {

   540     // WINDOW COORDINATES!

   541     TRect rect = aRect;

   542     MSwtComposite* composite = iParent;

   543     while (composite != NULL)

   544     {

   545         MSwtControl* ctrl = composite->Control();

   546         rect.Intersection(ctrl->ClientRect());

   547         composite = (!ctrl->IsShell()) ? ctrl->GetParent() : NULL;

   548     }

   549     return rect;

   550 }

   551 

   552 // Hurts the performance of non overlapping drawing when there are a lot

   553 // of control sibblings and does not really work for overlapping drawing

   554 #if 0

   555 void ASwtControlBase::VisibleRegion(RRegion& aRegion, TBool aVisibleBounds) const

   556 {

   557     // SCREEN COORDINATES!

   558     aRegion.AddRect(TRect(CoeControl().PositionRelativeToScreen(),

   559                           aVisibleBounds ? CoeControl().Size() : ClientRect().Size()));

   560     MSwtComposite* parent = iParent;

   561     const MSwtControl*  children = this;

   562 

   563     while (parent && !children->IsShell())

   564     {

   565         const RSwtControlArray* siblings = parent->Children();

   566 

   567         for (TInt i = siblings->Find(children)-1; i >= 0; i--)

   568         {

   569             MSwtControl* control = (*siblings)[i];

   570 

   571             if (!control->IsShell() && control->CoeControl().IsVisible())

   572             {

   573                 aRegion.SubRect(TRect(control->CoeControl().PositionRelativeToScreen(), control->CoeControl().Size()));

   574             }

   575         }

   576 

   577         children = parent->Control();

   578         parent = parent->Control()->GetParent();

   579     }

   580 }

   581 #endif

   582 

   583 TPoint ASwtControlBase::WindowToScreen(const TPoint& aPoint) const

   584 {

   585     const CCoeControl& coeControl = CoeControl();

   586     const TPoint posInScreen(coeControl.PositionRelativeToScreen());

   587     const TPoint posInWindow((coeControl.OwnsWindow()) ? TPoint(0,0) : coeControl.Position());

   588 

   589     TInt x = (aPoint.iX - posInWindow.iX) + posInScreen.iX;

   590     TInt y = (aPoint.iY - posInWindow.iY) + posInScreen.iY;

   591     return TPoint(x,y);

   592 }

   593 

   594 void ASwtControlBase::FocusabilityChanged()

   595 {

   596     CCoeControl& coeCtrl = CoeControl();

   597     MSwtShell& shell = GetShell();

   598 

   599     if (!IsFocusable(EFalse))

   600     {

   601         if (coeCtrl.IsFocused())

   602         {

   603             // Composite losing focusability can mean that it has received a new child.

   604             // Otherwise it means that the Composite itself has been disabled or hidden.

   605             // If a Control loses focusability, let the parent find a new focus target.

   606             // If a Composite loses focusability, find new target first in children then ancestors.

   607             MSwtControl* newFocus = NULL;

   608             MSwtComposite* comp = CompositeInterface();

   609             if (comp)

   610             {

   611                 TRAP_IGNORE((newFocus = shell.FindTraversalTargetL(ESwtTraverseArrowNext, *this)));

   612             }

   613             if (!newFocus)

   614             {

   615                 TRAP_IGNORE((newFocus = shell.FindTraversalTargetL(ESwtTraverseParent, *this)));

   616             }

   617             if (newFocus)

   618             {

   619                 newFocus->CoeControl().SetFocus(ETrue);

   620             }

   621             else

   622             {

   623                 // This control was focused but now there's nothing focusable anymore

   624                 coeCtrl.SetFocus(EFalse);

   625                 shell.SetControlGainingFocus(NULL);

   626                 shell.SetControlGoingToStack(NULL);

   627                 if (UiUtils().NextFocusedControl() == this)

   628                 {

   629                     UiUtils().SetNextFocusedControl(NULL);

   630                 }

   631             }

   632         }

   633         ASSERT(!coeCtrl.IsFocused());

   634     }

   635     else

   636     {

   637         if (UiUtils().GetActiveShell() == &shell && shell.FocusControl() == NULL)

   638             coeCtrl.SetFocus(ETrue);

   639     }

   640 }

   641 

   642 EXPORT_C void ASwtControlBase::HandleFocusChanged(TDrawNow /*aDrawNow*/)

   643 {

   644     CCoeControl&  coeCtrl     = CoeControl();

   645     TBool         focused     = coeCtrl.IsFocused();

   646     CSwtUiUtils&  uiUtils     = UiUtils();

   647     MSwtShell*    activeShell = uiUtils.GetActiveShell();

   648     MSwtControl*  oldFocus    = (activeShell!=NULL) ? activeShell->FocusControl() : NULL;

   649     TBool         appFocus    = uiUtils.IsAppFocused();

   650 

   651     // Detect when SetFocus() has been called twice with the same parameter

   652     if (oldFocus && ((focused && oldFocus == this)

   653                      || (!focused && oldFocus != this)))

   654     {

   655         return;

   656     }

   657 

   658     MSwtShell& shell = GetShell();

   659 

   660     // Make sure that UiUtils' information of the control that most

   661     // recently had focus is up-to-date. This way the focus will be

   662     // returned to the correct control once we regain application

   663     // focus after losing it.

   664     if (oldFocus == this)

   665     {

   666         uiUtils.SetNextFocusedControl(oldFocus);

   667     }

   668 

   669     // if app fails on next line check this issue:

   670     // caller should call MSwtControl::SetFocus() or MSwtControl::ForceFocus()

   671     // or Overridden function if posssible,

   672     // instead of CCoeControl::SetFoucus directly

   673     ASSERT(!(focused && !appFocus));

   674 

   675     if (!focused)

   676     {

   677         // Remove current control from ControlStack since the control becomes unfocused

   678         RemoveFromControlStack();

   679     }

   680 

   681     // Update the focus control

   682     if (focused)

   683     {

   684         // Clear the urgent paint control if focus goes outside it.

   685         // There cannot be an urgently painted control that is not

   686         // focused or does not have a focused child.

   687         MSwtControl* urgentPaintControl = shell.UrgentPaintControl();

   688         if (urgentPaintControl && urgentPaintControl != this

   689                 && !IsDescentOf(*urgentPaintControl))

   690         {

   691             shell.SetUrgentPaintControl(NULL);

   692         }

   693 

   694         // Activate our shell and remove focus from current owner

   695         if (activeShell != &shell)

   696         {

   697             // This removes focus from oldFocus

   698             uiUtils.SetActiveShell(shell, EFalse);

   699         }

   700         else

   701         {

   702             if (oldFocus)

   703             {

   704                 // first add control before removing the control from controlstack

   705                 // so that it stop calling focusChanged of shell.

   706                 TRAP_IGNORE(AddToControlStackL(ECoeStackPriorityDefault));

   707                 oldFocus->CoeControl().SetFocus(EFalse);

   708             }

   709         }

   710 

   711         ASSERT(!oldFocus || !oldFocus->CoeControl().IsFocused());

   712 

   713         // Set ourselves as the new focus control

   714         // Can't register a Shell with itself

   715         if (shell.Control() != this)

   716         {

   717             shell.SetFocusControl(this);

   718         }

   719     }

   720     else

   721     {

   722         shell.SetFocusControl(NULL);

   723     }

   724 

   725     // Notify parent of our new focus

   726     MSwtComposite* parent = GetParent();

   727     if (parent)

   728     {

   729         parent->ChildFocusChanged(*this);

   730     }

   731 

   732 

   733     // Notify Menu arranger

   734     if (focused)

   735     {

   736         iDisplay.MenuArranger().ControlFocusGained(*this);

   737     }

   738     else

   739     {

   740         iDisplay.MenuArranger().ControlFocusLost();

   741     }

   742 

   743     // Notify Command arranger

   744     MSwtCommandArranger* commandArranger = iDisplay.CommandArranger();

   745     if (commandArranger)   // commandArranger may be null as Mobile Extensions is optional

   746     {

   747         if (focused)

   748         {

   749             commandArranger->ControlFocusGained(*this);

   750         }

   751         else

   752         {

   753             commandArranger->ControlFocusLost();

   754         }

   755     }

   756 

   757     // Post the focus event

   758     TSwtEventType type((focused) ? ESwtEventFocusIn : ESwtEventFocusOut);

   759     TRAP_IGNORE(iDisplay.PostFocusEventL(JavaPeer(), type));

   760 

   761     if (focused)

   762     {

   763         // Add to ControlStack since the control becomes focused

   764         TRAP_IGNORE(AddToControlStackL(ECoeStackPriorityDefault));

   765     }

   766 

   767     shell.UpdateHighlight();

   768 }

   769 

   770 TKeyResponse ASwtControlBase::OfferKeyEventToCommandAndMenuArrangersL(

   771     const TKeyEvent& aKeyEvent,

   772     TEventCode aType)

   773 {

   774     if ((aType == EEventKeyDown) || (aType==EEventKeyUp))

   775     {

   776         return EKeyWasNotConsumed;

   777     }

   778 

   779     MSwtShell* activeTopShell = iDisplay.UiUtils().GetParentTopShellOfActiveShell();

   780     MSwtMenuArranger& menuArranger = iDisplay.MenuArranger();

   781     if (activeTopShell

   782             && activeTopShell->FullScreenMode()

   783             && menuArranger.IsOptionsCommandAdded())

   784     {

   785         if (aKeyEvent.iCode == EKeyCBA1 || aKeyEvent.iCode == EKeyCBA2)

   786         {

   787             menuArranger.TryDisplayMenuBarL(EFalse);

   788             return EKeyWasConsumed;

   789         }

   790     }

   791 

   792     // If the OK and backspace keys are not used by the control, HandleKeyL() returns EKeyWasNotConsumed.

   793     // Thus, this allows the command arranger calling the operations associated to these keys

   794     MSwtCommandArranger* commandArranger = iDisplay.CommandArranger();

   795     if (commandArranger != NULL)

   796     {

   797         // Clear command is called when backspace key is pressed

   798         if (aKeyEvent.iCode == EKeyBackspace &&

   799                 !IsKeyUsed(EKeyBackspace) &&

   800                 commandArranger->IsClearOperationSet())

   801         {

   802             if (commandArranger->DoClearOperationL())

   803             {

   804                 return EKeyWasConsumed;

   805             }

   806         }

   807         else if (!AknLayoutUtils::MSKEnabled() ||

   808                  (activeTopShell && activeTopShell->FullScreenMode()))

   809         {

   810             // When the selection key is pressed, the default command is called otherwise

   811             // a menu with the OK and SELECT commands is displayed

   812             if (aKeyEvent.iCode == EKeyOK

   813                     && !IsKeyUsed(EKeyOK)

   814                     && commandArranger->IsContextSensitiveOperationSet())

   815             {

   816                 if (commandArranger->DoContextSensitiveOperationL())

   817                 {

   818                     return EKeyWasConsumed;

   819                 }

   820             }

   821         }

   822         else if (aKeyEvent.iCode == EKeyEnter && !IsKeyUsed(EKeyEnter))

   823         {

   824             if (commandArranger->HandleEnterKeyL())

   825             {

   826                 return EKeyWasConsumed;

   827             }

   828         }

   829     }

   830 

   831     return EKeyWasNotConsumed;

   832 }

   833 

   834 TKeyResponse ASwtControlBase::HandleKeyL(const TKeyEvent& aKeyEvent,

   835         TEventCode aType, TBool aTraversalDoIt)

   836 {

   837     // Follows implementation of diagonal Keys. Native diagonal keys are in eSWT

   838     // replaced by two corresponding key events check if key is diagonal, if yes,

   839     // change the traversalDoIt state

   840     if (aKeyEvent.iCode == EKeyLeftUpArrow

   841             || aKeyEvent.iCode == EKeyRightUpArrow

   842             || aKeyEvent.iCode == EKeyLeftDownArrow

   843             || aKeyEvent.iCode == EKeyRightDownArrow)

   844     {

   845         aTraversalDoIt = EFalse;

   846     }

   847 

   848     switch (aKeyEvent.iCode)

   849     {

   850     case EKeyLeftUpArrow:

   851         return HandleDiagonalKeysL(aKeyEvent, aType, aTraversalDoIt, EKeyLeftArrow,

   852                                    EStdKeyLeftArrow, EKeyUpArrow, EStdKeyUpArrow);

   853     case EKeyLeftDownArrow:

   854         return HandleDiagonalKeysL(aKeyEvent, aType, aTraversalDoIt, EKeyLeftArrow,

   855                                    EStdKeyLeftArrow, EKeyDownArrow, EStdKeyDownArrow);

   856     case EKeyRightUpArrow:

   857         return HandleDiagonalKeysL(aKeyEvent, aType, aTraversalDoIt, EKeyRightArrow,

   858                                    EStdKeyRightArrow, EKeyUpArrow, EStdKeyUpArrow);

   859     case EKeyRightDownArrow:

   860         return HandleDiagonalKeysL(aKeyEvent, aType, aTraversalDoIt, EKeyRightArrow,

   861                                    EStdKeyRightArrow, EKeyDownArrow, EStdKeyDownArrow);

   862     }

   863 

   864     // Offer key event to command arranger first

   865     TKeyResponse keyResponse = OfferKeyEventToCommandAndMenuArrangersL(aKeyEvent, aType);

   866     if (keyResponse == EKeyWasConsumed)

   867     {

   868         iTraverse = EFalse;

   869         return EKeyWasConsumed;

   870     }

   871 

   872     // Traversal only on key event, not key down nor key up

   873     if (aType != EEventKey)

   874     {

   875         if (!iTraverse

   876 

   877 #ifndef RD_JAVA_S60_RELEASE_9_2

   878                 && !(AknLayoutUtils::MSKEnabled()

   879                      && aKeyEvent.iScanCode == EStdKeyDevice3

   880                      && iDisplay.CommandArranger()->IsDefaultCommandSet())

   881 #endif

   882            )

   883         {

   884             iDisplay.PostKeyEventL(*this, aKeyEvent, aType);

   885         }

   886         iTraverse = EFalse;

   887         return EKeyWasConsumed;

   888     }

   889 

   890     // In any case cancel the traverse state

   891     iTraverse = EFalse;

   892 

   893     TSwtTraversal detail(ESwtTraverseNone);

   894 

   895     const TInt modifiers = aKeyEvent.iModifiers & ECtrlFuncShiftMask;

   896 

   897     // If we press left or right arrow key and if there is a TabGroup displayed,

   898     // we let the TabGroup manage the keys.

   899     if (aTraversalDoIt && modifiers == 0

   900             && (aKeyEvent.iCode == EKeyRightArrow || aKeyEvent.iCode == EKeyLeftArrow))

   901     {

   902         keyResponse = OfferKeyEventToTabGroupL(aKeyEvent, aType);

   903         if (keyResponse == EKeyWasConsumed)

   904         {

   905             return EKeyWasConsumed;

   906         }

   907     }

   908 

   909     // Tab

   910     if (aKeyEvent.iCode == EKeyTab)

   911     {

   912         switch (modifiers)

   913         {

   914         case 0:                                // Tab

   915         case EModifierCtrl:                    // Ctrl+Tab

   916             detail = ESwtTraverseTabNext;

   917             break;

   918         case EModifierShift:                   // Shift+Tab

   919         case EModifierCtrl|EModifierShift:     // Ctrl+Shift+Tab

   920             detail = ESwtTraverseTabPrevious;

   921             break;

   922         default:

   923             break;

   924         }

   925     }

   926     else if (aKeyEvent.iCode == EKeyRightArrow ||

   927              aKeyEvent.iCode == EKeyDownArrow)

   928     {

   929         detail = ESwtTraverseArrowNext;

   930     }

   931     else if (aKeyEvent.iCode == EKeyLeftArrow ||

   932              aKeyEvent.iCode == EKeyUpArrow)

   933     {

   934         detail = ESwtTraverseArrowPrevious;

   935     }

   936 

   937     /*

   938      * These two conditions are because workaround in Text. We simulate

   939      * EEventKey from EEventKeyDown, so in this moment we haven't

   940      * aKeyEvent.iCode value, only iScanCode.

   941      */

   942     if (aType == EEventKey && aKeyEvent.iCode == 0)

   943     {

   944         if (aKeyEvent.iScanCode == EStdKeyLeftArrow)

   945         {

   946             detail = ESwtTraverseArrowPrevious;

   947         }

   948         if (aKeyEvent.iScanCode == EStdKeyRightArrow)

   949         {

   950             detail = ESwtTraverseArrowNext;

   951         }

   952     }

   953 

   954     // Return (only if there is a default button or a default command)

   955     if ((aKeyEvent.iCode==EKeyEnter || aKeyEvent.iCode==EKeyOK) && modifiers==0)

   956     {

   957         const MSwtShell& shell = GetShell();

   958         if ((!ButtonInterface() || ((Style() & KSwtStylePush) == 0))

   959                 && const_cast<MSwtShell&>(shell).Decorations()->DefaultButton())

   960         {

   961             detail = ESwtTraverseReturn;

   962         }

   963 

   964         if (shell.DefaultCommand())

   965         {

   966             detail = ESwtTraverseReturn;

   967         }

   968     }

   969 

   970     // Escape (only for non top-level Shells)

   971     if (aKeyEvent.iCode==EKeyEscape && modifiers==0)

   972     {

   973         if (GetShell().GetParentShell() != NULL)

   974             detail = ESwtTraverseEscape;

   975     }

   976 

   977     // Send event

   978     if (detail != ESwtTraverseNone)

   979     {

   980         iTraverse = aTraversalDoIt;

   981         MSwtComposite* parent = this->GetParent();

   982         if (parent)

   983         {

   984             // if the parent does not have a tablist.

   985             // it means the parent should not be used as a composite.

   986             // So don't post traverse event

   987             CSwtPeerArray* tabList = parent->GetTabListL();

   988             if (tabList)

   989             {

   990                 delete tabList;

   991                 tabList = NULL;

   992                 iDisplay.PostTraverseEventL(*this, detail, aKeyEvent, aType, aTraversalDoIt);

   993             }

   994         }

   995         else

   996         {

   997             iDisplay.PostTraverseEventL(*this, detail, aKeyEvent, aType, aTraversalDoIt);

   998         }

   999     }

  1000     else

  1001     {

  1002         iDisplay.PostKeyEventL(*this, aKeyEvent, aType);

  1003     }

  1004 

  1005     return EKeyWasConsumed;

  1006 }

  1007 

  1008 TKeyResponse ASwtControlBase::OfferKeyEventToTabGroupL(const TKeyEvent& aKeyEvent,TEventCode aType)

  1009 {

  1010     CEikStatusPane *sp = ((CAknAppUi*)iDisplay.CoeEnv()->EikAppUi())->StatusPane();

  1011     ASSERT(sp != NULL);

  1012     CAknNavigationControlContainer* naviCtrlCtnr = static_cast<CAknNavigationControlContainer*>

  1013             (sp->ControlL(TUid::Uid(EEikStatusPaneUidNavi)));

  1014     ASSERT(naviCtrlCtnr != NULL);

  1015     CAknNavigationDecorator* navi = naviCtrlCtnr->Top();

  1016     if (navi != NULL && navi->ControlType() == CAknNavigationDecorator::ETabGroup) // if there is a tab group

  1017     {

  1018         CAknTabGroup* tabGroup = static_cast<CAknTabGroup*>(navi->DecoratedControl());

  1019         if (tabGroup != NULL && tabGroup->OfferKeyEventL(aKeyEvent, aType) == EKeyWasConsumed)

  1020         {

  1021             TSwtTraversal detail(ESwtTraverseNone);

  1022             if (AknLayoutUtils::LayoutMirrored())

  1023             {

  1024                 detail = (aKeyEvent.iCode == EKeyRightArrow ?

  1025                           ESwtTraversePagePrevious : ESwtTraversePageNext);

  1026             }

  1027             else

  1028             {

  1029                 detail = (aKeyEvent.iCode == EKeyRightArrow ?

  1030                           ESwtTraversePageNext : ESwtTraversePagePrevious);

  1031             }

  1032             iDisplay.PostTraverseEventL(*this, detail, aKeyEvent, aType, ETrue);

  1033             // The tab has consumed the key event.

  1034             return EKeyWasConsumed;

  1035         }

  1036     }

  1037     return EKeyWasNotConsumed;

  1038 }

  1039 

  1040 EXPORT_C void ASwtControlBase::RegisterWithParentL()

  1041 {

  1042     if (iParent != NULL)

  1043     {

  1044         // eSWT hierarchy controls.

  1045         iParent->RegisterChildL(*this);

  1046     }

  1047 

  1048     // Set our DoNotDraw flag according to our parent flag

  1049     if (iParent != NULL)

  1050     {

  1051         UpdateDoNotDrawFlag();

  1052     }

  1053 }

  1054 

  1055 EXPORT_C TTypeUid::Ptr ASwtControlBase::SwtMopSupplyObject(TTypeUid aId)

  1056 {

  1057     // MAknsControlContext is ask.

  1058     if (aId.iUid == MAknsControlContext::ETypeId)

  1059     {

  1060         MAknsControlContext* bckgd = SwtMopSupplyCtrlContext();

  1061 

  1062         // If a parent have is own background context and the color background was not set on it.

  1063         // Return the Control Context of his background.

  1064         if (bckgd != NULL)

  1065         {

  1066             return MAknsControlContext::SupplyMopObject(aId, bckgd);

  1067         }

  1068     }

  1069 

  1070     // Else return Null

  1071     return TTypeUid::Null();

  1072 }

  1073 

  1074 MAknsControlContext* ASwtControlBase::SwtMopSupplyCtrlContext(TBool aBeginSearchToThis) const

  1075 {

  1076     MAknsControlContext* background = NULL;

  1077     if (aBeginSearchToThis)

  1078     {

  1079         background = FocusBackgroundNow();

  1080         if (background)

  1081         {

  1082             return background;

  1083         }

  1084     }

  1085 

  1086     MSwtComposite* parent = GetParent();

  1087     TInt policy = FocusBackgroundPolicy();

  1088     if (IsDefaultBackgroundUse())

  1089     {

  1090         background = aBeginSearchToThis ? GetControlContext() : NULL;

  1091         while (!background && parent)

  1092         {

  1093             // If policy is ENoFocusBackgroundInCaptionedControl, bypass the caption highlight.

  1094             if (policy == ENoFocusBackgroundInCaptionedControl

  1095                     && parent->Control()->CaptionedControlInterface())

  1096             {

  1097                 parent = parent->Control()->GetParent();

  1098                 ASSERT(parent);

  1099             }

  1100 

  1101             background = parent->Control()->GetControlContext();

  1102 

  1103             // If the parent is a Shell we stop on it.

  1104             if (parent->Control()->IsShell())

  1105             {

  1106                 parent = NULL;

  1107             }

  1108             else

  1109             {

  1110                 parent = parent->Control()->GetParent();

  1111             }

  1112         }

  1113     }

  1114 

  1115     return background;

  1116 }

  1117 

  1118 RRegion* ASwtControlBase::SetupChildClippingRegion(const MSwtComposite* aComposite,

  1119         CWindowGc& aGc,

  1120         const TRect& aDrawRect,

  1121         const TPoint& aOffset /*= TPoint( 0, 0 )*/) const

  1122 {

  1123     ASSERT(aComposite);

  1124 

  1125     TBool clippingRegionSet(EFalse);

  1126     RRegion* clippingRegion = NULL;

  1127     if (aComposite)

  1128     {

  1129         TInt childCount(0);

  1130         const RSwtControlArray* children = aComposite->Children();

  1131         if (children)

  1132         {

  1133             childCount = children->Count();

  1134         }