apply focus for tizen_2.1

Change-Id: Ie33ba09c108601b4803ac7ca4a9f928fe3df85fd

diff --git a/src/ui/controls/FUiCtrl_Button.cpp b/src/ui/controls/FUiCtrl_Button.cpp
index 942895d..834e568 100644 (file)
--- a/src/ui/controls/FUiCtrl_Button.cpp
+++ b/src/ui/controls/FUiCtrl_Button.cpp
@@ -313,6 +313,18 @@ _Button::OnTouchMoveHandled(const _Control& control)
        return;
 }
 
+bool
+_Button::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
+{
+       return __pButtonPresenter->OnKeyPressed(source, keyInfo);
+}
+
+bool
+_Button::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
+{
+       return __pButtonPresenter->OnKeyReleased(source, keyInfo);
+}
+
 void
 _Button::OnBoundsChanged(void)
 {
@@ -358,6 +370,62 @@ _Button::OnAncestorEnableStateChanged(const _Control& control)
        return;
 }
 
+void
+_Button::OnDrawFocus(void)
+{
+       __pButtonPresenter->OnDrawFocus();
+
+       return;
+}
+
+void
+_Button::OnChildControlFocusMoved(const _Control& control)
+{
+       __pButtonPresenter->OnChildControlFocusMoved(control);
+
+       return;
+}
+
+bool
+_Button::IsChildControlFocusManage(void) const
+{
+       __pButtonPresenter->IsChildControlFocusManage();
+
+       return true;
+}
+
+void
+_Button::OnFocusableStateChanged(bool focusalbeState)
+{
+       __pButtonPresenter->OnFocusableStateChanged(focusalbeState);
+
+       return;
+}
+
+void
+_Button::OnFocusModeStateChanged(void)
+{
+       __pButtonPresenter->OnFocusModeStateChanged();
+
+       return;
+}
+
+bool
+_Button::OnFocusGained(const _Control& source)
+{
+       __pButtonPresenter->OnFocusGained(source);
+
+       return false;
+}
+
+bool
+_Button::OnFocusLost(const _Control& source)
+{
+       __pButtonPresenter->OnFocusLost(source);
+
+       return true;
+}
+
 result
 _Button::SetText(const String& text)
 {

diff --git a/src/ui/controls/FUiCtrl_ButtonPresenter.cpp b/src/ui/controls/FUiCtrl_ButtonPresenter.cpp
index c16e2aa..ef50f8b 100644 (file)
--- a/src/ui/controls/FUiCtrl_ButtonPresenter.cpp
+++ b/src/ui/controls/FUiCtrl_ButtonPresenter.cpp
@@ -30,7 +30,6 @@
 #include "FUiAnim_VisualElement.h"
 #include "FUiCtrl_ButtonPresenter.h"
 #include "FUiCtrl_ButtonModel.h"
-#include "FUiCtrl_Button.h"
 
 using namespace Tizen::Base;
 using namespace Tizen::Graphics;
@@ -49,6 +48,7 @@ _ButtonPresenter::_ButtonPresenter(void)
        , __pBase(null)
        , __fontStyle(0)
        , __fontSize(0.0f)
+       , __focusPrevStatus(_BUTTON_STATUS_NORMAL)
 {
 
 }
@@ -293,7 +293,8 @@ _ButtonPresenter::Draw(void)
        DrawBitmap();
        DrawText();
 
-       if ((status == _BUTTON_STATUS_SELECTED || (status == _BUTTON_STATUS_PRESSED && prevStatus == _BUTTON_STATUS_SELECTED))
+       if ((status == _BUTTON_STATUS_SELECTED || (status == _BUTTON_STATUS_PRESSED && prevStatus == _BUTTON_STATUS_SELECTED)
+                       || (status == _BUTTON_STATUS_HIGHLIGHTED && prevStatus == _BUTTON_STATUS_SELECTED))
                        && __pButton->GetToolbarItemBackgroundBitmap(_BUTTON_STATUS_SELECTED) == null)
        {
                DrawToolbarSelectedBitmap();
@@ -307,9 +308,11 @@ _ButtonPresenter::DrawBackground(void)
 {
        Canvas* pCanvas = null;
 
-       Bitmap* pReplacementColorBackgroundBitmap = null;
        Bitmap* pBackgroundBitmap = null;
+       Bitmap* pReplacementColorBackgroundBitmap = null;
        Bitmap* pBackgroundEffectBitmap = null;
+       Bitmap* pHighlightedBackgroundBitmap = null;
+       Bitmap* pHighlightedReplacementColorBackgroundBitmap = null;
        Color bgColor = __pButton->GetBackgroundColor();
        String imagePath = L"";
 
@@ -325,8 +328,18 @@ _ButtonPresenter::DrawBackground(void)
 
        if (__pButton->IsUserBackgroundBitmap(status))
        {
+               if (status == _BUTTON_STATUS_HIGHLIGHTED)
+               {
+                       pBackgroundBitmap = __pButton->GetBackgroundBitmap(_BUTTON_STATUS_NORMAL);
+                       pBackgroundEffectBitmap = __pButton->GetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL);
+
+                       pHighlightedBackgroundBitmap = __pButton->GetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED);
+               }
+               else
+               {
                pBackgroundBitmap = __pButton->GetBackgroundBitmap(status);
                pBackgroundEffectBitmap = __pButton->GetBackgroundEffectBitmap(status);
+               }
 
                if (pBackgroundBitmap)
                {
@@ -345,6 +358,8 @@ _ButtonPresenter::DrawBackground(void)
                        }
                        else
                        {
+                               __pBase->SetImageSource(L"");
+
                                pCanvas = __pButton->GetCanvasN();
                                if (pCanvas == null)
                                {
@@ -407,9 +422,24 @@ _ButtonPresenter::DrawBackground(void)
                                        }
                                }
                        }
+
+                       if (pHighlightedBackgroundBitmap)
+                       {
+                               if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pHighlightedBackgroundBitmap))
+                               {
+                                       pCanvas->DrawNinePatchedBitmap(bounds, *pHighlightedBackgroundBitmap);
+                               }
+                               else
+                               {
+                                       pCanvas->DrawBitmap(bounds, *pHighlightedBackgroundBitmap,
+                                                       FloatRectangle(0.0f, 0.0f, pHighlightedBackgroundBitmap->GetWidthF(), pHighlightedBackgroundBitmap->GetHeightF()));
+                               }
+                       }
                }
                else // pBackgroundBitmap is null
                {
+                       __pBase->SetImageSource(L"");
+
                        pCanvas = __pButton->GetCanvasN();
                        if (pCanvas == null)
                        {
@@ -445,6 +475,8 @@ _ButtonPresenter::DrawBackground(void)
        }
        else // nobody set bitmap (default bitmap draw) // if (__pButton->IsUserBackgroundBitmap(status))
        {
+               __pBase->SetImageSource(L"");
+
                pCanvas = __pButton->GetCanvasN();
                if (pCanvas == null)
                {
@@ -466,6 +498,23 @@ _ButtonPresenter::DrawBackground(void)
                        pReplacementColorBackgroundBitmap =
                                        _BitmapImpl::GetColorReplacedBitmapN(*pBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA), __pButton->GetColor(_BUTTON_STATUS_DISABLED));
                }
+               else if (status == _BUTTON_STATUS_HIGHLIGHTED)
+               {
+                       pBackgroundBitmap = __pButton->GetBackgroundBitmap(_BUTTON_STATUS_NORMAL);
+
+                       if(!__pButton->IsUserBackgroundBitmap(_BUTTON_STATUS_NORMAL))
+                       {
+                               pBackgroundEffectBitmap = __pButton->GetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL);
+                       }
+
+                       pReplacementColorBackgroundBitmap =
+                                       _BitmapImpl::GetColorReplacedBitmapN(*pBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA), __pButton->GetColor(_BUTTON_STATUS_NORMAL));
+
+                       pHighlightedBackgroundBitmap = __pButton->GetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED);
+
+                       pHighlightedReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pHighlightedBackgroundBitmap,
+                                       Color::GetColor(COLOR_ID_MAGENTA), __pButton->GetColor(_BUTTON_STATUS_HIGHLIGHTED));
+               }
                else
                {
                        pBackgroundBitmap = __pButton->GetBackgroundBitmap(status);
@@ -548,6 +597,19 @@ _ButtonPresenter::DrawBackground(void)
                                }
                        }
                }
+
+               if (pHighlightedReplacementColorBackgroundBitmap)
+               {
+                       if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pHighlightedReplacementColorBackgroundBitmap))
+                       {
+                               pCanvas->DrawNinePatchedBitmap(bounds, *pHighlightedReplacementColorBackgroundBitmap);
+                       }
+                       else
+                       {
+                               pCanvas->DrawBitmap(bounds, *pHighlightedReplacementColorBackgroundBitmap,
+                                               FloatRectangle(0.0f, 0.0f, pHighlightedReplacementColorBackgroundBitmap->GetWidthF(), pHighlightedReplacementColorBackgroundBitmap->GetHeightF()));
+                       }
+               }
        }
 
        if (!__pButton->IsUserBackgroundBitmap(status))
@@ -583,6 +645,8 @@ _ButtonPresenter::DrawToolbarItemBackground(void)
 
        if (pToolbarItemBackgroundBitmap)
        {
+               __pBase->SetImageSource(L"");
+
                Canvas* pCanvas = __pButton->GetCanvasN();
 
                if (pCanvas == null)
@@ -636,6 +700,8 @@ _ButtonPresenter::DrawBitmap(void)
 
        if (pBitmap)
        {
+               __pBase->SetImageSource(L"");
+
                pCanvas = __pButton->GetCanvasN();
 
                if (pCanvas == null)
@@ -667,6 +733,8 @@ _ButtonPresenter::DrawBitmap(void)
        }
        else if (pNormalBitmap)
        {
+               __pBase->SetImageSource(L"");
+
                pCanvas = __pButton->GetCanvasN();
 
                if (pCanvas == null)
@@ -718,6 +786,8 @@ _ButtonPresenter::DrawText(void)
        float rightTouchMargin = __pButton->GetRightTouchMarginF();
        float bottomTouchMargin = __pButton->GetBottomTouchMarginF();
 
+       __pBase->SetImageSource(L"");
+
        Canvas* pCanvas = __pButton->GetCanvasN();
        if (pCanvas == null)
        {
@@ -809,6 +879,8 @@ _ButtonPresenter::DrawToolbarSelectedBitmap(void)
 
        if (pToolbarSelectedBitmap)
        {
+               __pBase->SetImageSource(L"");
+
                Canvas* pCanvas = __pButton->GetCanvasN();
 
                if (pCanvas == null)
@@ -1000,6 +1072,26 @@ _ButtonPresenter::OnTouchMoveHandled(const _Control& control)
        return;
 }
 
+bool
+_ButtonPresenter::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
+{
+       return false;
+}
+
+bool
+_ButtonPresenter::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
+{
+       _KeyCode keyCode = keyInfo.GetKeyCode();
+
+       if (keyCode == _KEY_ENTER)
+       {
+               __pButton->SetButtonStatus(_BUTTON_STATUS_SELECTED);
+               __pButton->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+       }
+
+       return false;
+}
+
 void
 _ButtonPresenter::OnAncestorEnableStateChanged(const _Control& control)
 {
@@ -1017,6 +1109,58 @@ _ButtonPresenter::OnAncestorEnableStateChanged(const _Control& control)
        return;
 }
 
+void
+_ButtonPresenter::OnDrawFocus(void)
+{
+       return;
+}
+
+void
+_ButtonPresenter::OnChildControlFocusMoved(const _Control& control)
+{
+       return;
+}
+
+bool
+_ButtonPresenter::IsChildControlFocusManage(void) const
+{
+       return true;
+}
+
+void
+_ButtonPresenter::OnFocusableStateChanged(bool focusalbeState)
+{
+       return;
+}
+
+void
+_ButtonPresenter::OnFocusModeStateChanged(void)
+{
+       __pButton->SetButtonStatus(__focusPrevStatus);
+       __pButton->Invalidate();
+
+       return;
+}
+
+bool
+_ButtonPresenter::OnFocusGained(const _Control& source)
+{
+       __focusPrevStatus = __pButton->GetButtonStatus();
+       __pButton->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+       __pButton->Invalidate();
+
+       return true;
+}
+
+bool
+_ButtonPresenter::OnFocusLost(const _Control& source)
+{
+       __pButton->SetButtonStatus(__focusPrevStatus);
+       __pButton->Invalidate();
+
+       return true;
+}
+
 bool
 _ButtonPresenter::IsEnabledStateChanged(void)
 {

diff --git a/src/ui/controls/FUiCtrl_CheckButton.cpp b/src/ui/controls/FUiCtrl_CheckButton.cpp
index 7c53e19..1983e28 100644 (file)
--- a/src/ui/controls/FUiCtrl_CheckButton.cpp
+++ b/src/ui/controls/FUiCtrl_CheckButton.cpp
@@ -569,6 +569,18 @@ _CheckButton::OnTouchMoveHandled(const _Control& control)
        return;
 }
 
+bool
+_CheckButton::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
+{
+       return __pCheckButtonPresenter->OnKeyPressed(source, keyInfo);
+}
+
+bool
+_CheckButton::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
+{
+       return __pCheckButtonPresenter->OnKeyReleased(source, keyInfo);
+}
+
 void
 _CheckButton::OnBoundsChanged(void)
 {
@@ -608,6 +620,62 @@ _CheckButton::OnFontInfoRequested(unsigned long& style, int& size)
 }
 
 void
+_CheckButton::OnDrawFocus(void)
+{
+       __pCheckButtonPresenter->OnDrawFocus();
+
+       return;
+}
+
+void
+_CheckButton::OnChildControlFocusMoved(const _Control& control)
+{
+       __pCheckButtonPresenter->OnChildControlFocusMoved(control);
+
+       return;
+}
+
+bool
+_CheckButton::IsChildControlFocusManage(void) const
+{
+       __pCheckButtonPresenter->IsChildControlFocusManage();
+
+       return true;
+}
+
+void
+_CheckButton::OnFocusableStateChanged(bool focusalbeState)
+{
+       __pCheckButtonPresenter->OnFocusableStateChanged(focusalbeState);
+
+       return;
+}
+
+void
+_CheckButton::OnFocusModeStateChanged(void)
+{
+       __pCheckButtonPresenter->OnFocusModeStateChanged();
+
+       return;
+}
+
+bool
+_CheckButton::OnFocusGained(const _Control& source)
+{
+       __pCheckButtonPresenter->OnFocusGained(source);
+
+       return true;
+}
+
+bool
+_CheckButton::OnFocusLost(const _Control& source)
+{
+       __pCheckButtonPresenter->OnFocusLost(source);
+
+       return true;
+}
+
+void
 _CheckButton::SendTouchReleasedEvent(const _Control& control)
 {
        const _Control* pDestination = dynamic_cast <const _Control*>(&control);

diff --git a/src/ui/controls/FUiCtrl_CheckButtonPresenter.cpp b/src/ui/controls/FUiCtrl_CheckButtonPresenter.cpp
index 0663d29..900935d 100644 (file)
--- a/src/ui/controls/FUiCtrl_CheckButtonPresenter.cpp
+++ b/src/ui/controls/FUiCtrl_CheckButtonPresenter.cpp
@@ -32,7 +32,6 @@
 #include "FUiAnim_VisualElement.h"
 #include "FUiCtrl_CheckButtonPresenter.h"
 #include "FUiCtrl_CheckButtonModel.h"
-#include "FUiCtrl_CheckButton.h"
 
 using namespace Tizen::Base;
 using namespace Tizen::Graphics;
@@ -63,6 +62,7 @@ _CheckButtonPresenter::_CheckButtonPresenter(void)
        , __onOffHandlerPosition(0.0f)
        , __onOffHandlerPressed(false)
        , __onOffHandlerMoved(false)
+       , __focusPrevStatus(_CHECK_BUTTON_STATUS_NORMAL)
 {
 
 }
@@ -220,10 +220,11 @@ _CheckButtonPresenter::DrawBackground(void)
                return;
        }
 
+       Bitmap* pBackgroundBitmap = null;
        Bitmap* pReplacementColorBackgroundBitmap = null;
-       Bitmap* pBackgroundBitmap = __pCheckButton->GetBackgroundBitmap(__pCheckButton->GetGroupStyle(), __pCheckButton->GetCheckButtonStatus());
-
 
+       Bitmap* pHighlightedBackgroundBitmap = null;
+       Bitmap* pHighlightedReplacementColorBackgroundBitmap = null;
 
        FloatDimension minDimension(0.0f, 0.0f);
        FloatDimension minDimensionWithAnnex(0.0f, 0.0f);
@@ -275,6 +276,8 @@ _CheckButtonPresenter::DrawBackground(void)
                }
                else
                {
+                       pBackgroundBitmap = __pCheckButton->GetBackgroundBitmap(__pCheckButton->GetGroupStyle(), _CHECK_BUTTON_STATUS_NORMAL);
+
                        if (pBackgroundBitmap && _BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundBitmap))
                        {
                                pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA),
@@ -331,6 +334,8 @@ _CheckButtonPresenter::DrawBackground(void)
                }
                else
                {
+                       pBackgroundBitmap = __pCheckButton->GetBackgroundBitmap(__pCheckButton->GetGroupStyle(), _CHECK_BUTTON_STATUS_DISABLED);
+
                        if (pBackgroundBitmap && _BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundBitmap))
                        {
                                pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA),
@@ -387,6 +392,8 @@ _CheckButtonPresenter::DrawBackground(void)
                }
                else
                {
+                       pBackgroundBitmap = __pCheckButton->GetBackgroundBitmap(__pCheckButton->GetGroupStyle(), _CHECK_BUTTON_STATUS_PRESSED);
+
                        if (pBackgroundBitmap && _BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundBitmap))
                        {
                                pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA),
@@ -443,10 +450,12 @@ _CheckButtonPresenter::DrawBackground(void)
                }
                else
                {
+                       pBackgroundBitmap = __pCheckButton->GetBackgroundBitmap(__pCheckButton->GetGroupStyle(), _CHECK_BUTTON_STATUS_NORMAL);
+
                        if (pBackgroundBitmap && _BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundBitmap))
                        {
                                pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA),
-                                               __pCheckButton->GetColor(_CHECK_BUTTON_STATUS_HIGHLIGHTED));
+                                               __pCheckButton->GetColor(_CHECK_BUTTON_STATUS_NORMAL));
                                if (pReplacementColorBackgroundBitmap)
                                {
                                        pCanvas->DrawNinePatchedBitmap(bounds, *pReplacementColorBackgroundBitmap);
@@ -488,6 +497,24 @@ _CheckButtonPresenter::DrawBackground(void)
                                        pCanvas->DrawBitmap(FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height), *pBackgroundBitmap);
                                }
                        }
+
+                       pHighlightedBackgroundBitmap = __pCheckButton->GetBackgroundBitmap(__pCheckButton->GetGroupStyle(), _CHECK_BUTTON_STATUS_HIGHLIGHTED);
+
+                       pHighlightedReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pHighlightedBackgroundBitmap,
+                                       Color::GetColor(COLOR_ID_MAGENTA), __pCheckButton->GetColor(_CHECK_BUTTON_STATUS_HIGHLIGHTED));
+
+                       if (pHighlightedReplacementColorBackgroundBitmap)
+                       {
+                               if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pHighlightedReplacementColorBackgroundBitmap))
+                               {
+                                       pCanvas->DrawNinePatchedBitmap(bounds, *pHighlightedReplacementColorBackgroundBitmap);
+                               }
+                               else
+                               {
+                                       pCanvas->DrawBitmap(bounds, *pHighlightedReplacementColorBackgroundBitmap,
+                                                       FloatRectangle(0.0f, 0.0f, pHighlightedReplacementColorBackgroundBitmap->GetWidthF(), pHighlightedReplacementColorBackgroundBitmap->GetHeightF()));
+                               }
+                       }
                }
        }
        else
@@ -499,6 +526,8 @@ _CheckButtonPresenter::DrawBackground(void)
                }
                else
                {
+                       pBackgroundBitmap = __pCheckButton->GetBackgroundBitmap(__pCheckButton->GetGroupStyle(), __pCheckButton->GetCheckButtonStatus());
+
                        if (pBackgroundBitmap && _BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundBitmap))
                        {
                                pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA),
@@ -753,21 +782,33 @@ _CheckButtonPresenter::DrawCheckBitmap(void)
                }
                else if (checkStatus == _CHECK_BUTTON_STATUS_HIGHLIGHTED)
                {
+                       Bitmap* pMarkBgNormalBitmap = __pCheckButton->GetMarkBgBitmap(_CHECK_BUTTON_STATUS_NORMAL);
                        Bitmap* pMarkBgHighlightedBitmap = __pCheckButton->GetMarkBgBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
 
+                       if (pMarkBgNormalBitmap)
+                       {
+                               pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pMarkBgNormalBitmap);
+                       }
+
                        if (pMarkBgHighlightedBitmap)
                        {
-                               pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pMarkBgHighlightedBitmap);
+                               pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pMarkBgHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedHighlightedBackgroundColor);
+                       }
+
+                       if (pReplacementColorBackgroundBitmap)
+                       {
+                               pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pReplacementColorBackgroundBitmap);
                        }
 
                        if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
                        {
+                               Bitmap* pCircleNormalBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_NORMAL);
                                Bitmap* pCircleHighlightedBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
                                Bitmap* pDetailedRightHighlightedBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
 
-                               if (pCircleHighlightedBitmap)
+                               if (pCircleNormalBitmap)
                                {
-                                       pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedHighlightedBackgroundColor);
+                                       pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedNormalBackgroundColor);
                                }
 
                                if (pDetailedRightHighlightedBitmap)
@@ -800,6 +841,16 @@ _CheckButtonPresenter::DrawCheckBitmap(void)
                                                pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCirclePressedEffectBitmap);
                                        }
                                }
+
+                               if (pCircleHighlightedBitmap)
+                               {
+                                       pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedHighlightedBackgroundColor);
+                               }
+
+                               if (pReplacementColorBackgroundBitmap)
+                               {
+                                       pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorBackgroundBitmap);
+                               }
                        }
                }
                else if (checkStatus == _CHECK_BUTTON_STATUS_SELECTED)
@@ -994,12 +1045,13 @@ _CheckButtonPresenter::DrawCheckBitmap(void)
                {
                        if (checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
                        {
+                               Bitmap* pCircleNormalBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_NORMAL);
                                Bitmap* pCircleHighlightedBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
                                Bitmap* pDetailedRightHighlightedBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
 
-                               if (pCircleHighlightedBitmap)
+                               if (pCircleNormalBitmap)
                                {
-                                       pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedHighlightedBackgroundColor);
+                                       pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedNormalBackgroundColor);
                                }
 
                                if (pDetailedRightHighlightedBitmap)
@@ -1032,6 +1084,16 @@ _CheckButtonPresenter::DrawCheckBitmap(void)
                                                pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCirclePressedEffectBitmap);
                                        }
                                }
+
+                               if (pCircleHighlightedBitmap)
+                               {
+                                       pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedHighlightedBackgroundColor);
+                               }
+
+                               if (pReplacementColorBackgroundBitmap)
+                               {
+                                       pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorBackgroundBitmap);
+                               }
                        }
                }
                else if (checkStatus == _CHECK_BUTTON_STATUS_SELECTED)
@@ -1133,11 +1195,12 @@ _CheckButtonPresenter::DrawCheckBitmap(void)
                }
                else if (checkStatus == _CHECK_BUTTON_STATUS_HIGHLIGHTED)
                {
+                       Bitmap* pOnOffBgNormalBitmap = __pCheckButton->GetOnOffBgBitmap(_CHECK_BUTTON_STATUS_NORMAL);
                        Bitmap* pOnOffBgHighlightedBitmap = __pCheckButton->GetOnOffBgBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
 
-                       if (pOnOffBgHighlightedBitmap)
+                       if (pOnOffBgNormalBitmap)
                        {
-                               pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffBgHighlightedBitmap);
+                               pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffBgNormalBitmap);
                        }
 
                        Bitmap* pOnOffHighlightedBitmap = __pCheckButton->GetOnOffBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
@@ -1146,6 +1209,16 @@ _CheckButtonPresenter::DrawCheckBitmap(void)
                        {
                                pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffHighlightedBitmap);
                        }
+
+                       if (pOnOffBgHighlightedBitmap)
+                       {
+                               pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pOnOffBgHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedHighlightedBackgroundColor);
+                       }
+
+                       if (pReplacementColorBackgroundBitmap)
+                       {
+                               pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pReplacementColorBackgroundBitmap);
+                       }
                }
                else if (checkStatus == _CHECK_BUTTON_STATUS_SELECTED)
                {
@@ -1660,6 +1733,11 @@ _CheckButtonPresenter::DrawOnOffSlidingHandler(float handlerPosition)
                return;
        }
 
+       Bitmap* pReplacementColorBackgroundBitmap = null;
+
+       Color detailedHighlightedBackgroundColor;
+       GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_BG_HIGHLIGHTED, detailedHighlightedBackgroundColor);
+
        float handlerMargin = 0.0f;
        float handlerWidth = 0.0f;
 
@@ -1737,11 +1815,24 @@ _CheckButtonPresenter::DrawOnOffSlidingHandler(float handlerPosition)
                                pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingOffHighlightedBitmap);
                        }
 
+                       Bitmap* pOnOffSlidingHandlerNormalBitmap = __pCheckButton->GetOnOffSlidingHandlerBitmap(_CHECK_BUTTON_STATUS_NORMAL);
+
+                       if (pOnOffSlidingHandlerNormalBitmap)
+                       {
+                               pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingHandlerNormalBitmap);
+                       }
+
                        Bitmap* pOnOffSlidingHandlerHighlightedBitmap = __pCheckButton->GetOnOffSlidingHandlerBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
 
                        if (pOnOffSlidingHandlerHighlightedBitmap)
                        {
-                               pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingHandlerHighlightedBitmap);
+                               pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pOnOffSlidingHandlerHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA),
+                                               detailedHighlightedBackgroundColor);
+                       }
+
+                       if (pReplacementColorBackgroundBitmap)
+                       {
+                               pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pReplacementColorBackgroundBitmap);
                        }
                }
                else if (checkStatus == _CHECK_BUTTON_STATUS_SELECTED)
@@ -1820,11 +1911,24 @@ _CheckButtonPresenter::DrawOnOffSlidingHandler(float handlerPosition)
                                pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingOnHighlightedBitmap);
                        }
 
+                       Bitmap* pOnOffSlidingHandlerNormalBitmap = __pCheckButton->GetOnOffSlidingHandlerBitmap(_CHECK_BUTTON_STATUS_NORMAL);
+
+                       if (pOnOffSlidingHandlerNormalBitmap)
+                       {
+                               pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingHandlerNormalBitmap);
+                       }
+
                        Bitmap* pOnOffSlidingHandlerHighlightedBitmap = __pCheckButton->GetOnOffSlidingHandlerBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
 
                        if (pOnOffSlidingHandlerHighlightedBitmap)
                        {
-                               pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingHandlerHighlightedBitmap);
+                               pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pOnOffSlidingHandlerHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA),
+                                               detailedHighlightedBackgroundColor);
+                       }
+
+                       if (pReplacementColorBackgroundBitmap)
+                       {
+                               pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pReplacementColorBackgroundBitmap);
                        }
                }
                else if (checkStatus == _CHECK_BUTTON_STATUS_SELECTED)
@@ -1846,6 +1950,7 @@ _CheckButtonPresenter::DrawOnOffSlidingHandler(float handlerPosition)
        }
 
        delete pCanvas;
+       delete pReplacementColorBackgroundBitmap;
 
        return;
 }
@@ -1880,6 +1985,52 @@ _CheckButtonPresenter::OnTouchMoveHandled(const _Control& control)
 }
 
 bool
+_CheckButtonPresenter::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
+{
+       return false;
+}
+
+bool
+_CheckButtonPresenter::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
+{
+       _KeyCode keyCode = keyInfo.GetKeyCode();
+
+       if (keyCode == _KEY_ENTER)
+       {
+               CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
+
+               if (checkStyle == CHECK_BUTTON_STYLE_MARK || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON
+                               || checkStyle == CHECK_BUTTON_STYLE_RADIO || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
+               {
+                       StartCheckAnimationTimer();
+                       __ratio = 0;
+               }
+
+               __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
+               __pCheckButton->Invalidate();
+
+               PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP);
+
+               __pCheckButton->FireActionEvent();
+
+               if (__pCheckButton->GetRadioGroup() != null)
+               {
+                       __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
+               }
+
+               if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING)
+               {
+                       AdjustHandlerPosition();
+
+                       __onOffHandlerPressed = false;
+                       __onOffHandlerMoved = false;
+               }
+       }
+
+       return false;
+}
+
+bool
 _CheckButtonPresenter::IsEnabledStateChanged(void)
 {
        bool __currentEnabledState = __pCheckButton->GetEnableState();
@@ -2250,6 +2401,57 @@ _CheckButtonPresenter::OnTimerExpired(Timer& timer)
 }
 
 void
+_CheckButtonPresenter::OnDrawFocus(void)
+{
+       return;
+}
+
+void
+_CheckButtonPresenter::OnChildControlFocusMoved(const _Control& control)
+{
+       return;
+}
+
+bool
+_CheckButtonPresenter::IsChildControlFocusManage(void) const
+{
+       return true;
+}
+
+void
+_CheckButtonPresenter::OnFocusableStateChanged(bool focusalbeState)
+{
+       return;
+}
+
+void
+_CheckButtonPresenter::OnFocusModeStateChanged(void)
+{
+       __pCheckButton->SetCheckButtonStatus(__focusPrevStatus);
+       __pCheckButton->Invalidate();
+
+       return;
+}
+
+bool
+_CheckButtonPresenter::OnFocusGained(const _Control& source)
+{
+       __focusPrevStatus = __pCheckButton->GetCheckButtonStatus();
+       __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
+       __pCheckButton->Invalidate();
+
+       return true;
+}
+
+bool
+_CheckButtonPresenter::OnFocusLost(const _Control& source)
+{
+       __pCheckButton->SetCheckButtonStatus(__focusPrevStatus);
+       __pCheckButton->Invalidate();
+
+       return true;
+}
+void
 _CheckButtonPresenter::DrawMarkAnimation(void)
 {
        Canvas* pCanvas = __pCheckButton->GetCanvasN();

diff --git a/src/ui/controls/FUiCtrl_Toolbar.cpp b/src/ui/controls/FUiCtrl_Toolbar.cpp
index 63657e7..bd20807 100644 (file)
--- a/src/ui/controls/FUiCtrl_Toolbar.cpp
+++ b/src/ui/controls/FUiCtrl_Toolbar.cpp
@@ -119,6 +119,7 @@ _Toolbar::_Toolbar(void)
        , __style(TOOLBAR_TITLE)
        , __transparent(false)
        , __isUserBackgroundBitmap(false)
+       , __highlightedItemIndex(0)
        , __titleTextArea(FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f))
        , __itemArea(FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f))
        , __pTitleTextElement(null)
@@ -2317,6 +2318,15 @@ _Toolbar::SetItemSelected(int itemIndex, bool fire, bool adjust)
 
        result r = E_SUCCESS;
 
+       if (__highlightedItemIndex < __itemCount)
+       {
+               if (itemIndex != -1 && __pItems.at(__highlightedItemIndex) != null)
+               {
+                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                       __pItems.at(__highlightedItemIndex)->Draw();
+               }
+       }
+
        int currentSelectedItemIndex = 0;
        currentSelectedItemIndex = GetSelectedItemIndex();
 
@@ -2330,6 +2340,9 @@ _Toolbar::SetItemSelected(int itemIndex, bool fire, bool adjust)
                }
                __pItems.at(itemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, fire);
                __pItems.at(itemIndex)->Draw();
+
+               __highlightedItemIndex = itemIndex;
+
                _AccessibilityElement* pElement = __pItems.at(currentSelectedItemIndex)->GetAccessibilityContainer()->GetChildElement(0);
                if (pElement)
                {
@@ -2354,6 +2367,9 @@ _Toolbar::SetItemSelected(int itemIndex, bool fire, bool adjust)
                        PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP);
                }
                __pItems.at(itemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, fire);
+
+               __highlightedItemIndex = itemIndex;
+
                _AccessibilityElement* pElement = __pItems.at(itemIndex)->GetAccessibilityContainer()->GetChildElement(0);
                if (pElement)
                {
@@ -2439,6 +2455,8 @@ _Toolbar::SetStyle(ToolbarStyle style)
 
        __descriptionText = L"";
 
+       __highlightedItemIndex = 0;
+
        if (__style == TOOLBAR_TITLE || __style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
        {
                if(__pTitleTextElement)
@@ -2842,146 +2860,1403 @@ _Toolbar::AddAccessibilityElement(ToolbarButton position, _Button* pButton)
                pButtonElement = pButtonContainer->GetChildElement(L"ButtonText");
        }
 
-       if(pButtonElement)
+       if(pButtonElement)
+       {
+               pButtonElement->SetName(name);
+
+               if (position == BACK_BUTTON)
+               {
+                       pButtonElement->SetLabel("Back");
+                       pButtonElement->SetTrait("Button");
+               }
+               else
+               {
+                       pButtonElement->SetTrait(L"Button");
+               }
+               FloatRectangle floatRect = GetButtonBoundsF(position);
+               pButtonElement->SetBounds(FloatRectangle(0,floatRect.y, pButton->GetBoundsF().width, floatRect.height));
+       }
+}
+
+void
+_Toolbar::AddAccessibilityElement(_Button* pButton)
+{
+       _AccessibilityContainer* pContainer = GetAccessibilityContainer();
+       if(pContainer == null)
+       {
+               return;
+       }
+
+       int priorty = 0;
+       if(__header == true)
+       {
+               priorty = ACCESSIBILITY_PRIORITY_TOP;
+       }
+       else
+       {
+               priorty = ACCESSIBILITY_PRIORITY_BOTTOM;
+       }
+       pContainer->SetPriority(priorty);
+
+       ToolbarStyle style = GetStyle();
+       String trait = L"";
+       String name = L"";
+       switch (style)
+       {
+               case TOOLBAR_HEADER_SEGMENTED:
+                       //fall through
+               case TOOLBAR_HEADER_SEGMENTED_WITH_TITLE:
+                       //fall through
+               case TOOLBAR_SEGMENTED:
+                       name = L"Segment" + Integer::ToString(__itemCount);
+                       name.Append(L"Text");
+                       trait = L"Segmented control";
+                       break;
+               case TOOLBAR_TAB_WITH_TITLE:
+                       //fall through
+               case TOOLBAR_TAB:
+                       name = L"Tab" + Integer::ToString(__itemCount);
+                       name.Append(L"Text");
+                       trait = L"Tab";
+                       break;
+               default:
+                       name = L"Button" + Integer::ToString(__itemCount);
+                       name.Append(L"Text");
+                       trait = L"Button";
+                       break;
+       }
+
+       if (pButton != null)
+       {
+               _AccessibilityElement* pElement = null;
+               _AccessibilityContainer* pButtonContainer = pButton->GetAccessibilityContainer();
+
+               if (pButtonContainer)
+               {
+                       pButtonContainer->SetPriority(priorty);
+                       pContainer->AddChildContainer(*pButtonContainer);
+                       pElement = pButtonContainer->GetChildElement(L"ButtonText");
+               }
+
+               if(pElement)
+               {
+                       pElement->SetName(name);
+                       pElement->SetTrait(trait);
+                       if(style == TOOLBAR_HEADER_SEGMENTED || style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE
+                               || style == TOOLBAR_SEGMENTED || style == TOOLBAR_TAB_WITH_TITLE
+                               || style == TOOLBAR_TAB)
+                       {
+                               pElement->SetHint(L"Double tap to move to contents");
+                               pButton->GetAccessibilityContainer()->AddListener(*__pAccessibilityListener);
+                       }
+               }
+       }
+
+       return;
+}
+
+void
+_Toolbar::OnBoundsChanged(void)
+{
+       RearrangeItems();
+
+       if(__pTitleTextElement)
+       {
+               if( __descriptionText.IsEmpty())
+               {
+                       __pTitleTextElement->SetBounds(FloatRectangle(__pToolbarPresenter->GetTitleTextBoundsF()));
+               }
+               else
+               {
+                       FloatRectangle descriptionBounds = __pToolbarPresenter->GetDescriptionBoundsF();
+                       FloatRectangle titleBounds = __pToolbarPresenter->GetTitleTextBoundsF();
+
+                       __pTitleTextElement->SetBounds(FloatRectangle(titleBounds.x, titleBounds.y, titleBounds.width, titleBounds.height + descriptionBounds.height));
+               }
+       }
+       return;
+}
+
+void
+_Toolbar::OnFontChanged(Font* pFont)
+{
+       __pToolbarPresenter->OnFontChanged(pFont);
+
+       return;
+}
+
+void
+_Toolbar::OnFontInfoRequested(unsigned long& style, int& size)
+{
+       __pToolbarPresenter->OnFontInfoRequested(style, size);
+
+       return;
+}
+
+void
+_Toolbar::OnAncestorVisibleStateChanged(const _Control& control)
+{
+       __pToolbarPresenter->OnAncestorVisibleStateChanged(control);
+
+       _Control::OnAncestorVisibleStateChanged(control);
+       return;
+}
+
+void
+_Toolbar::OnDrawFocus(void)
+{
+       __pToolbarPresenter->OnDrawFocus();
+
+       return;
+}
+
+void
+_Toolbar::OnChildControlFocusMoved(const _Control& control)
+{
+       __pToolbarPresenter->OnChildControlFocusMoved(control);
+
+       return;
+}
+
+bool
+_Toolbar::IsChildControlFocusManage(void) const
+{
+       __pToolbarPresenter->IsChildControlFocusManage();
+
+       return true;
+}
+
+void
+_Toolbar::OnFocusableStateChanged(bool focusalbeState)
+{
+       __pToolbarPresenter->OnFocusableStateChanged(focusalbeState);
+
+       return;
+}
+
+void
+_Toolbar::OnFocusModeStateChanged(void)
+{
+       if (__itemCount == 0)
+       {
+               if (__pButtonItems[LEFT_BUTTON])
+               {
+                       if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON])
+                       {
+                               if (__highlightedItemIndex == __itemCount && __pButtonItems[LEFT_BUTTON])
+                               {
+                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                       __pButtonItems[LEFT_BUTTON]->Invalidate();
+                               }
+                               else if (__highlightedItemIndex == __itemCount + 1 && __pButtonItems[BACK_BUTTON])
+                               {
+                                       __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                       __pButtonItems[BACK_BUTTON]->Invalidate();
+                               }
+                               else if (__highlightedItemIndex == __itemCount + 1 && __pButtonItems[RIGHT_BUTTON])
+                               {
+                                       __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                       __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                               }
+                       }
+                       else
+                       {
+                               if (__highlightedItemIndex == __itemCount && __pButtonItems[LEFT_BUTTON])
+                               {
+                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                       __pButtonItems[LEFT_BUTTON]->Invalidate();
+                               }
+                       }
+               }
+               else
+               {
+                       if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON])
+                       {
+                               if (__highlightedItemIndex == __itemCount && __pButtonItems[BACK_BUTTON])
+                               {
+                                       __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                       __pButtonItems[BACK_BUTTON]->Invalidate();
+                               }
+                               else if (__highlightedItemIndex == __itemCount && __pButtonItems[RIGHT_BUTTON])
+                               {
+                                       __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                       __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                               }
+                       }
+               }
+       }
+       else // __itemCount != 0
+       {
+               if (__highlightedItemIndex < __itemCount)
+               {
+                       if(__pItems.at(__highlightedItemIndex))
+                       {
+                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                       }
+               }
+               else
+               {
+                       if (__pButtonItems[LEFT_BUTTON])
+                       {
+                               if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON])
+                               {
+                                       if (__highlightedItemIndex == __itemCount && __pButtonItems[LEFT_BUTTON])
+                                       {
+                                               __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                               __pButtonItems[LEFT_BUTTON]->Invalidate();
+                                       }
+                                       else if (__highlightedItemIndex == __itemCount + 1 && __pButtonItems[BACK_BUTTON])
+                                       {
+                                               __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                               __pButtonItems[BACK_BUTTON]->Invalidate();
+                                       }
+                                       else if (__highlightedItemIndex == __itemCount + 1 && __pButtonItems[RIGHT_BUTTON])
+                                       {
+                                               __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                               __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                                       }
+                               }
+                               else
+                               {
+                                       if (__highlightedItemIndex == __itemCount && __pButtonItems[LEFT_BUTTON])
+                                       {
+                                               __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                               __pButtonItems[LEFT_BUTTON]->Invalidate();
+                                       }
+                               }
+                       }
+                       else
+                       {
+                               if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON])
+                               {
+                                       if (__highlightedItemIndex == __itemCount && __pButtonItems[BACK_BUTTON])
+                                       {
+                                               __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                               __pButtonItems[BACK_BUTTON]->Invalidate();
+                                       }
+                                       else if (__highlightedItemIndex == __itemCount && __pButtonItems[RIGHT_BUTTON])
+                                       {
+                                               __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                               __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                                       }
+                               }
+                       }
+               }
+
+               int selectedItemIndex = GetSelectedItemIndex();
+
+               if(selectedItemIndex != -1 && __pItems.at(selectedItemIndex))
+               {
+                       __pItems.at(selectedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
+                       __pItems.at(selectedItemIndex)->Invalidate();
+               }
+       }
+
+       return;
+}
+
+bool
+_Toolbar::OnFocusGained(const _Control& source)
+{
+       if (__itemCount == 0)
+       {
+               if (__pButtonItems[LEFT_BUTTON])
+               {
+                       if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON])
+                       {
+                               if (__highlightedItemIndex == __itemCount && __pButtonItems[LEFT_BUTTON])
+                               {
+                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                       __pButtonItems[LEFT_BUTTON]->Invalidate();
+                               }
+                               else if (__highlightedItemIndex == __itemCount + 1 && __pButtonItems[BACK_BUTTON])
+                               {
+                                       __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                       __pButtonItems[BACK_BUTTON]->Invalidate();
+                               }
+                               else if (__highlightedItemIndex == __itemCount + 1 && __pButtonItems[RIGHT_BUTTON])
+                               {
+                                       __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                       __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                               }
+                       }
+                       else
+                       {
+                               if (__highlightedItemIndex == __itemCount && __pButtonItems[LEFT_BUTTON])
+                               {
+                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                       __pButtonItems[LEFT_BUTTON]->Invalidate();
+                               }
+                       }
+               }
+               else
+               {
+                       if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON])
+                       {
+                               if (__highlightedItemIndex == __itemCount && __pButtonItems[BACK_BUTTON])
+                               {
+                                       __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                       __pButtonItems[BACK_BUTTON]->Invalidate();
+                               }
+                               else if (__highlightedItemIndex == __itemCount && __pButtonItems[RIGHT_BUTTON])
+                               {
+                                       __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                       __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                               }
+                       }
+               }
+       }
+       else
+       {
+               if (__highlightedItemIndex < __itemCount)
+               {
+                       if(__pItems.at(__highlightedItemIndex))
+                       {
+                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                       }
+               }
+               else
+               {
+                       if (__pButtonItems[LEFT_BUTTON])
+                       {
+                               if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON])
+                               {
+                                       if (__highlightedItemIndex == __itemCount && __pButtonItems[LEFT_BUTTON])
+                                       {
+                                               __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                               __pButtonItems[LEFT_BUTTON]->Invalidate();
+                                       }
+                                       else if (__highlightedItemIndex == __itemCount + 1 && __pButtonItems[BACK_BUTTON])
+                                       {
+                                               __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                               __pButtonItems[BACK_BUTTON]->Invalidate();
+                                       }
+                                       else if (__highlightedItemIndex == __itemCount + 1 && __pButtonItems[RIGHT_BUTTON])
+                                       {
+                                               __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                               __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                                       }
+                               }
+                               else
+                               {
+                                       if (__highlightedItemIndex == __itemCount && __pButtonItems[LEFT_BUTTON])
+                                       {
+                                               __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                               __pButtonItems[LEFT_BUTTON]->Invalidate();
+                                       }
+                               }
+                       }
+                       else
+                       {
+                               if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON])
+                               {
+                                       if (__highlightedItemIndex == __itemCount && __pButtonItems[BACK_BUTTON])
+                                       {
+                                               __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                               __pButtonItems[BACK_BUTTON]->Invalidate();
+                                       }
+                                       else if (__highlightedItemIndex == __itemCount && __pButtonItems[RIGHT_BUTTON])
+                                       {
+                                               __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                               __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                                       }
+                               }
+                       }
+               }
+       }
+
+       return true;
+}
+
+bool
+_Toolbar::OnFocusLost(const _Control& source)
+{
+       if (__itemCount == 0)
+       {
+               if (__pButtonItems[LEFT_BUTTON])
+               {
+                       if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON])
+                       {
+                               if (__highlightedItemIndex == __itemCount && __pButtonItems[LEFT_BUTTON])
+                               {
+                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                       __pButtonItems[LEFT_BUTTON]->Invalidate();
+                               }
+                               else if (__highlightedItemIndex == __itemCount + 1 && __pButtonItems[BACK_BUTTON])
+                               {
+                                       __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                       __pButtonItems[BACK_BUTTON]->Invalidate();
+                               }
+                               else if (__highlightedItemIndex == __itemCount + 1 && __pButtonItems[RIGHT_BUTTON])
+                               {
+                                       __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                       __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                               }
+                       }
+                       else
+                       {
+                               if (__highlightedItemIndex == __itemCount && __pButtonItems[LEFT_BUTTON])
+                               {
+                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                       __pButtonItems[LEFT_BUTTON]->Invalidate();
+                               }
+                       }
+               }
+               else
+               {
+                       if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON])
+                       {
+                               if (__highlightedItemIndex == __itemCount && __pButtonItems[BACK_BUTTON])
+                               {
+                                       __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                       __pButtonItems[BACK_BUTTON]->Invalidate();
+                               }
+                               else if (__highlightedItemIndex == __itemCount && __pButtonItems[RIGHT_BUTTON])
+                               {
+                                       __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                       __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                               }
+                       }
+               }
+       }
+       else // __itemCount != 0
+       {
+               if (__highlightedItemIndex < __itemCount)
+               {
+                       if(__pItems.at(__highlightedItemIndex))
+                       {
+                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                       }
+               }
+               else
+               {
+                       if (__pButtonItems[LEFT_BUTTON])
+                       {
+                               if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON])
+                               {
+                                       if (__highlightedItemIndex == __itemCount && __pButtonItems[LEFT_BUTTON])
+                                       {
+                                               __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                               __pButtonItems[LEFT_BUTTON]->Invalidate();
+                                       }
+                                       else if (__highlightedItemIndex == __itemCount + 1 && __pButtonItems[BACK_BUTTON])
+                                       {
+                                               __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                               __pButtonItems[BACK_BUTTON]->Invalidate();
+                                       }
+                                       else if (__highlightedItemIndex == __itemCount + 1 && __pButtonItems[RIGHT_BUTTON])
+                                       {
+                                               __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                               __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                                       }
+                               }
+                               else
+                               {
+                                       if (__highlightedItemIndex == __itemCount && __pButtonItems[LEFT_BUTTON])
+                                       {
+                                               __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                               __pButtonItems[LEFT_BUTTON]->Invalidate();
+                                       }
+                               }
+                       }
+                       else
+                       {
+                               if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON])
+                               {
+                                       if (__highlightedItemIndex == __itemCount && __pButtonItems[BACK_BUTTON])
+                                       {
+                                               __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                               __pButtonItems[BACK_BUTTON]->Invalidate();
+                                       }
+                                       else if (__highlightedItemIndex == __itemCount && __pButtonItems[RIGHT_BUTTON])
+                                       {
+                                               __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                               __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                                       }
+                               }
+                       }
+               }
+
+               int selectedItemIndex = GetSelectedItemIndex();
+
+               if(selectedItemIndex != -1 && __pItems.at(selectedItemIndex))
+               {
+                       __pItems.at(selectedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
+                       __pItems.at(selectedItemIndex)->Invalidate();
+               }
+       }
+
+       return true;
+}
+
+bool
+_Toolbar::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
+{
+       _KeyCode keyCode = keyInfo.GetKeyCode();
+
+       int selectedItemIndex  = GetSelectedItemIndex();
+
+       if (keyCode == _KEY_RIGHT)
+       {
+               if (__header == true && __style != TOOLBAR_TEXT) // right align
+               {
+                       if (__itemCount != 0)
+                       {
+                               if (__highlightedItemIndex < (__itemCount - 1))
+                               {
+                                       if (__pItems.at(__highlightedItemIndex) != null)
+                                       {
+                                               if (__highlightedItemIndex == selectedItemIndex)
+                                               {
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
+                                                       __pItems.at(__highlightedItemIndex)->Invalidate();
+                                               }
+                                               else
+                                               {
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                       __pItems.at(__highlightedItemIndex)->Invalidate();
+                                               }
+
+                                               __highlightedItemIndex++;
+
+                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+
+                                               if (__highlightedItemIndex - __pToolbarPresenter->GetFirstLoadedItemIndex() == SEGMENTED_ITEM_MAX)
+                                               {
+                                                       __pToolbarPresenter->SetItemFit(__highlightedItemIndex - (SEGMENTED_ITEM_MAX - 1));
+                                               }
+                                       }
+                               }
+                               else
+                               {
+                                       if (__pButtonItems[LEFT_BUTTON] || __pButtonItems[RIGHT_BUTTON])
+                                       {
+                                               if (__highlightedItemIndex < __itemCount)
+                                               {
+                                                       if (__pItems.at(__highlightedItemIndex) != null)
+                                                       {
+                                                               if (__highlightedItemIndex == selectedItemIndex)
+                                                               {
+                                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
+                                                                       __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                               }
+                                                               else
+                                                               {
+                                                                       if (__highlightedItemIndex < __itemCount)
+                                                                       {
+                                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                                       }
+                                                               }
+                                                       }
+                                               }
+                                       }
+                                       else
+                                       {
+                                               if (__highlightedItemIndex < __itemCount - 1)
+                                               {
+                                                       if (__pItems.at(__highlightedItemIndex) != null)
+                                                       {
+                                                               if (__highlightedItemIndex == selectedItemIndex)
+                                                               {
+                                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
+                                                                       __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                               }
+                                                               else
+                                                               {
+                                                                       if (__highlightedItemIndex < __itemCount)
+                                                                       {
+                                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                                       }
+                                                               }
+
+                                                               if (__highlightedItemIndex - __pToolbarPresenter->GetFirstLoadedItemIndex() == SEGMENTED_ITEM_MAX)
+                                                               {
+                                                                       __pToolbarPresenter->SetItemFit(__highlightedItemIndex - (SEGMENTED_ITEM_MAX - 1));
+                                                               }
+                                                       }
+                                               }
+                                       }
+
+                                       if (__pButtonItems[LEFT_BUTTON])
+                                       {
+                                               if (__pButtonItems[RIGHT_BUTTON])
+                                               {
+                                                       if (__highlightedItemIndex == __itemCount - 1)
+                                                       {
+                                                               __highlightedItemIndex++;
+                                                               __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                               __pButtonItems[LEFT_BUTTON]->Invalidate();
+                                                       }
+                                                       else if (__highlightedItemIndex == __itemCount)
+                                                       {
+                                                               __highlightedItemIndex++;
+                                                               __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                               __pButtonItems[LEFT_BUTTON]->Invalidate();
+
+                                                               __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                               __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                                                       }
+                                               }
+                                               else
+                                               {
+                                                       if (__highlightedItemIndex == __itemCount - 1)
+                                                       {
+                                                               __highlightedItemIndex++;
+                                                               __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                               __pButtonItems[LEFT_BUTTON]->Invalidate();
+                                                       }
+                                               }
+                                       }
+                                       else
+                                       {
+                                               if (__pButtonItems[RIGHT_BUTTON])
+                                               {
+                                                       if (__highlightedItemIndex == __itemCount - 1)
+                                                       {
+                                                               __highlightedItemIndex++;
+                                                               __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                               __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                                                       }
+                                               }
+                                       }
+                               }
+                       }
+                       else // itemCount == 0
+                       {
+                               if (__pButtonItems[LEFT_BUTTON])
+                               {
+                                       if (__pButtonItems[RIGHT_BUTTON])
+                                       {
+                                               if (__highlightedItemIndex == 0)
+                                               {
+                                                       __highlightedItemIndex++;
+                                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                       __pButtonItems[LEFT_BUTTON]->Invalidate();
+
+                                                       __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                                               }
+                                       }
+                               }
+                       }
+               }
+               else // footer // right key
+               {
+                       if (__itemCount != 0)
+                       {
+                               if (__pButtonItems[LEFT_BUTTON])
+                               {
+                                       if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON]) // L Item  R
+                                       {
+                                               if (__highlightedItemIndex == __itemCount)
+                                               {
+                                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                       __pButtonItems[LEFT_BUTTON]->Invalidate();
+
+                                                       __highlightedItemIndex = 0;
+
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       __pItems.at(__highlightedItemIndex)->Invalidate();
+                                               }
+                                               else if (__highlightedItemIndex < __itemCount - 1)
+                                               {
+                                                       if (__highlightedItemIndex == selectedItemIndex)
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+                                                       else
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+
+                                                       __highlightedItemIndex++;
+
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       __pItems.at(__highlightedItemIndex)->Invalidate();
+                                               }
+                                               else if (__highlightedItemIndex == __itemCount -1)
+                                               {
+                                                       if (__highlightedItemIndex == selectedItemIndex)
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+                                                       else
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+
+                                                       __highlightedItemIndex = __itemCount + 1;
+
+                                                       if (__pButtonItems[BACK_BUTTON])
+                                                       {
+                                                               __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                               __pButtonItems[BACK_BUTTON]->Invalidate();
+                                                       }
+                                                       else if (__pButtonItems[RIGHT_BUTTON])
+                                                       {
+                                                               __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                               __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                                                       }
+                                               }
+                                       }
+                                       else  // L  Item
+                                       {
+                                               if (__highlightedItemIndex == __itemCount)
+                                               {
+                                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                       __pButtonItems[LEFT_BUTTON]->Invalidate();
+
+                                                       __highlightedItemIndex = 0;
+
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       __pItems.at(__highlightedItemIndex)->Invalidate();
+                                               }
+                                               else if (__highlightedItemIndex < __itemCount - 1)
+                                               {
+                                                       if (__highlightedItemIndex == selectedItemIndex)
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+                                                       else
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+
+                                                       __highlightedItemIndex++;
+
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       __pItems.at(__highlightedItemIndex)->Invalidate();
+                                               }
+                                       }
+                               }
+                               else // __pButtonItems[LEFT_BUTTON] is null
+                               {
+                                       if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON]) // Item  R
+                                       {
+                                               if (__highlightedItemIndex < __itemCount - 1)
+                                               {
+                                                       if (__highlightedItemIndex == selectedItemIndex)
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+                                                       else
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+
+                                                       __highlightedItemIndex++;
+
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       __pItems.at(__highlightedItemIndex)->Invalidate();
+                                               }
+                                               else if (__highlightedItemIndex == __itemCount -1)
+                                               {
+                                                       if (__highlightedItemIndex == selectedItemIndex)
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+                                                       else
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+
+                                                       __highlightedItemIndex++;
+
+                                                       if (__pButtonItems[BACK_BUTTON])
+                                                       {
+                                                               __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                               __pButtonItems[BACK_BUTTON]->Invalidate();
+                                                       }
+                                                       else if (__pButtonItems[RIGHT_BUTTON])
+                                                       {
+                                                               __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                               __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                                                       }
+                                               }
+                                       }
+                                       else  // Item
+                                       {
+                                               if (__highlightedItemIndex < __itemCount - 1)
+                                               {
+                                                       if (__highlightedItemIndex == selectedItemIndex)
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+                                                       else
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+
+                                                       __highlightedItemIndex++;
+
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       __pItems.at(__highlightedItemIndex)->Invalidate();
+
+                                                       if (__highlightedItemIndex - __pToolbarPresenter->GetFirstLoadedItemIndex() == SEGMENTED_ITEM_MAX)
+                                                       {
+                                                               __pToolbarPresenter->SetItemFit(__highlightedItemIndex - (SEGMENTED_ITEM_MAX - 1));
+                                                       }
+                                               }
+                                       }
+                               }
+                       }
+                       else // __itemCount = 0
+                       {
+                               if (__pButtonItems[LEFT_BUTTON])
+                               {
+                                       if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON])
+                                       {
+                                               if (__highlightedItemIndex == 0)
+                                               {
+                                                       __highlightedItemIndex++;
+                                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                       __pButtonItems[LEFT_BUTTON]->Invalidate();
+
+                                                       if (__pButtonItems[BACK_BUTTON])
+                                                       {
+                                                               __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                               __pButtonItems[BACK_BUTTON]->Invalidate();
+                                                       }
+                                                       else if (__pButtonItems[RIGHT_BUTTON])
+                                                       {
+                                                               __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                               __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                                                       }
+                                               }
+                                       }
+                               }
+                       }
+               }
+       }
+
+       if (keyCode == _KEY_LEFT)
+       {
+               if (__header == true && __style != TOOLBAR_TEXT) // right align
+               {
+                       if (__itemCount != 0)
+                       {
+                               if (__highlightedItemIndex == __itemCount + 1)
+                               {
+                                       __highlightedItemIndex--;
+                                       __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                       __pButtonItems[RIGHT_BUTTON]->Invalidate();
+
+                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                       __pButtonItems[LEFT_BUTTON]->Invalidate();
+                               }
+                               else if (__highlightedItemIndex == __itemCount)
+                               {
+                                       __highlightedItemIndex--;
+                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                       __pButtonItems[LEFT_BUTTON]->Invalidate();
+
+                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                       __pItems.at(__highlightedItemIndex)->Invalidate();
+                               }
+                               else if (__highlightedItemIndex > 0)
+                               {
+                                       if (__pItems.at(__highlightedItemIndex) != null)
+                                       {
+                                               if (__highlightedItemIndex == selectedItemIndex)
+                                               {
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
+                                                       __pItems.at(__highlightedItemIndex)->Invalidate();
+                                               }
+                                               else
+                                               {
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                       __pItems.at(__highlightedItemIndex)->Invalidate();
+                                               }
+
+                                               __highlightedItemIndex--;
+
+                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+
+                                               if (__pToolbarPresenter->GetFirstLoadedItemIndex() > __highlightedItemIndex)
+                                               {
+                                                       __pToolbarPresenter->SetItemFit(__highlightedItemIndex);
+                                               }
+                                       }
+                               }
+                       }
+                       else // __itemCount == 0
+                       {
+                               if (__highlightedItemIndex == __itemCount + 1)
+                               {
+                                       __highlightedItemIndex--;
+                                       __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                       __pButtonItems[RIGHT_BUTTON]->Invalidate();
+
+                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                       __pButtonItems[LEFT_BUTTON]->Invalidate();
+                               }
+                       }
+               }
+               else // footer << leftkey
+               {
+                       if (__itemCount != 0)
+                       {
+                               if (__pButtonItems[LEFT_BUTTON])
+                               {
+                                       if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON]) // L  Item  R
+                                       {
+                                               if (__highlightedItemIndex == 0)
+                                               {
+                                                       if (__highlightedItemIndex == selectedItemIndex)
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+                                                       else
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+
+                                                       __highlightedItemIndex = __itemCount;
+
+                                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       __pButtonItems[LEFT_BUTTON]->Invalidate();
+                                               }
+                                               else if (__highlightedItemIndex < __itemCount)
+                                               {
+                                                       if (__highlightedItemIndex == selectedItemIndex)
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+                                                       else
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+
+                                                       __highlightedItemIndex--;
+
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       __pItems.at(__highlightedItemIndex)->Invalidate();
+                                               }
+                                               else if (__highlightedItemIndex == __itemCount + 1)
+                                               {
+                                                       if (__pButtonItems[BACK_BUTTON])
+                                                       {
+                                                               __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                               __pButtonItems[BACK_BUTTON]->Invalidate();
+                                                       }
+                                                       else if (__pButtonItems[RIGHT_BUTTON])
+                                                       {
+                                                               __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                               __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                                                       }
+
+                                                       __highlightedItemIndex = __itemCount - 1;
+
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       __pItems.at(__highlightedItemIndex)->Invalidate();
+                                               }
+                                       }
+                                       else  // L  Item
+                                       {
+                                               if (__highlightedItemIndex == 0)
+                                               {
+                                                       if (__highlightedItemIndex == selectedItemIndex)
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+                                                       else
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+
+                                                       __highlightedItemIndex = __itemCount;
+
+                                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       __pButtonItems[LEFT_BUTTON]->Invalidate();
+                                               }
+                                               else if (__highlightedItemIndex < __itemCount)
+                                               {
+                                                       if (__highlightedItemIndex == selectedItemIndex)
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+                                                       else
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+
+                                                       __highlightedItemIndex--;
+
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       __pItems.at(__highlightedItemIndex)->Invalidate();
+                                               }
+                                       }
+                               }
+                               else // __pButtonItems[LEFT_BUTTON] is null
+                               {
+                                       if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON]) // Item  R
+                                       {
+                                               if (__highlightedItemIndex == 0)
+                                               {
+                                                       // empty
+                                               }
+                                               else if (__highlightedItemIndex < __itemCount)
+                                               {
+                                                       if (__highlightedItemIndex == selectedItemIndex)
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+                                                       else
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+
+                                                       __highlightedItemIndex--;
+
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       __pItems.at(__highlightedItemIndex)->Invalidate();
+                                               }
+                                               else if (__highlightedItemIndex == __itemCount)
+                                               {
+                                                       if (__pButtonItems[BACK_BUTTON])
+                                                       {
+                                                               __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                               __pButtonItems[BACK_BUTTON]->Invalidate();
+                                                       }
+                                                       else if (__pButtonItems[RIGHT_BUTTON])
+                                                       {
+                                                               __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                               __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                                                       }
+
+                                                       __highlightedItemIndex--;
+
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       __pItems.at(__highlightedItemIndex)->Invalidate();
+                                               }
+                                       }
+                                       else // Item
+                                       {
+                                               if (__highlightedItemIndex == 0)
+                                               {
+                                                       // empty
+                                               }
+                                               else if (__highlightedItemIndex < __itemCount)
+                                               {
+                                                       if (__highlightedItemIndex == selectedItemIndex)
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+                                                       else
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                               __pItems.at(__highlightedItemIndex)->Invalidate();
+                                                       }
+
+                                                       __highlightedItemIndex--;
+
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       __pItems.at(__highlightedItemIndex)->Invalidate();
+
+                                                       if (__pToolbarPresenter->GetFirstLoadedItemIndex() > __highlightedItemIndex)
+                                                       {
+                                                               __pToolbarPresenter->SetItemFit(__highlightedItemIndex);
+                                                       }
+                                               }
+                                       }
+                               }
+                       }
+                       else // __itemCount == 0
+                       {
+                               if (__pButtonItems[LEFT_BUTTON])
+                               {
+                                       if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON])
+                                       {
+                                               if (__highlightedItemIndex == __itemCount)
+                                               {
+                                                       if (__pButtonItems[BACK_BUTTON])
+                                                       {
+                                                               __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                               __pButtonItems[BACK_BUTTON]->Invalidate();
+                                                       }
+                                                       else if (__pButtonItems[RIGHT_BUTTON])
+                                                       {
+                                                               __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
+                                                               __pButtonItems[RIGHT_BUTTON]->Invalidate();
+                                                       }
+
+                                                       __highlightedItemIndex--;
+
+                                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       __pButtonItems[LEFT_BUTTON]->Invalidate();
+                                               }
+                                       }
+                               }
+                       }
+               }
+       }
+
+       if (keyCode == _KEY_ENTER)
        {
-               pButtonElement->SetName(name);
-
-               if (position == BACK_BUTTON)
-               {
-                       pButtonElement->SetLabel("Back");
-                       pButtonElement->SetTrait("Button");
-               }
-               else
+               if (__itemCount != 0)
                {
-                       pButtonElement->SetTrait(L"Button");
-               }
-               FloatRectangle floatRect = GetButtonBoundsF(position);
-               pButtonElement->SetBounds(FloatRectangle(0,floatRect.y, pButton->GetBoundsF().width, floatRect.height));
-       }
-}
+                       if (__pButtonItems[LEFT_BUTTON])
+                       {
+                               if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON]) // L  Item  R
+                               {
+                                       if (__highlightedItemIndex < __itemCount)
+                                       {
+                                               if (__style == TOOLBAR_HEADER_SEGMENTED || __style ==TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_SEGMENTED
+                                                               || __style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE)
+                                               {
+                                                       SetItemSelected(__highlightedItemIndex, true, false);
+                                                       //__pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                               }
+                                               else
+                                               {
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED);
 
-void
-_Toolbar::AddAccessibilityElement(_Button* pButton)
-{
-       _AccessibilityContainer* pContainer = GetAccessibilityContainer();
-       if(pContainer == null)
-       {
-               return;
-       }
+                                                       if (__pItems.empty() == false)
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       }
+                                               }
+                                       }
+                                       else if (__highlightedItemIndex == __itemCount)
+                                       {
+                                               __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_SELECTED);
 
-       int priorty = 0;
-       if(__header == true)
-       {
-               priorty = ACCESSIBILITY_PRIORITY_TOP;
-       }
-       else
-       {
-               priorty = ACCESSIBILITY_PRIORITY_BOTTOM;
-       }
-       pContainer->SetPriority(priorty);
+                                               if (__pButtonItems[LEFT_BUTTON] != null)
+                                               {
+                                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                               }
+                                       }
+                                       else if (__highlightedItemIndex == __itemCount + 1)
+                                       {
+                                               if (__pButtonItems[BACK_BUTTON])
+                                               {
+                                                       __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_SELECTED);
 
-       ToolbarStyle style = GetStyle();
-       String trait = L"";
-       String name = L"";
-       switch (style)
-       {
-               case TOOLBAR_HEADER_SEGMENTED:
-                       //fall through
-               case TOOLBAR_HEADER_SEGMENTED_WITH_TITLE:
-                       //fall through
-               case TOOLBAR_SEGMENTED:
-                       name = L"Segment" + Integer::ToString(__itemCount);
-                       name.Append(L"Text");
-                       trait = L"Segmented control";
-                       break;
-               case TOOLBAR_TAB_WITH_TITLE:
-                       //fall through
-               case TOOLBAR_TAB:
-                       name = L"Tab" + Integer::ToString(__itemCount);
-                       name.Append(L"Text");
-                       trait = L"Tab";
-                       break;
-               default:
-                       name = L"Button" + Integer::ToString(__itemCount);
-                       name.Append(L"Text");
-                       trait = L"Button";
-                       break;
-       }
+                                                       if (__pButtonItems[BACK_BUTTON] != null)
+                                                       {
+                                                               __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       }
+                                               }
+                                               else if (__pButtonItems[RIGHT_BUTTON])
+                                               {
+                                                       __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_SELECTED);
 
-       if (pButton != null)
-       {
-               _AccessibilityElement* pElement = null;
-               _AccessibilityContainer* pButtonContainer = pButton->GetAccessibilityContainer();
+                                                       if (__pButtonItems[RIGHT_BUTTON] != null)
+                                                       {
+                                                               __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       }
+                                               }
+                                       }
+                               }
+                               else  // L  Item
+                               {
+                                       if (__highlightedItemIndex < __itemCount)
+                                       {
+                                               if (__style == TOOLBAR_HEADER_SEGMENTED || __style ==TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_SEGMENTED
+                                                               || __style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE)
+                                               {
+                                                       SetItemSelected(__highlightedItemIndex, true, false);
+                                                       //__pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                               }
+                                               else
+                                               {
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED);
 
-               if (pButtonContainer)
-               {
-                       pButtonContainer->SetPriority(priorty);
-                       pContainer->AddChildContainer(*pButtonContainer);
-                       pElement = pButtonContainer->GetChildElement(L"ButtonText");
-               }
+                                                       if (__pItems.empty() == false)
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       }
+                                               }
+                                       }
+                                       else if (__highlightedItemIndex == __itemCount)
+                                       {
+                                               __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_SELECTED);
 
-               if(pElement)
-               {
-                       pElement->SetName(name);
-                       pElement->SetTrait(trait);
-                       if(style == TOOLBAR_HEADER_SEGMENTED || style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE
-                               || style == TOOLBAR_SEGMENTED || style == TOOLBAR_TAB_WITH_TITLE
-                               || style == TOOLBAR_TAB)
-                       {
-                               pElement->SetHint(L"Double tap to move to contents");
-                               pButton->GetAccessibilityContainer()->AddListener(*__pAccessibilityListener);
+                                               if (__pButtonItems[LEFT_BUTTON] != null)
+                                               {
+                                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                               }
+                                       }
+                               }
                        }
-               }
-       }
+                       else // __pButtonItems[LEFT_BUTTON] is null
+                       {
+                               if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON]) // Item  R
+                               {
+                                       if (__highlightedItemIndex < __itemCount)
+                                       {
+                                               if (__style == TOOLBAR_HEADER_SEGMENTED || __style ==TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_SEGMENTED
+                                                               || __style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE)
+                                               {
+                                                       SetItemSelected(__highlightedItemIndex, true, false);
+                                                       //__pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                               }
+                                               else
+                                               {
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED);
 
-       return;
-}
+                                                       if (__pItems.empty() == false)
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       }
+                                               }
+                                       }
+                                       else if (__highlightedItemIndex == __itemCount)
+                                       {
+                                               if (__pButtonItems[BACK_BUTTON])
+                                               {
+                                                       __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_SELECTED);
 
-void
-_Toolbar::OnBoundsChanged(void)
-{
-       RearrangeItems();
+                                                       if (__pButtonItems[BACK_BUTTON] != null)
+                                                       {
+                                                               __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       }
+                                               }
+                                               else if (__pButtonItems[RIGHT_BUTTON])
+                                               {
+                                                       __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_SELECTED);
 
-       if(__pTitleTextElement)
-       {
-               if( __descriptionText.IsEmpty())
-               {
-                       __pTitleTextElement->SetBounds(FloatRectangle(__pToolbarPresenter->GetTitleTextBoundsF()));
+                                                       if (__pButtonItems[RIGHT_BUTTON] != null)
+                                                       {
+                                                               __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       }
+                                               }
+                                       }
+                               }
+                               else // Item
+                               {
+                                       if (__highlightedItemIndex < __itemCount)
+                                       {
+                                               if (__style == TOOLBAR_HEADER_SEGMENTED || __style ==TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_SEGMENTED
+                                                               || __style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE)
+                                               {
+                                                       SetItemSelected(__highlightedItemIndex, true, false);
+                                                       //__pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                               }
+                                               else
+                                               {
+                                                       __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED);
+
+                                                       if (__pItems.empty() == false)
+                                                       {
+                                                               __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       }
+                                               }
+                                       }
+                               }
+                       }
                }
-               else
+               else // __itemCount == 0
                {
-                       FloatRectangle descriptionBounds = __pToolbarPresenter->GetDescriptionBoundsF();
-                       FloatRectangle titleBounds = __pToolbarPresenter->GetTitleTextBoundsF();
+                       if (__pButtonItems[LEFT_BUTTON])
+                       {
+                               if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON]) // L   R
+                               {
+                                       if (__highlightedItemIndex == 0)
+                                       {
+                                               __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_SELECTED);
 
-                       __pTitleTextElement->SetBounds(FloatRectangle(titleBounds.x, titleBounds.y, titleBounds.width, titleBounds.height + descriptionBounds.height));
-               }
-       }
-       return;
-}
+                                               if (__pButtonItems[LEFT_BUTTON] != null)
+                                               {
+                                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                               }
+                                       }
+                                       else if (__highlightedItemIndex == 1)
+                                       {
+                                               if (__pButtonItems[BACK_BUTTON])
+                                               {
+                                                       __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_SELECTED);
 
-void
-_Toolbar::OnFontChanged(Font* pFont)
-{
-       __pToolbarPresenter->OnFontChanged(pFont);
+                                                       if (__pButtonItems[BACK_BUTTON] != null)
+                                                       {
+                                                               __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       }
+                                               }
+                                               else if (__pButtonItems[RIGHT_BUTTON])
+                                               {
+                                                       __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_SELECTED);
 
-       return;
-}
+                                                       if (__pButtonItems[RIGHT_BUTTON] != null)
+                                                       {
+                                                               __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       }
+                                               }
+                                       }
+                               }
+                               else  // L
+                               {
+                                       if (__highlightedItemIndex == 0)
+                                       {
+                                               __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_SELECTED);
 
-void
-_Toolbar::OnFontInfoRequested(unsigned long& style, int& size)
-{
-       __pToolbarPresenter->OnFontInfoRequested(style, size);
+                                               if (__pButtonItems[LEFT_BUTTON] != null)
+                                               {
+                                                       __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                               }
+                                       }
+                               }
+                       }
+                       else // __pButtonItems[LEFT_BUTTON] is null
+                       {
+                               if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON]) //  R
+                               {
+                                       if (__highlightedItemIndex == 0)
+                                       {
+                                               if (__pButtonItems[BACK_BUTTON])
+                                               {
+                                                       __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_SELECTED);
 
-       return;
-}
+                                                       if (__pButtonItems[BACK_BUTTON] != null)
+                                                       {
+                                                               __pButtonItems[BACK_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       }
+                                               }
+                                               else if (__pButtonItems[RIGHT_BUTTON])
+                                               {
+                                                       __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_SELECTED);
 
-void
-_Toolbar::OnAncestorVisibleStateChanged(const _Control& control)
-{
-       __pToolbarPresenter->OnAncestorVisibleStateChanged(control);
+                                                       if (__pButtonItems[RIGHT_BUTTON] != null)
+                                                       {
+                                                               __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+                                                       }
+                                               }
+                                       }
+                               }
+                       }
+               }
+       }
 
-       _Control::OnAncestorVisibleStateChanged(control);
-       return;
+       return false;
 }
 
 void
@@ -3083,6 +4358,12 @@ _Toolbar::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
        return __pToolbarPresenter->OnTouchCanceled(source, touchinfo);
 }
 
+bool
+_Toolbar::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
+{
+       return false;
+}
+
 void
 _Toolbar::AddActionEventListener(const Controls::_IActionEventListener& listener)
 {
@@ -6288,6 +7569,17 @@ _Toolbar::SetPropertyHighlightedItemColor(const Variant& color)
                }
        }
 
+       for (int i = 0; i < __itemCount; i++)
+       {
+               if (__pItems.at(i) != null)
+               {
+                       if (__pBaseBackgroundBitmap)
+                       {
+                               SetColorReplacedBitmap(__pItems.at(i), _BUTTON_STATUS_HIGHLIGHTED, __itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED], __pBaseBackgroundBitmap);
+                       }
+               }
+       }
+
        delete __pBaseBackgroundBitmap;
 
        return E_SUCCESS;

diff --git a/src/ui/controls/FUiCtrl_ToolbarPresenter.cpp b/src/ui/controls/FUiCtrl_ToolbarPresenter.cpp
index 1f9aee1..a1c27ea 100644 (file)
--- a/src/ui/controls/FUiCtrl_ToolbarPresenter.cpp
+++ b/src/ui/controls/FUiCtrl_ToolbarPresenter.cpp
@@ -989,6 +989,9 @@ _ToolbarPresenter::SetInitialDrawState(bool state)
        __titleSliding = false;
        __tabEditEnabled = false;
 
+       __firstLoadedItemIndex = 0;
+       __lastLoadedItemIndex = 0;
+
        return E_SUCCESS;
 }
 
@@ -1761,6 +1764,55 @@ _ToolbarPresenter::OnTimerExpired(Timer& timer)
        return;
 }
 
+void
+_ToolbarPresenter::OnDrawFocus(void)
+{
+       return;
+}
+
+void
+_ToolbarPresenter::OnChildControlFocusMoved(const _Control& control)
+{
+       return;
+}
+
+bool
+_ToolbarPresenter::IsChildControlFocusManage(void) const
+{
+       return true;
+}
+
+void
+_ToolbarPresenter::OnFocusableStateChanged(bool focusalbeState)
+{
+       return;
+}
+
+void
+_ToolbarPresenter::OnFocusModeStateChanged(void)
+{
+       return;
+}
+
+bool
+_ToolbarPresenter::OnFocusGained(const _Control& source)
+{
+       //__focusPrevStatus = __pButton->GetButtonStatus();
+       //__pButton->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
+       //__pButton->Invalidate();
+
+       return false;
+}
+
+bool
+_ToolbarPresenter::OnFocusLost(const _Control& source)
+{
+       //__pButton->SetButtonStatus(__focusPrevStatus);
+       //__pButton->Invalidate();
+
+       return true;
+}
+
 result
 _ToolbarPresenter::TimerForTitleSlideInit(void)
 {
@@ -2029,6 +2081,12 @@ _ToolbarPresenter::SetFirstLoadedItemIndex(void)
        return;
 }
 
+int
+_ToolbarPresenter::GetFirstLoadedItemIndex(void)
+{
+       return __firstLoadedItemIndex;
+}
+
 void
 _ToolbarPresenter::SetLastLoadedItemIndex(void)
 {
@@ -2117,6 +2175,11 @@ _ToolbarPresenter::SetItemFit(int index)
                pItem->SetBounds(bounds);
        }
 
+       SetFirstLoadedItemIndex();
+       SetLastLoadedItemIndex();
+
+       Draw();
+
        return;
 }
 

diff --git a/src/ui/inc/FUiCtrl_Button.h b/src/ui/inc/FUiCtrl_Button.h
index 4ac1b16..d3014f9 100644 (file)
--- a/src/ui/inc/FUiCtrl_Button.h
+++ b/src/ui/inc/FUiCtrl_Button.h
@@ -130,12 +130,21 @@ public:
        virtual bool OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo);
        virtual bool OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo);
        virtual void OnTouchMoveHandled(const _Control& control);
+       virtual bool OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo);
+       virtual bool OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo);
        virtual void OnBoundsChanged(void);
        virtual void OnFontChanged(Tizen::Graphics::Font* pFont);
        virtual void OnFontInfoRequested(unsigned long& style, int& size);
        virtual void OnFontInfoRequested(unsigned long& style, float& size);
        virtual Tizen::Graphics::FloatDimension GetContentSizeF(bool horizontalMode, bool verticalMode) const;
        virtual void OnAncestorEnableStateChanged(const _Control& control);
+       virtual void OnDrawFocus(void);
+       virtual void OnChildControlFocusMoved(const _Control& control);
+       virtual bool IsChildControlFocusManage(void) const;
+       virtual void OnFocusableStateChanged(bool focusalbeState);
+       virtual void OnFocusModeStateChanged(void);
+       virtual bool OnFocusGained(const _Control& source);
+       virtual bool OnFocusLost(const _Control& source);
 
 public:
        result SetText(const Tizen::Base::String& text);

diff --git a/src/ui/inc/FUiCtrl_ButtonPresenter.h b/src/ui/inc/FUiCtrl_ButtonPresenter.h
index cb4cf34..7be1537 100644 (file)
--- a/src/ui/inc/FUiCtrl_ButtonPresenter.h
+++ b/src/ui/inc/FUiCtrl_ButtonPresenter.h
@@ -26,6 +26,7 @@
 #include <FBaseObject.h>
 #include <FGrp_TextTextObject.h>
 #include "FUi_Control.h"
+#include "FUiCtrl_Button.h"
 
 namespace Tizen { namespace Ui { namespace Animations
 {
@@ -62,7 +63,16 @@ public:
        virtual bool OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo);
        virtual bool OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo);
        virtual void OnTouchMoveHandled(const _Control& control);
+       virtual bool OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo);
+       virtual bool OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo);
        virtual void OnAncestorEnableStateChanged(const _Control& control);
+       virtual void OnDrawFocus(void);
+       virtual void OnChildControlFocusMoved(const _Control& control);
+       virtual bool IsChildControlFocusManage(void) const;
+       virtual void OnFocusableStateChanged(bool focusalbeState);
+       virtual void OnFocusModeStateChanged(void);
+       virtual bool OnFocusGained(const _Control& source);
+       virtual bool OnFocusLost(const _Control& source);
 
        void Draw(void);
 
@@ -107,6 +117,7 @@ private:
        Tizen::Ui::Animations::_VisualElement* __pBase;
        unsigned long __fontStyle;
        float __fontSize;
+       _ButtonStatus __focusPrevStatus;
 }; // _ButtonPresenter
 
 }}} // Tizen::Ui::Controls

diff --git a/src/ui/inc/FUiCtrl_CheckButton.h b/src/ui/inc/FUiCtrl_CheckButton.h
index abe9023..4a0f2b6 100644 (file)
--- a/src/ui/inc/FUiCtrl_CheckButton.h
+++ b/src/ui/inc/FUiCtrl_CheckButton.h
@@ -149,9 +149,18 @@ public:
        virtual bool OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo);
        virtual bool OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo);
        virtual void OnTouchMoveHandled(const _Control& control);
+       virtual bool OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo);
+       virtual bool OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo);
        virtual void OnBoundsChanged(void);
        virtual void OnFontChanged(Tizen::Graphics::Font* pFont);
        virtual void OnFontInfoRequested(unsigned long& style, int& size);
+       virtual void OnDrawFocus(void);
+       virtual void OnChildControlFocusMoved(const _Control& control);
+       virtual bool IsChildControlFocusManage(void) const;
+       virtual void OnFocusableStateChanged(bool focusalbeState);
+       virtual void OnFocusModeStateChanged(void);
+       virtual bool OnFocusGained(const _Control& source);
+       virtual bool OnFocusLost(const _Control& source);
 
 public:
        result LoadDefaultBackgroundBitmap(void);

diff --git a/src/ui/inc/FUiCtrl_CheckButtonPresenter.h b/src/ui/inc/FUiCtrl_CheckButtonPresenter.h
index 41f4ca1..11d22fa 100644 (file)
--- a/src/ui/inc/FUiCtrl_CheckButtonPresenter.h
+++ b/src/ui/inc/FUiCtrl_CheckButtonPresenter.h
@@ -26,6 +26,7 @@
 #include <FBaseObject.h>
 #include <FGrp_TextTextObject.h>
 #include "FUi_Control.h"
+#include "FUiCtrl_CheckButton.h"
 
 namespace Tizen { namespace Ui { namespace Animations
 {
@@ -63,9 +64,19 @@ public:
        virtual bool OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo);
        virtual bool OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo);
        virtual void OnTouchMoveHandled(const _Control& control);
+       virtual bool OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo);
+       virtual bool OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo);
 
        virtual void OnTimerExpired(Tizen::Base::Runtime::Timer& timer);
 
+       virtual void OnDrawFocus(void);
+       virtual void OnChildControlFocusMoved(const _Control& control);
+       virtual bool IsChildControlFocusManage(void) const;
+       virtual void OnFocusableStateChanged(bool focusalbeState);
+       virtual void OnFocusModeStateChanged(void);
+       virtual bool OnFocusGained(const _Control& source);
+       virtual bool OnFocusLost(const _Control& source);
+
        void Draw(void);
 
        void OnFontChanged(Tizen::Graphics::Font* pFont);
@@ -131,6 +142,7 @@ private:
        float __onOffHandlerPosition;
        bool __onOffHandlerPressed;
        bool __onOffHandlerMoved;
+       _CheckButtonStatus __focusPrevStatus;
 }; // _CheckButtonPresenter
 
 }}} // Tizen::Ui::Controls

diff --git a/src/ui/inc/FUiCtrl_Toolbar.h b/src/ui/inc/FUiCtrl_Toolbar.h
index 5920fc4..0e1e678 100644 (file)
--- a/src/ui/inc/FUiCtrl_Toolbar.h
+++ b/src/ui/inc/FUiCtrl_Toolbar.h
@@ -351,6 +351,10 @@ public:
 
        virtual bool OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo);
 
+       virtual bool OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo);
+
+       virtual bool OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo);
+
        void AddActionEventListener(const Tizen::Ui::Controls::_IActionEventListener& listener);
 
        void RemoveActionEventListener(const Tizen::Ui::Controls::_IActionEventListener& listener);
@@ -365,6 +369,20 @@ public:
 
        virtual void OnAncestorVisibleStateChanged(const _Control& control);
 
+       virtual void OnDrawFocus(void);
+
+       virtual void OnChildControlFocusMoved(const _Control& control);
+
+       virtual bool IsChildControlFocusManage(void) const;
+
+       virtual void OnFocusableStateChanged(bool focusalbeState);
+
+       virtual void OnFocusModeStateChanged(void);
+
+       virtual bool OnFocusGained(const _Control& source);
+
+       virtual bool OnFocusLost(const _Control& source);
+
        Tizen::Graphics::Rectangle GetButtonBounds(ToolbarButton position) const;
 
        Tizen::Graphics::FloatRectangle GetButtonBoundsF(ToolbarButton position) const;
@@ -502,6 +520,8 @@ private:
 
        bool __isUserBackgroundBitmap;
 
+       int __highlightedItemIndex;
+
        Tizen::Graphics::FloatRectangle __titleTextArea;
 
        Tizen::Graphics::FloatRectangle __itemArea;

diff --git a/src/ui/inc/FUiCtrl_ToolbarPresenter.h b/src/ui/inc/FUiCtrl_ToolbarPresenter.h
index 005b32d..3d20c2f 100644 (file)
--- a/src/ui/inc/FUiCtrl_ToolbarPresenter.h
+++ b/src/ui/inc/FUiCtrl_ToolbarPresenter.h
@@ -110,6 +110,20 @@ public:
 
        virtual void OnTimerExpired(Tizen::Base::Runtime::Timer& timer);
 
+       virtual void OnDrawFocus(void);
+
+       virtual void OnChildControlFocusMoved(const _Control& control);
+
+       virtual bool IsChildControlFocusManage(void) const;
+
+       virtual void OnFocusableStateChanged(bool focusalbeState);
+
+       virtual void OnFocusModeStateChanged(void);
+
+       virtual bool OnFocusGained(const _Control& source);
+
+       virtual bool OnFocusLost(const _Control& source);
+
        result TimerForTitleSlideInit(void);
 
        result TimerForTitleSlideStart(void);
@@ -126,8 +140,9 @@ public:
        void OnAncestorVisibleStateChanged(const _Control& control);
        void SetFontInfo(unsigned long style, float size);
 
-
        result AdjustItemPositionX(float distance);
+       void SetItemFit(int);
+       int GetFirstLoadedItemIndex(void);
 
 protected:
        result _SetModel(const _ToolbarModel& toolbarModel);
@@ -144,8 +159,6 @@ private:
 
        float CalculateProgress(float timeProgress) const;
 
-       void SetItemFit(int);
-
        virtual void OnVisualElementAnimationStarted(const Tizen::Ui::Animations::VisualElementAnimation& animation, const Tizen::Base::String& keyName, Tizen::Ui::Animations::VisualElement& target);
        virtual void OnVisualElementAnimationRepeated(const Tizen::Ui::Animations::VisualElementAnimation& animation, const Tizen::Base::String& keyName, Tizen::Ui::Animations::VisualElement& target, long currentRepeatCount);
        virtual void OnVisualElementAnimationFinished(const Tizen::Ui::Animations::VisualElementAnimation& animation, const Tizen::Base::String& keyName, Tizen::Ui::Animations::VisualElement& target, bool completedNormally);