src/ui/FUi_HorizontalBoxLayoutImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an ”AS IS” BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file                FUi_HorizontalBoxLayoutImpl.cpp
  19  * @brief       This is the implementation file for _HorizontalBoxLayoutImpl class.
  20  *
  21  * This file contains the implementation of _HorizontalBoxLayoutImpl class.
  22  */
  23
  24 #include "FUi_HorizontalBoxLayoutImpl.h"
  25 #include "FUi_CoordinateSystemUtils.h"
  26
  27 namespace Tizen { namespace Ui
  28 {
  29
  30 namespace
  31 {
  32 static const int CONVERT_ERROR_CODE = -1;
  33
  34 _Layout::LinearLayoutDirection
  35 ConvertEnum(HorizontalDirection val)
  36 {
  37         switch (val)
  38         {
  39         case HORIZONTAL_DIRECTION_RIGHTWARD:
  40                 return _Layout::LINEAR_LEFT_TO_RIGHT;
  41
  42         case HORIZONTAL_DIRECTION_LEFTWARD:
  43                 return _Layout::LINEAR_RIGHT_TO_LEFT;
  44
  45         default:
  46                 return _Layout::LINEAR_NONE_DIRECTION;
  47         }
  48 }
  49
  50 HorizontalDirection
  51 ConvertEnum(_Layout::LinearLayoutDirection val)
  52 {
  53         switch (val)
  54         {
  55         case _Layout::LINEAR_LEFT_TO_RIGHT:
  56                 return HORIZONTAL_DIRECTION_RIGHTWARD;
  57
  58         case _Layout::LINEAR_RIGHT_TO_LEFT:
  59                 return HORIZONTAL_DIRECTION_LEFTWARD;
  60
  61         default:
  62                 return static_cast <HorizontalDirection>(CONVERT_ERROR_CODE);
  63         }
  64 }
  65 }
  66
  67 // _HorizontalBoxLayoutImpl implementation
  68 _HorizontalBoxLayoutImpl::_HorizontalBoxLayoutImpl(HorizontalBoxLayout* pPublicLayout, _Layout::LinearLayout* pCoreLayout)
  69         : _LayoutImpl(pPublicLayout, pCoreLayout)
  70 {
  71 }
  72
  73 _HorizontalBoxLayoutImpl::~_HorizontalBoxLayoutImpl()
  74 {
  75 }
  76
  77 Tizen::Ui::LayoutType
  78 _HorizontalBoxLayoutImpl::GetLayoutType(void) const
  79 {
  80         return LAYOUT_HORIZONTAL_BOX;
  81 }
  82
  83 result
  84 _HorizontalBoxLayoutImpl::Construct(HorizontalDirection direction)
  85 {
  86         ClearLastResult();
  87
  88         _Layout::LinearLayoutDirection linearDirection = ConvertEnum(direction);
  89         SysTryReturn(NID_UI, linearDirection != _Layout::LINEAR_NONE_DIRECTION,
  90                                 E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid data.");
  91
  92         result r = GetCore().Initialize(_Layout::LINEAR_HORIZONTAL, linearDirection);
  93
  94         return r;
  95 }
  96
  97 result
  98 _HorizontalBoxLayoutImpl::GetDirection(HorizontalDirection& direction) const
  99 {
 100         ClearLastResult();
 101
 102         _Layout::LinearLayoutDirection internalDirection;
 103
 104         result r = GetCore().GetDirection(internalDirection);
 105         SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 106
 107         direction = ConvertEnum(internalDirection);
 108
 109         return r;
 110 }
 111
 112 result
 113 _HorizontalBoxLayoutImpl::SetVerticalAlignment(_ControlImpl& control, LayoutVerticalAlignment vertAlign)
 114 {
 115         result r = SetAlignment(control, LAYOUT_HORIZONTAL_ALIGN_LEFT, vertAlign);
 116
 117         return r;
 118 }
 119
 120 result
 121 _HorizontalBoxLayoutImpl::SetSpacing(_ControlImpl& control, float space)
 122 {
 123         ClearLastResult();
 124
 125         _Layout::LayoutItem& layoutItem = control.GetLayoutContainer();
 126
 127         result r = GetCore().SetItemSpacing(layoutItem, space);
 128
 129         return r;
 130 }
 131
 132 result
 133 _HorizontalBoxLayoutImpl::SetVerticalMargin(_ControlImpl& control, float top, float bottom)
 134 {
 135         result r = SetMargin(control, 0.0f, 0.0f, top, bottom);
 136
 137         return r;
 138 }
 139
 140 result
 141 _HorizontalBoxLayoutImpl::SetWidth(_ControlImpl& control, float width)
 142 {
 143         ClearLastResult();
 144
 145         result r = SetHorizontalFitPolicy(control, FIT_POLICY_FIXED);
 146         SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 147
 148         _Layout::LayoutRect rect;
 149         r = GetItemBaseRect(control, rect);
 150         SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 151
 152         rect.w = width;
 153         r = SetItemBaseRect(control, rect);
 154
 155         return r;
 156 }
 157
 158 result
 159 _HorizontalBoxLayoutImpl::SetItemHorizontalFitPolicy(_ControlImpl& control, FitPolicy policy)
 160 {
 161         result r = SetHorizontalFitPolicy(control, policy);
 162
 163         return r;
 164 }
 165
 166 result
 167 _HorizontalBoxLayoutImpl::SetHeight(_ControlImpl& control, float height)
 168 {
 169         ClearLastResult();
 170
 171         result r = SetVerticalFitPolicy(control, FIT_POLICY_FIXED);
 172         SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 173
 174         _Layout::LayoutRect rect;
 175         r = GetItemBaseRect(control, rect);
 176         SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 177
 178         rect.h = height;
 179         r = SetItemBaseRect(control, rect);
 180
 181         return r;
 182 }
 183
 184 result
 185 _HorizontalBoxLayoutImpl::SetItemVerticalFitPolicy(_ControlImpl& control, FitPolicy policy)
 186 {
 187         result r = SetVerticalFitPolicy(control, policy);
 188
 189         return r;
 190 }
 191
 192 result
 193 _HorizontalBoxLayoutImpl::SetWeight(_ControlImpl& control, float weight)
 194 {
 195         ClearLastResult();
 196
 197         _Layout::LayoutItem& layoutItem = control.GetLayoutContainer();
 198
 199         result r = GetCore().SetItemWeight(layoutItem, weight);
 200
 201         return r;
 202 }
 203
 204 _HorizontalBoxLayoutImpl*
 205 _HorizontalBoxLayoutImpl::CreateHorizontalBoxLayoutImplN(HorizontalBoxLayout* pPublicLayout, HorizontalDirection direction)
 206 {
 207         ClearLastResult();
 208
 209         _Layout::LinearLayout* pCoreLayout = null;
 210         _HorizontalBoxLayoutImpl* pImplLayout = null;
 211         result r = E_SUCCESS;
 212
 213         pCoreLayout = _Layout::LinearLayout::CreateLinearLayoutN();
 214         r = GetLastResult();
 215         SysTryReturn(NID_UI, pCoreLayout != null, null, r, "[%s] Propagating.", GetErrorMessage(r));
 216
 217         pImplLayout = new (std::nothrow) _HorizontalBoxLayoutImpl(pPublicLayout, pCoreLayout);
 218         r = CheckConstruction(pCoreLayout, pImplLayout);
 219         SysTryReturn(NID_UI, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 220
 221         r = pImplLayout->Construct(direction);
 222         if (r != E_SUCCESS)
 223         {
 224                 delete pImplLayout;
 225                 SysTryReturn(NID_UI, false, null, E_INVALID_ARG, "[E_INVALID_ARG] The Direction is invalid.");
 226         }
 227
 228         return pImplLayout;
 229 }
 230
 231 const char*
 232 _HorizontalBoxLayoutImpl::GetPublicClassName(void) const
 233 {
 234         return "Tizen::Ui::HorizontalBoxLayout";
 235 }
 236
 237 const HorizontalBoxLayout&
 238 _HorizontalBoxLayoutImpl::GetPublic(void) const
 239 {
 240         return static_cast <const HorizontalBoxLayout&>(_LayoutImpl::GetPublic());
 241 }
 242
 243 HorizontalBoxLayout&
 244 _HorizontalBoxLayoutImpl::GetPublic(void)
 245 {
 246         return static_cast <HorizontalBoxLayout&>(_LayoutImpl::GetPublic());
 247 }
 248
 249 const _Layout::LinearLayout&
 250 _HorizontalBoxLayoutImpl::GetCore(void) const
 251 {
 252         return static_cast <const _Layout::LinearLayout&>(_LayoutImpl::GetCore());
 253 }
 254
 255 _Layout::LinearLayout&
 256 _HorizontalBoxLayoutImpl::GetCore(void)
 257 {
 258         return static_cast <_Layout::LinearLayout&>(_LayoutImpl::GetCore());
 259 }
 260
 261 const _HorizontalBoxLayoutImpl*
 262 _HorizontalBoxLayoutImpl::GetInstance(const HorizontalBoxLayout& layout)
 263 {
 264         return static_cast <const _HorizontalBoxLayoutImpl*>(_LayoutImpl::GetInstance(layout));
 265 }
 266
 267 _HorizontalBoxLayoutImpl*
 268 _HorizontalBoxLayoutImpl::GetInstance(HorizontalBoxLayout& layout)
 269 {
 270         return static_cast <_HorizontalBoxLayoutImpl*>(_LayoutImpl::GetInstance(layout));
 271 }
 272
 273 }} // Tizen::Ui