, __pHueBarElement(null)
, __pSaturationBarElement(null)
, __pLuminanceBarElement(null)
+ , __currentFocusedHandler(HUE_HANDLER)
+ , __previousFocusedHandler(HSL_NOT)
+ , __isInFocusMode(false)
{
}
bool
_ColorPicker::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
{
+ __pColorPickerPresenter->ClearFocus(__currentFocusedHandler);
+
return __pColorPickerPresenter->OnTouchPressed(source, touchinfo);
}
return true;
}
+bool
+_ColorPicker::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
+{
+ _KeyCode keyCode = keyInfo.GetKeyCode();
+
+ if (!__isInFocusMode)
+ {
+ return false;
+ }
+
+ switch (keyCode)
+ {
+ case _KEY_RIGHT:
+ __pColorPickerPresenter->StepHandler(__currentFocusedHandler, true);
+ break;
+
+ case _KEY_LEFT:
+ __pColorPickerPresenter->StepHandler(__currentFocusedHandler, false);
+ break;
+
+ case _KEY_DOWN:
+ if (__currentFocusedHandler < LUM_HANDLER)
+ {
+ __previousFocusedHandler = __currentFocusedHandler;
+ __currentFocusedHandler = static_cast<_ColorPickerComponentType>(static_cast<int>(__currentFocusedHandler) + 1);
+ __pColorPickerPresenter->DrawFocus(__currentFocusedHandler, __previousFocusedHandler);
+ }
+ break;
+
+ case _KEY_UP:
+ if (__currentFocusedHandler > HUE_HANDLER)
+ {
+ __previousFocusedHandler = __currentFocusedHandler;
+ __currentFocusedHandler = static_cast<_ColorPickerComponentType>(static_cast<int>(__currentFocusedHandler) - 1);
+ __pColorPickerPresenter->DrawFocus(__currentFocusedHandler, __previousFocusedHandler);
+ }
+ break;
+
+ default:
+ return false;
+ }
+
+ return true;
+}
+
+bool
+_ColorPicker::OnFocusLost(const _Control& source)
+{
+ result r = E_SUCCESS;
+ r = __pColorPickerPresenter->ClearFocus(__currentFocusedHandler);
+ __previousFocusedHandler = HSL_NOT;
+ __currentFocusedHandler = HUE_HANDLER;
+
+ if (r != E_SUCCESS)
+ {
+ SysLogException(NID_UI_CTRL, r, "[%s] Propagating.", GetErrorMessage(r));
+ }
+ r = __pColorPickerPresenter->Draw();
+
+ if (r != E_SUCCESS)
+ {
+ SysLogException(NID_UI_CTRL, r, "[%s] Propagating.", GetErrorMessage(r));
+ }
+ _Control::OnFocusLost(source);
+
+ return true;
+}
+
+void
+_ColorPicker::OnDrawFocus(void)
+{
+ __pColorPickerPresenter->DrawFocus(__currentFocusedHandler, __previousFocusedHandler);
+ __isInFocusMode = true;
+
+ return;
+}
+
+void
+_ColorPicker::OnFocusModeStateChanged(void)
+{
+ result r = E_SUCCESS;
+
+ r = __pColorPickerPresenter->ClearFocus(__currentFocusedHandler);
+ __previousFocusedHandler = HSL_NOT;
+ __currentFocusedHandler = HUE_HANDLER;
+ __isInFocusMode = false;
+
+ if (r != E_SUCCESS)
+ {
+ SysLogException(NID_UI_CTRL, r, "[%s] Propagating.", GetErrorMessage(r));
+ }
+ Invalidate();
+
+ return;
+}
+
}}} // Tizen::Ui::Controls
#include "FUiAnim_VisualElement.h"
#include "FUiCtrl_ColorPickerPresenter.h"
#include "FUiCtrl_ColorPickerModel.h"
+#include "FUiCtrl_ColorPicker.h"
#include "FUi_AccessibilityElement.h"
#include "FUi_UiTouchEvent.h"
#include "FUi_ResourceManager.h"
, __pLandscapeCustomBitmap(null)
, __pLandscapeLuminanceSliderBgBitmap(null)
, __pLandscapeSaturationSliderBgBitmap(null)
+ , __pFocusBitmap(null)
{
}
delete __pLandscapeSaturationSliderBgBitmap;
__pLandscapeSaturationSliderBgBitmap = null;
+
+ delete __pFocusBitmap;
+ __pFocusBitmap = null;
}
_ColorPickerPresenter*
r = GET_BITMAP_CONFIG_N(COLORPICKER::RIGHT_ARROW_BUTTON_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pRightArrowDisabledBitmap);
SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
+ r = GET_BITMAP_CONFIG_N(COLORPICKER::HANDLER_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pFocusBitmap);
+ SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
+
__pColorNormalReplacementBgBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBgNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), buttonBgNormalColor);
r = GetLastResult();
SysTryCatch(NID_UI_CTRL, (__pColorNormalReplacementBgBitmap != null), , r, "[%s] Propagating.", GetErrorMessage(r));
delete __pRightArrowDisabledBitmap;
__pRightArrowDisabledBitmap = null;
+ delete __pFocusBitmap;
+ __pFocusBitmap = null;
+
+ return r;
+}
+
+void
+_ColorPickerPresenter::StepHandler(_ColorPickerComponentType index, bool increase)
+{
+ if (increase)
+ {
+ SetHandlerPosition(index, __componentBounds[index].x + ARROW_MOVE_STEP);
+ }
+ else
+ {
+ SetHandlerPosition(index, __componentBounds[index].x - ARROW_MOVE_STEP);
+ }
+
+ MoveHandler(index);
+ ChangeColorFromCurrentHandlerPosition(index);
+}
+
+result
+_ColorPickerPresenter::DrawFocus(_ColorPickerComponentType currentFocusedIndex, _ColorPickerComponentType prevFocusIndex)
+{
+ result r = E_SUCCESS;
+
+ if (prevFocusIndex != HSL_NOT)
+ {
+ ClearFocus(prevFocusIndex);
+ }
+
+ switch (currentFocusedIndex)
+ {
+ case HUE_HANDLER:
+ {
+ Canvas *pCanvas = __pColorPicker->GetHueHandler()->GetCanvasN();
+ r = GetLastResult();
+ SysTryReturnResult(NID_UI_CTRL, pCanvas != null, r, "[%s] Propagating.", GetErrorMessage(r));
+ r = DrawResourceBitmap(*pCanvas, FloatRectangle(0, 0, __componentBounds[HUE_HANDLER].width, __componentBounds[HUE_HANDLER].height), __pFocusBitmap);
+ delete pCanvas;
+ }
+ break;
+ case SAT_HANDLER:
+ {
+ Canvas *pCanvas = __pColorPicker->GetSaturationHandler()->GetCanvasN();
+ r = GetLastResult();
+ SysTryReturnResult(NID_UI_CTRL, pCanvas != null, r, "[%s] Propagating.", GetErrorMessage(r));
+ r = DrawResourceBitmap(*pCanvas, FloatRectangle(0, 0, __componentBounds[SAT_HANDLER].width, __componentBounds[SAT_HANDLER].height), __pFocusBitmap);
+ delete pCanvas;
+ }
+ break;
+ case LUM_HANDLER:
+ {
+ Canvas *pCanvas = __pColorPicker->GetLuminanceHandler()->GetCanvasN();
+ r = GetLastResult();
+ SysTryReturnResult(NID_UI_CTRL, pCanvas != null, r, "[%s] Propagating.", GetErrorMessage(r));
+ r = DrawResourceBitmap(*pCanvas, FloatRectangle(0, 0, __componentBounds[LUM_HANDLER].width, __componentBounds[LUM_HANDLER].height), __pFocusBitmap);
+ delete pCanvas;
+ }
+ break;
+ default:
+ break;
+ }
+
+ return r;
+}
+
+result
+_ColorPickerPresenter::ClearFocus(_ColorPickerComponentType index)
+{
+ result r = E_SUCCESS;
+
+ switch (index)
+ {
+ case HUE_HANDLER:
+ {
+ Canvas *pCanvas = __pColorPicker->GetHueHandler()->GetCanvasN();
+ r = GetLastResult();
+ SysTryReturnResult(NID_UI_CTRL, pCanvas != null, r, "[%s] Propagating.", GetErrorMessage(r));
+ pCanvas->SetBackgroundColor(Color());
+ pCanvas->Clear();
+ r = DrawResourceBitmap(*pCanvas, FloatRectangle(0, 0, __componentBounds[HUE_HANDLER].width, __componentBounds[HUE_HANDLER].height), __pHandlerBitmap);
+ delete pCanvas;
+ }
+ break;
+ case SAT_HANDLER:
+ {
+ Canvas *pCanvas = __pColorPicker->GetSaturationHandler()->GetCanvasN();
+ r = GetLastResult();
+ SysTryReturnResult(NID_UI_CTRL, pCanvas != null, r, "[%s] Propagating.", GetErrorMessage(r));
+ pCanvas->SetBackgroundColor(Color());
+ pCanvas->Clear();
+ r = DrawResourceBitmap(*pCanvas, FloatRectangle(0, 0, __componentBounds[SAT_HANDLER].width, __componentBounds[SAT_HANDLER].height), __pHandlerBitmap);
+ delete pCanvas;
+ }
+ break;
+ case LUM_HANDLER:
+ {
+ Canvas *pCanvas = __pColorPicker->GetLuminanceHandler()->GetCanvasN();
+ r = GetLastResult();
+ SysTryReturnResult(NID_UI_CTRL, pCanvas != null, r, "[%s] Propagating.", GetErrorMessage(r));
+ pCanvas->SetBackgroundColor(Color());
+ pCanvas->Clear();
+ r = DrawResourceBitmap(*pCanvas, FloatRectangle(0, 0, __componentBounds[LUM_HANDLER].width, __componentBounds[LUM_HANDLER].height), __pHandlerBitmap);
+ delete pCanvas;
+ }
+ break;
+ default:
+ break;
+ }
+
return r;
}
Color disabledColor;
Color pressedColor;
- GET_COLOR_CONFIG(TABLEVIEW::EXPANDABLE_ARROW_NORMAL, normalColor);
- GET_COLOR_CONFIG(TABLEVIEW::EXPANDABLE_ARROW_DISABLED, disabledColor);
- GET_COLOR_CONFIG(TABLEVIEW::EXPANDABLE_ARROW_PRESSED, pressedColor);
+ GET_COLOR_CONFIG(LIST::EXPANDABLE_ARROW_NORMAL, normalColor);
+ GET_COLOR_CONFIG(LIST::EXPANDABLE_ARROW_DISABLED, disabledColor);
+ GET_COLOR_CONFIG(LIST::EXPANDABLE_ARROW_PRESSED, pressedColor);
r = GET_BITMAP_CONFIG_N(LIST::BUTTON_COLLAPSE_GROUP, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
SysTryReturnResult(NID_UI_CTRL, (r == E_SUCCESS), r, "Failed to fetch Arrow Bitmap");
delete pTempBitmap;
pTempBitmap = null;
- r = GET_BITMAP_CONFIG_N(TABLEVIEW::BUTTON_EXPAND_CLOSED_EFFECT, BITMAP_PIXEL_FORMAT_ARGB8888, __pEffectOpenedImage);
+ r = GET_BITMAP_CONFIG_N(LIST::BUTTON_EXPAND_CLOSED_EFFECT, BITMAP_PIXEL_FORMAT_ARGB8888, __pEffectOpenedImage);
SysTryReturnResult(NID_UI_CTRL, (r == E_SUCCESS), r, "Failed to fetch Arrow effect Bitmap");
- r = GET_BITMAP_CONFIG_N(TABLEVIEW::BUTTON_EXPAND_OPENED_EFFECT, BITMAP_PIXEL_FORMAT_ARGB8888, __pEffectClosedImage);
+ r = GET_BITMAP_CONFIG_N(LIST::BUTTON_EXPAND_OPENED_EFFECT, BITMAP_PIXEL_FORMAT_ARGB8888, __pEffectClosedImage);
SysTryReturnResult(NID_UI_CTRL, (r == E_SUCCESS), r, "Failed to fetch Arrow effect Bitmap");
return r;
Canvas* pCanvas = null;
Rectangle bitmapBounds;
- Color canvasBackgroundColor;
-
result r = E_SUCCESS;
bitmapBounds = Rectangle(0, 0, pNormalBitmap.GetWidth(), pNormalBitmap.GetHeight());
pCanvas = new (std::nothrow) Canvas();
SysTryReturn(NID_UI_CTRL, pCanvas != null, null, E_OUT_OF_MEMORY, "Memory allocation failed.");
- GET_COLOR_CONFIG(TABLEVIEW::ITEM_ANNEX_CANVAS_BG_NORMAL, canvasBackgroundColor);
-
pCanvas->Construct(bitmapBounds);
- pCanvas->SetBackgroundColor(Color(canvasBackgroundColor.GetRed(), canvasBackgroundColor.GetGreen(), canvasBackgroundColor.GetBlue(), 0));
+ pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
pCanvas->Clear();
if (_BitmapImpl::CheckNinePatchedBitmapStrictly(pNormalBitmap))
Canvas* pCanvas = null;
Rectangle bitmapBounds;
-
- result r = E_SUCCESS;
-
Rectangle handlerBounds;
- Color canvasBackgroundColor;
+ result r = E_SUCCESS;
bitmapBounds = Rectangle(0, 0, pNormalBitmap.GetWidth(), pNormalBitmap.GetHeight());
pCanvas = new (std::nothrow) Canvas();
SysTryReturn(NID_UI_CTRL, pCanvas != null, null, E_OUT_OF_MEMORY, "Memory allocation failed.");
- GET_COLOR_CONFIG(TABLEVIEW::ITEM_ANNEX_CANVAS_BG_NORMAL, canvasBackgroundColor);
-
pCanvas->Construct(bitmapBounds);
- pCanvas->SetBackgroundColor(Color(canvasBackgroundColor.GetRed(), canvasBackgroundColor.GetGreen(), canvasBackgroundColor.GetBlue(), 0));
+ pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
pCanvas->Clear();
if (_BitmapImpl::CheckNinePatchedBitmapStrictly(pNormalBitmap))
, __pActionEvent(null)
, __pSubMenu(null)
, __subMenuIndex(-1)
+ , __currentFocusedIndex(-1)
+ , __isFocused(false)
{
}
return GetLastResult();
}
- __pSubMenu->SetFocusable(true);
+ __pSubMenu->SetFocusable(true);
if (__pSubMenu->GetOwner() == null)
{
}
SetTouchCapture(true, false);
-
_Window::OnActivated();
}
__pOptionMenuPresenter->OnActionPerformed(source, actionId);
}
+bool
+_OptionMenu::OnFocusGained(const _Control &source)
+{
+ __currentFocusedIndex = -1;
+ __isFocused = false;
+ return true;
+}
+
+bool
+_OptionMenu::OnFocusLost(const _Control &source)
+{
+ __pOptionMenuPresenter->ClearFocus(__currentFocusedIndex);
+ __isFocused = false;
+ return true;
+}
+
+void
+_OptionMenu::OnDrawFocus(void)
+{
+ if (!__isFocused)
+ {
+ __isFocused = true;
+ __currentFocusedIndex = -1;
+ __pOptionMenuPresenter->DrawFocus(__currentFocusedIndex);
+ }
+ return;
+}
+
+bool
+_OptionMenu::OnKeyPressed(const _Control &source, const _KeyInfo &keyInfo)
+{
+ if (&source != this)
+ {
+ return false;
+ }
+
+ _KeyCode keyCode = keyInfo.GetKeyCode();
+
+ int count = GetItemCount();
+
+ if(!__isFocused)
+ {
+ return false;
+ }
+
+ switch(keyCode)
+ {
+ case _KEY_RIGHT:
+ if (__currentFocusedIndex >= (count - 1))
+ {
+ __currentFocusedIndex = count - 1;
+ }
+ else
+ {
+ __currentFocusedIndex++;
+ }
+ break;
+
+ case _KEY_LEFT:
+ if (__currentFocusedIndex <= -1)
+ {
+ __currentFocusedIndex = -1;
+ }
+ else
+ {
+ __currentFocusedIndex--;
+ }
+ break;
+
+ case _KEY_ENTER:
+ __pOptionMenuPresenter->OnEnterKeyPressed(__currentFocusedIndex);
+
+ return true;
+
+ default :
+ return false;
+ }
+ __pOptionMenuPresenter->DrawFocus(__currentFocusedIndex);
+
+ return true;
+}
+
void
_OptionMenu::SetBoundsAllAccessibilityElement(void)
{
, __isHandlerPressed(false)
, __isClosing(false)
, __isAnimationStarted(false)
+ , __focusedIndex(-1)
, __pOptionMenuVE(null)
, __pThirtyThreeTimingFunction(null)
, __pSixtyTimingFunction(null)
arrowBounds.height = pHandleArrowBitmap->GetHeightF();
r = DrawResourceBitmap(canvas, arrowBounds, pHandleArrowBitmap);
+ __arrowBounds = arrowBounds;
SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
if (!isCustomHandleBitmap && (pHandleEffectBitmap!= null))
}
result
+_OptionMenuPresenter::DrawFocus(int index)
+{
+ ClearFocus(__focusedIndex);
+
+ result r = E_SUCCESS;
+
+ Canvas* pCanvas;
+ pCanvas = __pOptionMenu->GetCanvasN();
+
+ SysTryReturn(NID_UI_CTRL, (pCanvas != null), r, r, "[%s] Propagating.", GetErrorMessage(r));
+
+ FloatRectangle bounds;
+
+ if (index == -1)
+ {
+ bounds = __arrowBounds;
+ }
+ else
+ {
+ bounds = GetItemBounds(index);
+ }
+
+ Bitmap* pBitmap = null;
+ r = GET_BITMAP_CONFIG_N(FOCUSUI::FOCUS, BITMAP_PIXEL_FORMAT_ARGB8888, pBitmap);
+ SysTryCatch(NID_UI_CTRL, (pBitmap != null), , r, "[%s] Propagating.", GetErrorMessage(r));
+
+ if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBitmap))
+ {
+ r = pCanvas->DrawNinePatchedBitmap(bounds, *pBitmap);
+ }
+ else
+ {
+ r = pCanvas->DrawBitmap(bounds, *pBitmap);
+ }
+
+ __focusedIndex = index;
+
+ delete pCanvas;
+ delete pBitmap;
+
+ return r;
+
+CATCH:
+ delete pCanvas;
+
+ return r;
+}
+
+result
+_OptionMenuPresenter::ClearFocus(int index)
+{
+ result r = E_SUCCESS;
+ Canvas* pCanvas;
+
+ pCanvas = __pOptionMenu->GetCanvasN();
+ SysTryReturn(NID_UI_CTRL, (pCanvas != null), r, r, "[%s] Propagating.", GetErrorMessage(r));
+
+ Color background;
+ GET_COLOR_CONFIG(OPTIONMENU::ITEM_BG_NORMAL, background);
+
+ FloatRectangle bounds;
+
+ if (index == -1)
+ {
+ bounds = __arrowBounds;
+ }
+ else
+ {
+ bounds = GetItemBounds(index);
+ }
+
+ pCanvas->SetBackgroundColor(background);
+ pCanvas->Clear(bounds);
+
+ if (index == -1)
+ {
+ DrawHandler(*pCanvas);
+ }
+ else
+ {
+ DrawItem(*pCanvas, index);
+ }
+
+ DrawItemLine(*pCanvas);
+
+ delete pCanvas;
+ return r;
+}
+
+void
+_OptionMenuPresenter::OnEnterKeyPressed(int selectedIndex)
+{
+ if (selectedIndex == -1)
+ {
+ __isHandlerPressed = false;
+ Hide();
+ }
+ else
+ {
+ _OptionMenuItem* pItem = __pOptionMenuModel->GetItem(selectedIndex);
+ if (pItem != null)
+ {
+ if (pItem->HasSubItem() == true)
+ {
+ __pOptionMenu->ShowSubMenu(selectedIndex, *pItem);
+ }
+ else
+ {
+ // Fire Action Event
+ Hide();
+ __pOptionMenu->FireActionEvent(pItem->GetActionId());
+ }
+ }
+ }
+ return;
+}
+
+result
_OptionMenuPresenter::RefreshItem(int index)
{
if (index < 0 || index >= __pOptionMenuModel->GetItemCount())
return false;
}
- SysTryReturn(NID_UI_CTRL, (!__isAnimationStarted), false, E_SUCCESS, "[E_SUCCESS] Animation is in Progress.");
+ SysTryReturn(NID_UI_CTRL, (!__isAnimationStarted), false, E_SUCCESS, "[E_SUCCESS] Animation is in Progress.");
if (__pOptionMenu->IsSubMenuShown() == true)
{
_Tab::_Tab(void)
: __pTabPresenter(null)
, __style(_TAB_STYLE_TEXT)
+ , __currentHighlightedItemIndex(-1)
, __tabStatus(_TAB_STATUS_NORMAL)
, __pActionEvent(null)
, __pGestureLongPress(null)
__pTabPresenter->SetRecalculateItemBounds(true);
+ if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
+ {
+ __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
+ }
+ __currentHighlightedItemIndex = 0;
+
return __tabItems.Add(*pItem);
}
__pTabPresenter->SetRecalculateItemBounds(true);
+ if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
+ {
+ __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
+ }
+ __currentHighlightedItemIndex = 0;
+
return __tabItems.Add(*pItem);
}
__pTabPresenter->SetRecalculateItemBounds(true);
+ if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
+ {
+ __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
+ }
+ __currentHighlightedItemIndex = 0;
return __tabItems.Add(*pItem);
}
SetSelectedItemIndex(selectedIndex);
}
+ if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
+ {
+ __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
+ }
+ __currentHighlightedItemIndex = 0;
+
return r;
}
SetSelectedItemIndex(selectedIndex);
}
+ if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
+ {
+ __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
+ }
+ __currentHighlightedItemIndex = 0;
+
return r;
}
SetSelectedItemIndex(selectedIndex);
}
+ if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
+ {
+ __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
+ }
+ __currentHighlightedItemIndex = 0;
+
return r;
}
SetSelectedItemIndex(0);
+ if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
+ {
+ __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
+ }
+ if(GetItemCount() > 0)
+ {
+ __currentHighlightedItemIndex = 0;
+ }
+ else
+ {
+ __currentHighlightedItemIndex = -1;
+ }
+
return r;
}
result
_Tab::RemoveAllItems(void)
{
+ if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
+ {
+ __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
+ }
+ __currentHighlightedItemIndex = -1;
+
__pTabPresenter->SetRecalculateItemBounds(true);
SetSelectedItemIndex(0);
SetFirstDrawnItemIndex(-1);
return _TabStyle(__style);
}
+int
+_Tab::GetCurrentHighlightedItemIndex(void) const
+{
+ return __currentHighlightedItemIndex;
+}
+
void
_Tab::AddActionEventListener(const _IActionEventListener& listener)
{
return true;
}
+ if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
+ {
+ __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
+ }
+ __currentHighlightedItemIndex = -1;
+
return __pTabPresenter->OnTouchPressed(source, touchinfo);
}
return;
}
+bool
+_Tab::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
+{
+ if (this != &source)
+ {
+ return false;
+ }
+ _KeyCode keyCode = keyInfo.GetKeyCode();
+ int itemCount = __pTabPresenter->GetItemCount();
+ if(itemCount == 0)
+ {
+ return false;
+ }
+
+ if (keyCode == _KEY_RIGHT)
+ {
+ if (__currentHighlightedItemIndex < (itemCount - 1))
+ {
+ if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) != _TABITEM_STATUS_SELECTED)
+ {
+ __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
+ }
+
+ __currentHighlightedItemIndex++;
+
+ if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) != _TABITEM_STATUS_SELECTED)
+ {
+ __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_HIGHLIGHTED);
+ }
+ __pTabPresenter->ShiftToFocusedItem(__currentHighlightedItemIndex, _FOCUS_DIRECTION_MOVE_RIGHT);
+ }
+ return true;
+ }
+
+ if (keyCode == _KEY_LEFT)
+ {
+ if (__currentHighlightedItemIndex >= -1)
+ {
+ if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) != _TABITEM_STATUS_SELECTED)
+ {
+ __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
+ }
+ if (__currentHighlightedItemIndex == -1)
+ {
+ __currentHighlightedItemIndex = 0;
+ }
+ if (__currentHighlightedItemIndex > 0)
+ {
+ __currentHighlightedItemIndex--;
+ }
+ if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) != _TABITEM_STATUS_SELECTED)
+ {
+ __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_HIGHLIGHTED);
+ }
+ __pTabPresenter->ShiftToFocusedItem(__currentHighlightedItemIndex, _FOCUS_DIRECTION_MOVE_LEFT);
+ }
+ return true;
+ }
+
+ if (keyCode == _KEY_ENTER && __currentHighlightedItemIndex != -1)
+ {
+ __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_SELECTED);
+ __pTabPresenter->SetSelectedItemIndex(__currentHighlightedItemIndex);
+ Invalidate();
+ return true;
+ }
+ return false;
+}
+
+bool
+_Tab::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
+{
+ return false;
+}
+
+bool
+_Tab::OnFocusGained(const _Control & source)
+{
+ if (this != &source)
+ {
+ return false;
+ }
+
+ if(__pTabPresenter->GetItemCount() > 0)
+ {
+ __currentHighlightedItemIndex = 0;
+ }
+ else
+ {
+ __currentHighlightedItemIndex = -1;
+ }
+ return true;
+}
+
+bool
+_Tab::OnFocusLost(const _Control & source)
+{
+ if (this != &source)
+ {
+ return false;
+ }
+
+ if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
+ {
+ __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
+ }
+ __currentHighlightedItemIndex = -1;
+ Invalidate();
+ return true;
+}
+
+void
+_Tab::OnDrawFocus()
+{
+ if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) != _TABITEM_STATUS_SELECTED)
+ {
+ __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_HIGHLIGHTED);
+ }
+ __pTabPresenter->ShiftToFocusedItem(__currentHighlightedItemIndex, _FOCUS_DIRECTION_MOVE_LEFT);
+ return;
+}
+
void
_Tab::AddAccessibilityElement(const FloatRectangle& itemBounds, const String& itemText, _TabItemStatus status)
{
, __pFrontScrollingEffectBitmap(null)
, __pRearScrollingEffectBitmap(null)
, __pScrollingEffectBitmap(null)
+ , __pFocusBitmap(null)
, __pScrollingEffectVe(null)
, __pFlickAnimationTimer(null)
, __pScrollAnimationTimer(null)
__pScrollingEffectBitmap = null;
}
+ if(__pFocusBitmap)
+ {
+ delete __pFocusBitmap;
+ __pFocusBitmap = null;
+ }
+
if (__pScrollingEffectVe)
{
__pScrollingEffectVe->RemoveAllAnimations();
r = GET_BITMAP_CONFIG_N(TAB::TAB_BOUNCE_EFFECT_RIGHT, BITMAP_PIXEL_FORMAT_ARGB8888, __pRearScrollingEffectBitmap);
SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "Failed to locate overscrolling right bitmap.");
+ r = GET_BITMAP_CONFIG_N(FOCUSUI::FOCUS, BITMAP_PIXEL_FORMAT_ARGB8888, __pFocusBitmap);
+ SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "Failed to locate focus bitmap.");
+
delete pBitmap;
return r;
}
if (__isRecalculateNeeded)
{
__isRecalculateNeeded = false;
- CalcItemBounds();
+ CalculateItemBounds();
}
else if (__isFlickEnabled )
{
DrawItem(pCanvas);
}
+ if (__pTab->GetCurrentHighlightedItemIndex() > -1 && __pTab->IsFocused() && GetItemCount() > 0)
+ {
+ DrawResourceBitmap(*pCanvas, GetItemAt(__pTab->GetCurrentHighlightedItemIndex())->GetItemBounds(), __pFocusBitmap);
+ }
+
RefreshAccessibilityElement();
delete pCanvas;
if ((bounds.x + __moveDistance) > 0.0f)
{
- CalcItemBounds();
+ CalculateItemBounds();
ResetFlickAnimationTimer();
return;
}
return;
}
+result
+_TabPresenter::ShiftToFocusedItem(int itemIndex, _FocusDirectionMove direction)
+{
+ if (direction == _FOCUS_DIRECTION_MOVE_LEFT && itemIndex == __firstLoadedItemIndex - 1) //left key pressed
+ {
+ SetItemFit(__firstLoadedItemIndex - 1);
+ }
+ if (direction == _FOCUS_DIRECTION_MOVE_RIGHT && itemIndex == __lastLoadedItemIndex + 1) //right key pressed
+ {
+ SetItemFit(__firstLoadedItemIndex + 1);
+ }
+ if(itemIndex == 0) //when touched
+ {
+ SetItemFit(0);
+ }
+ __pTab->Invalidate();
+
+ return E_SUCCESS;
+}
+
void
_TabPresenter::DrawBadgeIcon(_TabItem* pDrawItem, Canvas* pCanvas)
{
}
void
-_TabPresenter::CalcItemBounds(void)
+_TabPresenter::CalculateItemBounds(void)
{
ClearLastResult();
return;
}
- CalcTabBounds(true);
+ CalculateTabBounds(true);
FloatRectangle bounds = __pTab->GetBoundsF();
}
void
-_TabPresenter::CalcTabBounds(bool isReset)
+_TabPresenter::CalculateTabBounds(bool isReset)
{
FloatRectangle bounds = __pTab->GetBoundsF();
{
SetItemStatus(pressedIndex, _TABITEM_STATUS_NORMAL);
}
- CalcItemBounds();
+ CalculateItemBounds();
__moveDistance = -(GetItemAt(__firstLoadedItemIndex)->GetItemBounds().x);
DrawHorizontal();
if (__isEditMode && __editItemIndex == __rearIndex)
{
FloatRectangle bounds(0.0f, 0.0f, 0.0f, 0.0f);
- if(__editItemIndex > 0)
+ if (__editItemIndex > 0)
{
pItem = GetItemAt((__editItemIndex - 1));
SysTryReturn(NID_UI_CTRL, pItem, false, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
}
else
{
- CalcItemBounds();
+ CalculateItemBounds();
}
}
SetLastLoadedItemIndex();
- CalcItemBounds();
+ CalculateItemBounds();
__moveDistance = -(__firstLoadedItemIndex * __itemWidth);
DrawHorizontal();
}
#include "FUi_Control.h"
#include "FUiCtrl_ColorChangeEvent.h"
#include "FUi_IAccessibilityListener.h"
+#include "FUiCtrl_ColorPickerPresenter.h"
namespace Tizen { namespace Ui {
class _AccessibilityElement;
virtual bool OnAccessibilityValueIncreased(const Tizen::Ui::_AccessibilityContainer&, const Tizen::Ui::_AccessibilityElement&);
virtual bool OnAccessibilityValueDecreased(const Tizen::Ui::_AccessibilityContainer&, const Tizen::Ui::_AccessibilityElement&);
+ virtual bool OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo);
+
+ bool OnFocusLost(const _Control& source);
+ virtual void OnDrawFocus(void);
+ virtual void OnFocusModeStateChanged(void);
+
private:
_ColorPicker(void);
Tizen::Ui::_AccessibilityElement* __pSaturationBarElement;
Tizen::Ui::_AccessibilityElement* __pLuminanceBarElement;
+
+ _ColorPickerComponentType __currentFocusedHandler;
+
+ _ColorPickerComponentType __previousFocusedHandler;
+
+ bool __isInFocusMode;
}; // _ColorPicker
}}} // Tizen::Ui::Controls
#define _FUI_CTRL_INTERNAL_COLORPICKER_PRESENTER_H_
#include <FBaseObject.h>
-#include "FUiCtrl_ColorPicker.h"
+#include "FUi_Control.h"
namespace Tizen { namespace Graphics
{
};
class _ColorPickerModel;
+class _ColorPicker;
class _ColorPickerPresenter
: public Tizen::Base::Object
void LoadDrawingProperties(const Tizen::Graphics::FloatRectangle& controlBounds);
+ void StepHandler(_ColorPickerComponentType index, bool increase);
+
+ result DrawFocus(_ColorPickerComponentType currentIndex, _ColorPickerComponentType prevIndex);
+
+ result ClearFocus(_ColorPickerComponentType index);
+
void OnChangeLayout(Tizen::Ui::_ControlOrientation orientation);
bool OnTouchPressed(const Tizen::Ui::_Control& source, const Tizen::Ui::_TouchInfo& touchinfo);
Tizen::Graphics::Bitmap* __pLandscapeCustomBitmap;
Tizen::Graphics::Bitmap* __pLandscapeLuminanceSliderBgBitmap;
Tizen::Graphics::Bitmap* __pLandscapeSaturationSliderBgBitmap;
+ Tizen::Graphics::Bitmap* __pFocusBitmap;
}; // _ColorPickerPresenter
}}} // Tizen::Ui::Controls
// _IActionEventListener
virtual void OnActionPerformed(const Tizen::Ui::_Control& source, int actionId);
+ bool OnFocusGained(const _Control& source);
+
+ bool OnFocusLost(const _Control& source);
+
+ void OnDrawFocus(void);
+
+ bool OnKeyPressed(const _Control &source, const _KeyInfo &keyInfo);
+
virtual ~_OptionMenu(void);
static _OptionMenu* CreateOptionMenuN(void);
int __subMenuIndex;
Tizen::Base::Collection::LinkedListT<_AccessibilityElement*> __accessibilityElements;
+
+ int __currentFocusedIndex;
+
+ bool __isFocused;
}; // _OptionMenu
}}} // Tizen::Ui::Controls
void OnFontInfoRequested(unsigned long& style, float& size);
Tizen::Graphics::Font* GetFont(void) const;
+ result DrawFocus(int index);
+ result ClearFocus(int index);
+ void OnEnterKeyPressed(int index);
+
private:
_OptionMenuPresenter(_OptionMenu* optionMenu);
bool __isAnimationStarted;
+ int __focusedIndex;
+
+ Tizen::Graphics::FloatRectangle __arrowBounds;
+
Tizen::Graphics::FloatMatrix4 _matrixOrigin;
Tizen::Graphics::FloatMatrix4 _matrixScale;
Tizen::Ui::Animations::_VisualElement* __pOptionMenuVE;
void SetStyle(int style);
_TabStyle GetStyle(void) const;
+ int GetCurrentHighlightedItemIndex(void) const;
+
void AddActionEventListener(const Tizen::Ui::Controls::_IActionEventListener& listener);
void RemoveActionEventListener(const Tizen::Ui::Controls::_IActionEventListener& listener);
virtual bool OnAccessibilityValueIncreased(const Tizen::Ui::_AccessibilityContainer&, const Tizen::Ui::_AccessibilityElement&);
virtual bool OnAccessibilityValueDecreased(const Tizen::Ui::_AccessibilityContainer&, const Tizen::Ui::_AccessibilityElement&);
+ virtual bool OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo);
+ virtual bool OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo);
+ bool OnFocusGained(const _Control& source);
+ bool OnFocusLost(const _Control& source);
+ virtual void OnDrawFocus(void);
+
private:
int GetItemIndex(int actionId);
bool CheckDuplicatedActionId(int actionId);
_TabPresenter* __pTabPresenter;
int __style;
+ int __currentHighlightedItemIndex;
_TabStatus __tabStatus;
Tizen::Base::Collection::ArrayList __tabItems;
class _TabItem;
class _FlickAnimation;
-const int _TIMER_COUNT = 3;
-const int _TAB_ITEM_MAXCOUNT = 14;
+// enum
+enum _FocusDirectionMove
+{
+ _FOCUS_DIRECTION_MOVE_LEFT = 0, /** Move Focus to Left */
+ _FOCUS_DIRECTION_MOVE_RIGHT /** Move Focus to Right*/
+};
+
/**
* @class _TabPresenter
* @brief
virtual bool OnAccessibilityFocusMovedNext(const Tizen::Ui::_AccessibilityContainer& control, const Tizen::Ui::_AccessibilityElement& element);
virtual bool OnAccessibilityFocusMovedPrevious(const Tizen::Ui::_AccessibilityContainer& control, const Tizen::Ui::_AccessibilityElement& element);
+ result ShiftToFocusedItem(int itemIndex, _FocusDirectionMove direction);
+
protected:
result SetModel(const _TabModel& tabModel);
void DrawBadgeIcon(_TabItem* pDrawItem, Tizen::Graphics::Canvas* pCanvas);
- void CalcItemBounds(void);
- void CalcTabBounds(bool isReset);
+ void CalculateItemBounds(void);
+ void CalculateTabBounds(bool isReset);
void StartFlickAnimation(void);
result StartFlickAnimationTimer(void);
Tizen::Graphics::FloatRectangle __dividerLine;
Tizen::Graphics::FloatRectangle __selectedLine;
+ static const int _TIMER_COUNT = 3;
+ static const int _TAB_ITEM_MAXCOUNT = 14;
+
struct ReorderAnimationInfo *__pAnimInfo[_TAB_ITEM_MAXCOUNT];
struct TimerInfo *__pTimerInfo[_TIMER_COUNT];
bool __isRecalculateNeeded;
Tizen::Graphics::Bitmap* __pFrontScrollingEffectBitmap;
Tizen::Graphics::Bitmap* __pRearScrollingEffectBitmap;
Tizen::Graphics::Bitmap* __pScrollingEffectBitmap;
+ Tizen::Graphics::Bitmap* __pFocusBitmap;
Tizen::Ui::Animations::_VisualElement* __pScrollingEffectVe;
Tizen::Base::Runtime::Timer* __pFlickAnimationTimer;
DECLARE_COLOR_CONFIG(ELEMENT_TEXT_PRESSED, 5);
DECLARE_COLOR_CONFIG(ELEMENT_TEXT_HIGHLIGHTED, 6);
DECLARE_COLOR_CONFIG(ELEMENT_TEXT_DISABLED, 7);
- DECLARE_IMAGE_CONFIG(CHECK_BG_BITMAP, 1);
- DECLARE_IMAGE_CONFIG(CHECK_MARK_BG_BITMAP, 2);
- DECLARE_IMAGE_CONFIG(CHECK_DIM_BITMAP, 3);
- DECLARE_IMAGE_CONFIG(BUTTON_RADIO_BITMAP, 4);
- DECLARE_IMAGE_CONFIG(BUTTON_RADIO_SELECTED_BITMAP, 5);
- DECLARE_IMAGE_CONFIG(BUTTON_OFF_BITMAP, 6);
- DECLARE_IMAGE_CONFIG(BUTTON_ON_BITMAP, 7);
- DECLARE_IMAGE_CONFIG(BUTTON_EXPAND_GROUP, 8);
- DECLARE_IMAGE_CONFIG(BUTTON_COLLAPSE_GROUP, 9);
+ DECLARE_COLOR_CONFIG(EXPANDABLE_ARROW_NORMAL, 8);
+ DECLARE_COLOR_CONFIG(EXPANDABLE_ARROW_DISABLED, 9);
+ DECLARE_COLOR_CONFIG(EXPANDABLE_ARROW_PRESSED, 10);
+ DECLARE_IMAGE_CONFIG(BUTTON_EXPAND_GROUP, 1);
+ DECLARE_IMAGE_CONFIG(BUTTON_COLLAPSE_GROUP, 2);
+ DECLARE_IMAGE_CONFIG(BUTTON_EXPAND_CLOSED_EFFECT, 3);
+ DECLARE_IMAGE_CONFIG(BUTTON_EXPAND_OPENED_EFFECT, 4);
DECLARE_SHAPE_CONFIG(EMPTY_LIST_TEXT_HEIGHT, 1);
DECLARE_SHAPE_CONFIG(LIST_ITEM_TEXT_SIZE, 2);
DECLARE_SHAPE_CONFIG(LIST_STYLE_NUMBER_X, 3);
DECLARE_UI_CONFIG(TABLEVIEW);
DECLARE_COLOR_CONFIG(BG_NORMAL, 1);
- DECLARE_COLOR_CONFIG(EXPANDABLE_ARROW_NORMAL, 2);
- DECLARE_COLOR_CONFIG(EXPANDABLE_ARROW_DISABLED, 3);
- DECLARE_COLOR_CONFIG(EXPANDABLE_ARROW_PRESSED, 4);
+// DECLARE_COLOR_CONFIG(EXPANDABLE_ARROW_NORMAL, 2);
+// DECLARE_COLOR_CONFIG(EXPANDABLE_ARROW_DISABLED, 3);
+// DECLARE_COLOR_CONFIG(EXPANDABLE_ARROW_PRESSED, 4);
DECLARE_COLOR_CONFIG(ITEM_DIVIDER_TOP_BG_NORMAL, 5);
DECLARE_COLOR_CONFIG(ITEM_DIVIDER_BOTTOM_BG_NORMAL, 6);
DECLARE_COLOR_CONFIG(ITEM_BG_NORMAL, 7);
DECLARE_IMAGE_CONFIG(CIRCLE_BUTTON_BG_EFFECT, 32);
// DECLARE_IMAGE_CONFIG(CIRCLE_BUTTON_REVEAL, 33);
DECLARE_IMAGE_CONFIG(SEARCH_ICON_NORMAL, 34);
- DECLARE_IMAGE_CONFIG(BUTTON_EXPAND_CLOSED_EFFECT, 35);
- DECLARE_IMAGE_CONFIG(BUTTON_EXPAND_OPENED_EFFECT, 36);
+// DECLARE_IMAGE_CONFIG(BUTTON_EXPAND_CLOSED_EFFECT, 35);
+// DECLARE_IMAGE_CONFIG(BUTTON_EXPAND_OPENED_EFFECT, 36);
DECLARE_IMAGE_CONFIG(CHECKBOX_BG_DISABLED, 37);
DECLARE_IMAGE_CONFIG(CHECKBOX_CHECK_MARK_DISABLED, 38);
DECLARE_IMAGE_CONFIG(RADIOBUTTON_NORMAL_DISABLED, 39);
DECLARE_FIXED_VALUE_CONFIG(ITEM_ANNEX_DIVIDER_MARGIN, 4);
DECLARE_END_UI_CONFIG(TABLEVIEW);
-#endif //_FUI_RESOURCE_TABLE_VIEW_CONFIG_H_
\ No newline at end of file
+#endif //_FUI_RESOURCE_TABLE_VIEW_CONFIG_H_
__pColorKeyTable->Add(ResourceKey(key), _TABLEVIEW::BG_NORMAL_COLOR);
}
{
- const char* key ="TABLEVIEW::EXPANDABLE_ARROW_NORMAL";
- __pColorKeyTable->Add(ResourceKey(key), _TABLEVIEW::EXPANDABLE_ARROW_NORMAL_COLOR);
- }
- {
- const char* key ="TABLEVIEW::EXPANDABLE_ARROW_DISABLED";
- __pColorKeyTable->Add(ResourceKey(key), _TABLEVIEW::EXPANDABLE_ARROW_DISABLED_COLOR);
- }
- {
- const char* key ="TABLEVIEW::EXPANDABLE_ARROW_PRESSED";
- __pColorKeyTable->Add(ResourceKey(key), _TABLEVIEW::EXPANDABLE_ARROW_PRESSED_COLOR);
- }
- {
const char* key ="TABLEVIEW::ITEM_DIVIDER_TOP_BG_NORMAL";
__pColorKeyTable->Add(ResourceKey(key), _TABLEVIEW::ITEM_DIVIDER_TOP_BG_NORMAL_COLOR);
}
ADD_COLOR_CONFIG(LISTITEM_DIVIDER_LEFT_HALF_COLOR, $B0223);
ADD_COLOR_CONFIG(LISTITEM_DIVIDER_RIGHT_HALF_COLOR, $B0222);
ADD_COLOR_CONFIG(EXPANDABLELIST_SUB_ITEM_BG_COLOR, $B0217);
+ ADD_COLOR_CONFIG(EXPANDABLE_ARROW_NORMAL, $F032L1);
+ ADD_COLOR_CONFIG(EXPANDABLE_ARROW_DISABLED, $F032L1D);
+ ADD_COLOR_CONFIG(EXPANDABLE_ARROW_PRESSED, $F032L1P);
ADD_COLOR_CONFIG(ELEMENT_TEXT_NORMAL, $F011L1);
ADD_COLOR_CONFIG(ELEMENT_TEXT_PRESSED, $F011L1P);
ADD_COLOR_CONFIG(ELEMENT_TEXT_HIGHLIGHTED, $F011L1P);
ADD_COLOR_CONFIG(ELEMENT_TEXT_DISABLED, $F011L1D);
ADD_IMAGE_CONFIG(BUTTON_EXPAND_GROUP, #00_button_expand_opened.png);
ADD_IMAGE_CONFIG(BUTTON_COLLAPSE_GROUP, #00_button_expand_closed.png);
+ ADD_IMAGE_CONFIG(BUTTON_EXPAND_CLOSED_EFFECT, #00_button_expand_closed_ef.png);
+ ADD_IMAGE_CONFIG(BUTTON_EXPAND_OPENED_EFFECT, #00_button_expand_opened_ef.png);
START_UI_CONFIG_MODE(720x1280);
ADD_SHAPE_CONFIG(EMPTY_LIST_TEXT_HEIGHT, 38);
START_UI_CONFIG(TABLEVIEW);
{
ADD_COLOR_CONFIG(BG_NORMAL, 0x00000000);
- ADD_COLOR_CONFIG(EXPANDABLE_ARROW_NORMAL, $F032L1);
- ADD_COLOR_CONFIG(EXPANDABLE_ARROW_DISABLED, $F032L1D);
- ADD_COLOR_CONFIG(EXPANDABLE_ARROW_PRESSED, $F032L1P);
ADD_COLOR_CONFIG(ITEM_DIVIDER_TOP_BG_NORMAL, $B0222);
ADD_COLOR_CONFIG(ITEM_DIVIDER_BOTTOM_BG_NORMAL, $B0223);
ADD_COLOR_CONFIG(ITEM_BG_NORMAL, 0x00000000);
ADD_IMAGE_CONFIG(CIRCLE_BUTTON_BG_EFFECT_DISABLED, #00_circle_bg_ef_dim.png);
ADD_IMAGE_CONFIG(CIRCLE_BUTTON_REVEAL_NORMAL, #00_button_right.png);
ADD_IMAGE_CONFIG(SEARCH_ICON_NORMAL, #00_search_icon.png);
- ADD_IMAGE_CONFIG(BUTTON_EXPAND_CLOSED_EFFECT, #00_button_expand_closed_ef.png);
- ADD_IMAGE_CONFIG(BUTTON_EXPAND_OPENED_EFFECT, #00_button_expand_opened_ef.png);
ADD_IMAGE_CONFIG(CHECKBOX_CHECK_MARK_PRESSED, #00_check_press.png);
ADD_IMAGE_CONFIG(CIRCLE_BUTTON_REVEAL_PRESSED, #00_button_right.png);
ADD_IMAGE_CONFIG(CIRCLE_BUTTON_REVEAL_HIGHLIGHTED, #00_button_right.png);
ADD_IMAGE_CONFIG(QUICK_MENU_BG_EFFECT, #00_quick_menu_bg_ef.#.png);
-
START_UI_CONFIG_MODE(720x1280);
ADD_DIMENSION_CONFIG(MIN_SIZE, 0, 0);
ADD_SHAPE_CONFIG(ITEM_DEFAULT_FONT_SIZE, 44);
projects / platform / framework / native / uifw.git / commitdiff