src/ui/controls/FUiCtrl_ButtonPresenter.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                FUiCtrl_ButtonPresenter.cpp
  19  * @brief               This is the implementation file for the _ButtonPresenter class.
  20  */
  21
  22 #include <FBaseErrorDefine.h>
  23 #include <FBaseSysLog.h>
  24 #include <FGrp_TextTextSimple.h>
  25 #include <FGrp_BitmapImpl.h>
  26 #include <FGrp_CanvasImpl.h>
  27 #include "FUi_CoordinateSystemUtils.h"
  28 #include "FUi_ResourceManager.h"
  29 #include "FUi_UiTouchEvent.h"
  30 #include "FUiAnim_VisualElement.h"
  31 #include "FUiCtrl_ButtonPresenter.h"
  32 #include "FUiCtrl_ButtonModel.h"
  33
  34 using namespace Tizen::Base;
  35 using namespace Tizen::Graphics;
  36 using namespace Tizen::Graphics::_Text;
  37 using namespace Tizen::App;
  38
  39 namespace Tizen { namespace Ui { namespace Controls
  40 {
  41 _ButtonPresenter::_ButtonPresenter(void)
  42         : __pButton(null)
  43         , __pButtonModel(null)
  44         , __previousEnabledState(false)
  45         , __touchMoveHandled(false)
  46         , __lazyDecode(false)
  47         , __showUnderlineBitmap(false)
  48         , __pFont(null)
  49         , __pTextObject(null)
  50         , __pBase(null)
  51         , __fontStyle(0)
  52         , __fontSize(0.0f)
  53         , __focusPrevStatus(_BUTTON_STATUS_NORMAL)
  54 {
  55
  56 }
  57
  58 _ButtonPresenter::~_ButtonPresenter(void)
  59 {
  60         if (__pButtonModel)
  61         {
  62                 delete __pButtonModel;
  63                 __pButtonModel = null;
  64         }
  65
  66         if (__pTextObject)
  67         {
  68                 delete __pTextObject;
  69                 __pTextObject = null;
  70         }
  71 }
  72
  73 result
  74 _ButtonPresenter::Construct(const _Button& button)
  75 {
  76         result r = E_SUCCESS;
  77
  78         __pButton = const_cast <_Button*>(&button);
  79         __fontStyle = FONT_STYLE_PLAIN;
  80
  81         GET_SHAPE_CONFIG(BUTTON::DEFAULT_FONT_SIZE, __pButton->GetOrientation(), __fontSize);
  82
  83         __pFont = __pButton->GetFallbackFont();
  84         r = GetLastResult();
  85         SysTryReturn(NID_UI_CTRL, __pFont, r, r, "[%s] Propagating.", GetErrorMessage(r));
  86
  87         __pTextObject = new (std::nothrow) TextObject();
  88         SysTryCatch(NID_UI_CTRL, __pTextObject != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
  89
  90         __pTextObject->Construct();
  91
  92         return E_SUCCESS;
  93
  94 CATCH:
  95
  96         delete __pTextObject;
  97         __pTextObject = null;
  98
  99         return r;
 100 }
 101
 102 result
 103 _ButtonPresenter::Install(void)
 104 {
 105         result r = E_SUCCESS;
 106
 107         __pBase = __pButton->GetVisualElement();
 108
 109         _ButtonModel* pModel = new (std::nothrow) _ButtonModel();
 110         SysTryReturn(NID_UI_CTRL, pModel, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 111
 112         r = SetModel(*pModel);
 113         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 114
 115         r = pModel->Construct();
 116         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 117
 118         return E_SUCCESS;
 119
 120 CATCH:
 121         delete pModel;
 122         return r;
 123 }
 124
 125 result
 126 _ButtonPresenter::SetModel(const _ButtonModel& buttonModel)
 127 {
 128         __pButtonModel = const_cast <_ButtonModel*>(&buttonModel);
 129
 130         return E_SUCCESS;
 131 }
 132
 133 result
 134 _ButtonPresenter::InitTextObject(void)
 135 {
 136         TextSimple* pSimpleText = null;
 137
 138         float leftMargin = __pButton->GetLeftMarginF();
 139         float topMargin = __pButton->GetTopMarginF();
 140         float rightMargin = __pButton->GetRightMarginF();
 141         float bottomMargin = __pButton->GetBottomMarginF();
 142
 143         float leftTouchMargin = __pButton->GetLeftTouchMarginF();
 144         float topTouchMargin = __pButton->GetTopTouchMarginF();
 145         float rightTouchMargin = __pButton->GetRightTouchMarginF();
 146         float bottomTouchMargin = __pButton->GetBottomTouchMarginF();
 147
 148         __pTextObject->RemoveAll(true);
 149
 150         pSimpleText = new (std::nothrow) TextSimple(const_cast<wchar_t*>(__pButton->GetText().GetPointer()), __pButton->GetText().GetLength());
 151         SysTryReturn(NID_UI_CTRL, pSimpleText, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 152
 153         __pTextObject->AppendElement(*pSimpleText);
 154         __pTextObject->SetWrap(TEXT_OBJECT_WRAP_TYPE_WORD);
 155         __pTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_ABBREV);
 156         SetTextSize(__pButton->GetTextSizeF());
 157         __pTextObject->SetFont(__pFont, 0, __pTextObject->GetTextLength());
 158         __pTextObject->SetAlignment(TEXT_OBJECT_ALIGNMENT_CENTER | TEXT_OBJECT_ALIGNMENT_MIDDLE);
 159         __pTextObject->SetBounds(FloatRectangle(leftMargin + leftTouchMargin, topMargin + topTouchMargin,
 160                         __pButton->GetBoundsF().width - (leftMargin + rightMargin) - (leftTouchMargin + rightTouchMargin),
 161                         __pButton->GetBoundsF().height - (topMargin + bottomMargin) - (topTouchMargin + bottomTouchMargin)));
 162         __pTextObject->Compose();
 163
 164         return E_SUCCESS;
 165 }
 166
 167 void
 168 _ButtonPresenter::OnFontChanged(Font* pFont)
 169 {
 170         __pFont = pFont;
 171
 172         return;
 173 }
 174
 175 void
 176 _ButtonPresenter::OnFontInfoRequested(unsigned long& style, int& size)
 177 {
 178         style = __fontStyle;
 179         size = _CoordinateSystemUtils::ConvertToInteger(__fontSize);
 180
 181         return;
 182 }
 183
 184 void
 185 _ButtonPresenter::OnFontInfoRequested(unsigned long& style, float& size)
 186 {
 187         style = __fontStyle;
 188         size =  __fontSize;
 189
 190         return;
 191 }
 192
 193 void
 194 _ButtonPresenter::SetTextSize(int size, unsigned long fontStyle)
 195 {
 196         float floatSize = _CoordinateSystemUtils::ConvertToFloat(size);
 197
 198         return SetTextSize(floatSize, fontStyle);
 199 }
 200
 201 void
 202 _ButtonPresenter::SetTextSize(float size, unsigned long fontStyle)
 203 {
 204         result r = E_SUCCESS;
 205
 206         if (__pFont == null)
 207         {
 208                 return;
 209         }
 210
 211         bool isStrikeOut = __pFont->IsStrikeOut();
 212         bool isUnderLine = __pFont->IsUnderlined();
 213
 214         if (__pFont->IsItalic())
 215         {
 216                 fontStyle |= FONT_STYLE_ITALIC;
 217         }
 218
 219         if (__pFont->IsBold())
 220         {
 221                 fontStyle |= FONT_STYLE_BOLD;
 222         }
 223
 224         __fontStyle = fontStyle;
 225         __fontSize = size;
 226
 227         __pFont = __pButton->GetFallbackFont();
 228
 229         r = GetLastResult();
 230         SysTryReturnVoidResult(NID_UI_CTRL, __pFont, r, "[%s] Propagating.", GetErrorMessage(r));
 231
 232         __pFont->SetStrikeOut(isStrikeOut);
 233         __pFont->SetUnderline(isUnderLine);
 234
 235         return;
 236 }
 237
 238 void
 239 _ButtonPresenter::SetFontInfo(unsigned long style, int size)
 240 {
 241         float floatSize = _CoordinateSystemUtils::ConvertToFloat(size);
 242
 243         return SetFontInfo(style, floatSize);
 244 }
 245
 246 void
 247 _ButtonPresenter::SetFontInfo(unsigned long style, float size)
 248 {
 249         __fontStyle = style;
 250         __fontSize = size;
 251
 252         return;
 253 }
 254
 255 TextObject*
 256 _ButtonPresenter::GetTextObject(void) const
 257 {
 258         return __pTextObject;
 259 }
 260
 261 Font*
 262 _ButtonPresenter::GetFont(void) const
 263 {
 264         return __pFont;
 265 }
 266
 267 void
 268 _ButtonPresenter::Draw(void)
 269 {
 270         _ButtonStatus status = __pButton->GetButtonStatus();
 271
 272         Bitmap* pToolbarItemBackgroundBitmap = __pButton->GetToolbarItemBackgroundBitmap(status);
 273
 274         if (pToolbarItemBackgroundBitmap)
 275         {
 276                 DrawToolbarItemBackground();
 277         }
 278         else
 279         {
 280                 DrawBackground();
 281         }
 282
 283         DrawBitmap();
 284         DrawText();
 285
 286         if (__showUnderlineBitmap && __pButton->GetToolbarItemBackgroundBitmap(status) == null)
 287         {
 288                 DrawUnderlineBitmap();
 289         }
 290
 291         return;
 292 }
 293
 294 void
 295 _ButtonPresenter::DrawBackground(void)
 296 {
 297         Canvas* pCanvas = null;
 298
 299         Bitmap* pBackgroundBitmap = null;
 300         Bitmap* pReplacementColorBackgroundBitmap = null;
 301         Bitmap* pBackgroundEffectBitmap = null;
 302         Bitmap* pHighlightedBackgroundBitmap = null;
 303         Bitmap* pHighlightedReplacementColorBackgroundBitmap = null;
 304         Color bgColor = __pButton->GetBackgroundColor();
 305         String imagePath = L"";
 306
 307         float leftTouchMargin = __pButton->GetLeftTouchMarginF();
 308         float topTouchMargin = __pButton->GetTopTouchMarginF();
 309         float rightTouchMargin = __pButton->GetRightTouchMarginF();
 310         float bottomTouchMargin = __pButton->GetBottomTouchMarginF();
 311
 312         FloatRectangle bounds(leftTouchMargin, topTouchMargin, __pButton->GetBoundsF().width - (leftTouchMargin + rightTouchMargin)
 313                         , __pButton->GetBoundsF().height - (topTouchMargin + bottomTouchMargin));
 314
 315         _ButtonStatus status = __pButton->GetButtonStatus();
 316
 317         if (__pButton->IsUserBackgroundBitmap(status))
 318         {
 319                 if (status == _BUTTON_STATUS_HIGHLIGHTED)
 320                 {
 321                         pBackgroundBitmap = __pButton->GetBackgroundBitmap(_BUTTON_STATUS_NORMAL);
 322                         pBackgroundEffectBitmap = __pButton->GetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL);
 323
 324                         pHighlightedBackgroundBitmap = __pButton->GetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED);
 325                 }
 326                 else
 327                 {
 328                         pBackgroundBitmap = __pButton->GetBackgroundBitmap(status);
 329                         pBackgroundEffectBitmap = __pButton->GetBackgroundEffectBitmap(status);
 330                 }
 331
 332                 if (pBackgroundBitmap)
 333                 {
 334                         if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundBitmap) == false)
 335                         {
 336                                 imagePath = _BitmapImpl::GetInstance(*pBackgroundBitmap)->GetFileName();
 337                         }
 338
 339                         if (imagePath.IsEmpty() == false && __pButton->GetText() == L""
 340                                         && __pButton->GetBitmap(_BUTTON_STATUS_NORMAL) == null && __pButton->GetBitmap(_BUTTON_STATUS_DISABLED) == null
 341                                         && __pButton->GetBitmap(_BUTTON_STATUS_PRESSED) == null && __pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED) == null)
 342                         {
 343                                 __pBase->SetBackgroundColor(_Colorf(
 344                                                 (float)bgColor.GetRed() / 255, (float)bgColor.GetGreen() / 255, (float)bgColor.GetBlue() / 255, (float)bgColor.GetAlpha() / 255));
 345                                 __pBase->SetImageSource(imagePath);
 346
 347                                 __lazyDecode = true;
 348                         }
 349                         else
 350                         {
 351                                 __pBase->SetImageSource(L"");
 352
 353                                 __lazyDecode = false;
 354
 355                                 pCanvas = __pButton->GetCanvasN();
 356                                 if (pCanvas == null)
 357                                 {
 358                                         SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 359                                         return;
 360                                 }
 361                                 pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 362                                 pCanvas->Clear();
 363
 364                                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundBitmap))// pBackgroundBitmap is 9
 365                                 {
 366                                         if (pBackgroundEffectBitmap)
 367                                         {
 368                                                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundEffectBitmap)) // 9,9
 369                                                 {
 370                                                         pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundBitmap);
 371                                                         if (__pButton->IsUserBackgroundEffectBitmap(status))
 372                                                         {
 373                                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundEffectBitmap);
 374                                                         }
 375                                                 }
 376                                                 else // 9,0
 377                                                 {
 378                                                         pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundBitmap);
 379                                                         if (__pButton->IsUserBackgroundEffectBitmap(status))
 380                                                         {
 381                                                                 pCanvas->DrawBitmap(bounds, *pBackgroundEffectBitmap, FloatRectangle(0.0f, 0.0f, pBackgroundEffectBitmap->GetWidthF(), pBackgroundEffectBitmap->GetHeightF()));
 382                                                         }
 383                                                 }
 384                                         }
 385                                         else // 9, X
 386                                         {
 387                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundBitmap);
 388                                         }
 389                                 }
 390                                 else // pBackgroundBitmap is not 9
 391                                 {
 392                                         if (pBackgroundEffectBitmap)
 393                                         {
 394                                                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundEffectBitmap)) // 0, 9
 395                                                 {
 396                                                         pCanvas->DrawBitmap(bounds, *pBackgroundBitmap, FloatRectangle(0.0f, 0.0f, pBackgroundBitmap->GetWidthF(), pBackgroundBitmap->GetHeightF()));
 397                                                         if (__pButton->IsUserBackgroundEffectBitmap(status))
 398                                                         {
 399                                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundEffectBitmap);
 400                                                         }
 401                                                 }
 402                                                 else // 0, 0
 403                                                 {
 404                                                         pCanvas->DrawBitmap(bounds, *pBackgroundBitmap, FloatRectangle(0.0f, 0.0f, pBackgroundBitmap->GetWidthF(), pBackgroundBitmap->GetHeightF()));
 405                                                         if (__pButton->IsUserBackgroundEffectBitmap(status))
 406                                                         {
 407                                                                 pCanvas->DrawBitmap(bounds, *pBackgroundEffectBitmap, FloatRectangle(0.0f, 0.0f, pBackgroundEffectBitmap->GetWidthF(), pBackgroundEffectBitmap->GetHeightF()));
 408                                                         }
 409                                                 }
 410                                         }
 411                                         else // 0, X
 412                                         {
 413                                                 pCanvas->DrawBitmap(bounds, *pBackgroundBitmap, FloatRectangle(0.0f, 0.0f, pBackgroundBitmap->GetWidthF(), pBackgroundBitmap->GetHeightF()));
 414                                         }
 415                                 }
 416                         }
 417
 418                         if (pHighlightedBackgroundBitmap)
 419                         {
 420                                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pHighlightedBackgroundBitmap))
 421                                 {
 422                                         pCanvas->DrawNinePatchedBitmap(bounds, *pHighlightedBackgroundBitmap);
 423                                 }
 424                                 else
 425                                 {
 426                                         pCanvas->DrawBitmap(bounds, *pHighlightedBackgroundBitmap,
 427                                                         FloatRectangle(0.0f, 0.0f, pHighlightedBackgroundBitmap->GetWidthF(), pHighlightedBackgroundBitmap->GetHeightF()));
 428                                 }
 429                         }
 430                 }
 431                 else // pBackgroundBitmap is null
 432                 {
 433                         pCanvas = __pButton->GetCanvasN();
 434                         if (pCanvas == null)
 435                         {
 436                                 SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 437                                 return;
 438                         }
 439                         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 440                         pCanvas->Clear();
 441
 442                         if (pBackgroundEffectBitmap)
 443                         {
 444                                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundEffectBitmap)) // X, 9
 445                                 {
 446                                         if (__pButton->IsUserBackgroundEffectBitmap(status))
 447                                         {
 448                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundEffectBitmap);
 449                                         }
 450                                 }
 451                                 else // X, 0
 452                                 {
 453                                         if (__pButton->IsUserBackgroundEffectBitmap(status))
 454                                         {
 455                                                 pCanvas->DrawBitmap(bounds, *pBackgroundEffectBitmap,
 456                                                                 FloatRectangle(0.0f, 0.0f, pBackgroundEffectBitmap->GetWidthF(), pBackgroundEffectBitmap->GetHeightF()));
 457                                         }
 458                                 }
 459                         }
 460                         else
 461                         {
 462                                 pCanvas->FillRectangle(__pButton->GetColor(status), bounds);
 463                         }
 464                 }
 465         }
 466         else // nobody set bitmap (default bitmap draw) // if (__pButton->IsUserBackgroundBitmap(status))
 467         {
 468                 pCanvas = __pButton->GetCanvasN();
 469                 if (pCanvas == null)
 470                 {
 471                         SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 472                         return;
 473                 }
 474                 pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 475                 pCanvas->Clear();
 476
 477                 if (status == _BUTTON_STATUS_DISABLED)
 478                 {
 479                         pBackgroundBitmap = __pButton->GetBackgroundBitmap(_BUTTON_STATUS_NORMAL);
 480
 481                         if(!__pButton->IsUserBackgroundBitmap(_BUTTON_STATUS_NORMAL))
 482                         {
 483                                 pBackgroundEffectBitmap = __pButton->GetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL);
 484                         }
 485
 486                         pReplacementColorBackgroundBitmap =
 487                                         _BitmapImpl::GetColorReplacedBitmapN(*pBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA), __pButton->GetColor(_BUTTON_STATUS_DISABLED));
 488                 }
 489                 else if (status == _BUTTON_STATUS_HIGHLIGHTED)
 490                 {
 491                         pBackgroundBitmap = __pButton->GetBackgroundBitmap(_BUTTON_STATUS_NORMAL);
 492
 493                         if(!__pButton->IsUserBackgroundBitmap(_BUTTON_STATUS_NORMAL))
 494                         {
 495                                 pBackgroundEffectBitmap = __pButton->GetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL);
 496                         }
 497
 498                         pReplacementColorBackgroundBitmap =
 499                                         _BitmapImpl::GetColorReplacedBitmapN(*pBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA), __pButton->GetColor(_BUTTON_STATUS_NORMAL));
 500
 501                         pHighlightedBackgroundBitmap = __pButton->GetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED);
 502
 503                         pHighlightedReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pHighlightedBackgroundBitmap,
 504                                         Color::GetColor(COLOR_ID_MAGENTA), __pButton->GetColor(_BUTTON_STATUS_HIGHLIGHTED));
 505                 }
 506                 else
 507                 {
 508                         pBackgroundBitmap = __pButton->GetBackgroundBitmap(status);
 509                         pBackgroundEffectBitmap = __pButton->GetBackgroundEffectBitmap(status);
 510                         pReplacementColorBackgroundBitmap =
 511                                         _BitmapImpl::GetColorReplacedBitmapN(*pBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA), __pButton->GetColor(status));
 512                 }
 513
 514                 if (pReplacementColorBackgroundBitmap)
 515                 {
 516                         if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pReplacementColorBackgroundBitmap))
 517                         {
 518                                 if (pBackgroundEffectBitmap)
 519                                 {
 520                                         if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundEffectBitmap))
 521                                         {
 522                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pReplacementColorBackgroundBitmap);
 523                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundEffectBitmap);
 524                                         }
 525                                         else
 526                                         {
 527                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pReplacementColorBackgroundBitmap);
 528                                                 pCanvas->DrawBitmap(bounds, *pBackgroundEffectBitmap,
 529                                                                 FloatRectangle(0.0f, 0.0f, pBackgroundEffectBitmap->GetWidthF(), pBackgroundEffectBitmap->GetHeightF()));
 530                                         }
 531                                 }
 532                                 else
 533                                 {
 534                                         pCanvas->DrawNinePatchedBitmap(bounds, *pReplacementColorBackgroundBitmap);
 535                                 }
 536                         }
 537                         else
 538                         {
 539                                 if (pBackgroundEffectBitmap)
 540                                 {
 541                                         if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundEffectBitmap))
 542                                         {
 543                                                 pCanvas->DrawBitmap(bounds, *pReplacementColorBackgroundBitmap,
 544                                                                 FloatRectangle(0.0f, 0.0f, pReplacementColorBackgroundBitmap->GetWidthF(), pReplacementColorBackgroundBitmap->GetHeightF()));
 545                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundEffectBitmap);
 546                                         }
 547                                         else
 548                                         {
 549                                                 pCanvas->DrawBitmap(bounds, *pReplacementColorBackgroundBitmap,
 550                                                                 FloatRectangle(0.0f, 0.0f, pReplacementColorBackgroundBitmap->GetWidthF(), pReplacementColorBackgroundBitmap->GetHeightF()));
 551                                                 pCanvas->DrawBitmap(bounds, *pBackgroundEffectBitmap,
 552                                                                 FloatRectangle(0.0f, 0.0f, pBackgroundEffectBitmap->GetWidthF(), pBackgroundEffectBitmap->GetHeightF()));
 553                                         }
 554                                 }
 555                                 else
 556                                 {
 557                                         pCanvas->DrawBitmap(bounds, *pReplacementColorBackgroundBitmap,
 558                                                         FloatRectangle(0.0f, 0.0f, pReplacementColorBackgroundBitmap->GetWidthF(), pReplacementColorBackgroundBitmap->GetHeightF()));
 559                                 }
 560                         }
 561                 }
 562                 else
 563                 {
 564                         if (pBackgroundEffectBitmap)
 565                         {
 566                                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundEffectBitmap))
 567                                 {
 568                                         pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundEffectBitmap);
 569                                 }
 570                                 else
 571                                 {
 572                                         pCanvas->DrawBitmap(bounds, *pBackgroundEffectBitmap,
 573                                                         FloatRectangle(0.0f, 0.0f, pBackgroundEffectBitmap->GetWidthF(), pBackgroundEffectBitmap->GetHeightF()));
 574                                 }
 575                         }
 576                         else
 577                         {
 578                                 if (status == _BUTTON_STATUS_DISABLED)
 579                                 {
 580                                         pCanvas->FillRectangle(__pButton->GetColor(_BUTTON_STATUS_NORMAL), bounds);
 581                                 }
 582                                 else
 583                                 {
 584                                         pCanvas->FillRectangle(__pButton->GetColor(status), bounds);
 585                                 }
 586                         }
 587                 }
 588
 589                 if (pHighlightedReplacementColorBackgroundBitmap)
 590                 {
 591                         if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pHighlightedReplacementColorBackgroundBitmap))
 592                         {
 593                                 pCanvas->DrawNinePatchedBitmap(bounds, *pHighlightedReplacementColorBackgroundBitmap);
 594                         }
 595                         else
 596                         {
 597                                 pCanvas->DrawBitmap(bounds, *pHighlightedReplacementColorBackgroundBitmap,
 598                                                 FloatRectangle(0.0f, 0.0f, pHighlightedReplacementColorBackgroundBitmap->GetWidthF(), pHighlightedReplacementColorBackgroundBitmap->GetHeightF()));
 599                         }
 600                 }
 601         }
 602
 603         if (!__pButton->IsUserBackgroundBitmap(status))
 604         {
 605                 __pButton->UnloadBackgroundBitmap(status);
 606         }
 607
 608         if (!__pButton->IsUserBackgroundEffectBitmap(status))
 609         {
 610                 __pButton->UnloadBackgroundEffectBitmap(status);
 611         }
 612
 613         if (pCanvas)
 614         {
 615                 delete pCanvas;
 616         }
 617
 618         delete pReplacementColorBackgroundBitmap;
 619
 620         return;
 621 }
 622
 623 void
 624 _ButtonPresenter::DrawToolbarItemBackground(void)
 625 {
 626         float leftTouchMargin = __pButton->GetLeftTouchMarginF();
 627         float topTouchMargin = __pButton->GetTopTouchMarginF();
 628         float rightTouchMargin = __pButton->GetRightTouchMarginF();
 629         float bottomTouchMargin = __pButton->GetBottomTouchMarginF();
 630
 631         _ButtonStatus status = __pButton->GetButtonStatus();
 632         Bitmap* pToolbarItemBackgroundBitmap = __pButton->GetToolbarItemBackgroundBitmap(status);
 633
 634         if (pToolbarItemBackgroundBitmap)
 635         {
 636                 Canvas* pCanvas = __pButton->GetCanvasN();
 637
 638                 if (pCanvas == null)
 639                 {
 640                         SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 641                         return;
 642                 }
 643
 644                 pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 645                 pCanvas->Clear();
 646
 647                 FloatRectangle bounds(leftTouchMargin, topTouchMargin, __pButton->GetBoundsF().width - (leftTouchMargin + rightTouchMargin),
 648                                 __pButton->GetBoundsF().height - (topTouchMargin + bottomTouchMargin));
 649
 650                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pToolbarItemBackgroundBitmap))
 651                 {
 652                         pCanvas->DrawNinePatchedBitmap(bounds, *pToolbarItemBackgroundBitmap);
 653                 }
 654                 else
 655                 {
 656                         pCanvas->DrawBitmap(bounds, *pToolbarItemBackgroundBitmap,
 657                                         FloatRectangle(0.0f, 0.0f, pToolbarItemBackgroundBitmap->GetWidthF(), pToolbarItemBackgroundBitmap->GetHeightF()));
 658                 }
 659
 660                 delete pCanvas;
 661         }
 662
 663         return;
 664 }
 665
 666 void
 667 _ButtonPresenter::DrawBitmap(void)
 668 {
 669         Canvas* pCanvas = null;
 670
 671         _ButtonStatus status = __pButton->GetButtonStatus();
 672
 673         Bitmap* pBitmap = __pButton->GetBitmap(status);
 674         Bitmap* pNormalBitmap = __pButton->GetBitmap(_BUTTON_STATUS_NORMAL);
 675
 676         Bitmap* pEffectBitmap = __pButton->GetEffectBitmap(status);
 677         Bitmap* pNormalEffectBitmap = __pButton->GetEffectBitmap(_BUTTON_STATUS_NORMAL);
 678
 679         float leftTouchMargin = __pButton->GetLeftTouchMarginF();
 680         float topTouchMargin = __pButton->GetTopTouchMarginF();
 681         float rightTouchMargin = __pButton->GetRightTouchMarginF();
 682         float bottomTouchMargin = __pButton->GetBottomTouchMarginF();
 683
 684         FloatRectangle bounds(leftTouchMargin, topTouchMargin, __pButton->GetBoundsF().width - (leftTouchMargin + rightTouchMargin),
 685                         __pButton->GetBoundsF().height - (topTouchMargin + bottomTouchMargin));
 686
 687         if (pBitmap)
 688         {
 689                 pCanvas = __pButton->GetCanvasN();
 690
 691                 if (pCanvas == null)
 692                 {
 693                         SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 694                         return;
 695                 }
 696
 697                 if (__pButton->GetSizeF().width - __pButton->GetBitmapPositionF(status).x - rightTouchMargin < pBitmap->GetWidthF()
 698                                 || __pButton->GetSizeF().height - __pButton->GetBitmapPositionF(status).y - bottomTouchMargin < pBitmap->GetHeightF())
 699                 {
 700                         pCanvas->DrawBitmap(bounds, *pBitmap, FloatRectangle(0.0f, 0.0f, pBitmap->GetWidthF(), pBitmap->GetHeightF()));
 701
 702                         if (pEffectBitmap)
 703                         {
 704                                 pCanvas->DrawBitmap(bounds, *pEffectBitmap,
 705                                                 FloatRectangle(0.0f, 0.0f, pEffectBitmap->GetWidthF(), pEffectBitmap->GetHeightF()));
 706                         }
 707                 }
 708                 else
 709                 {
 710                         pCanvas->DrawBitmap(__pButton->GetBitmapPositionF(status), *pBitmap);
 711
 712                         if (pEffectBitmap)
 713                         {
 714                                 pCanvas->DrawBitmap(__pButton->GetEffectBitmapPositionF(status), *pEffectBitmap);
 715                         }
 716                 }
 717         }
 718         else if (pNormalBitmap)
 719         {
 720                 pCanvas = __pButton->GetCanvasN();
 721
 722                 if (pCanvas == null)
 723                 {
 724                         SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 725                         return;
 726                 }
 727
 728                 if (__pButton->GetSizeF().width - __pButton->GetBitmapPositionF(_BUTTON_STATUS_NORMAL).x - rightTouchMargin < pNormalBitmap->GetWidthF()
 729                                 || __pButton->GetSizeF().height - __pButton->GetBitmapPositionF(_BUTTON_STATUS_NORMAL).y - bottomTouchMargin < pNormalBitmap->GetHeightF())
 730                 {
 731                         pCanvas->DrawBitmap(bounds, *pNormalBitmap, FloatRectangle(0.0f, 0.0f, pNormalBitmap->GetWidthF(), pNormalBitmap->GetHeightF()));
 732
 733                         if (pNormalEffectBitmap)
 734                         {
 735                                 pCanvas->DrawBitmap(bounds, *pNormalEffectBitmap, FloatRectangle(0.0f, 0.0f, pNormalEffectBitmap->GetWidthF(), pNormalEffectBitmap->GetHeightF()));
 736                         }
 737                 }
 738                 else
 739                 {
 740                         pCanvas->DrawBitmap(__pButton->GetBitmapPositionF(_BUTTON_STATUS_NORMAL), *pNormalBitmap);
 741
 742                         if (pNormalEffectBitmap)
 743                         {
 744                                 pCanvas->DrawBitmap(__pButton->GetEffectBitmapPositionF(_BUTTON_STATUS_NORMAL), *pNormalEffectBitmap);
 745                         }
 746                 }
 747         }
 748
 749         delete pCanvas;
 750
 751         return;
 752 }
 753
 754 void
 755 _ButtonPresenter::DrawText(void)
 756 {
 757         //TextSimple* pSimpleText = null;
 758         TextObjectAlignment horizontalAlign = TEXT_OBJECT_ALIGNMENT_CENTER;
 759         TextObjectAlignment verticalAlign = TEXT_OBJECT_ALIGNMENT_MIDDLE;
 760
 761         float leftMargin = __pButton->GetLeftMarginF();
 762         float topMargin = __pButton->GetTopMarginF();
 763         float rightMargin = __pButton->GetRightMarginF();
 764         float bottomMargin = __pButton->GetBottomMarginF();
 765
 766         float leftTouchMargin = __pButton->GetLeftTouchMarginF();
 767         float topTouchMargin = __pButton->GetTopTouchMarginF();
 768         float rightTouchMargin = __pButton->GetRightTouchMarginF();
 769         float bottomTouchMargin = __pButton->GetBottomTouchMarginF();
 770
 771         Canvas* pCanvas = __pButton->GetCanvasN();
 772         if (pCanvas == null)
 773         {
 774                 SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 775                 return;
 776         }
 777
 778         switch (__pButton->GetTextHorizontalAlignment())
 779         {
 780         case ALIGNMENT_LEFT:
 781                 horizontalAlign = TEXT_OBJECT_ALIGNMENT_LEFT;
 782                 break;
 783         case ALIGNMENT_CENTER:
 784                 horizontalAlign = TEXT_OBJECT_ALIGNMENT_CENTER;
 785                 break;
 786         default:
 787                 horizontalAlign = TEXT_OBJECT_ALIGNMENT_RIGHT;
 788         }
 789
 790         switch (__pButton->GetTextVerticalAlignment())
 791         {
 792         case ALIGNMENT_TOP:
 793                 verticalAlign = TEXT_OBJECT_ALIGNMENT_TOP;
 794                 break;
 795         case ALIGNMENT_MIDDLE:
 796                 verticalAlign = TEXT_OBJECT_ALIGNMENT_MIDDLE;
 797                 break;
 798         default:
 799                 verticalAlign = TEXT_OBJECT_ALIGNMENT_BOTTOM;
 800         }
 801
 802         //__pTextObject->RemoveAll(true);
 803         //pSimpleText = new (std::nothrow) TextSimple(const_cast<wchar_t*>(__pButton->GetText().GetPointer()), __pButton->GetText().GetLength());
 804         //__pTextObject->AppendElement(*pSimpleText);
 805
 806         if (__pButton->UserDefinedText())
 807         {
 808                 __pTextObject->SetBounds(__pButton->GetUserDefinedTextAreaF());
 809         }
 810         else
 811         {
 812                 __pTextObject->SetBounds(FloatRectangle(leftMargin + leftTouchMargin, topMargin + topTouchMargin,
 813                                 __pButton->GetBoundsF().width - (leftMargin + rightMargin) - (leftTouchMargin + rightTouchMargin),
 814                                 __pButton->GetBoundsF().height - (topMargin + bottomMargin) - (topTouchMargin + bottomTouchMargin)));
 815         }
 816         __pTextObject->SetAlignment(horizontalAlign | verticalAlign);
 817
 818         __pTextObject->SetFont(__pFont, 0, __pTextObject->GetTextLength());
 819         __pTextObject->Compose();
 820
 821         float fontSize = 0.0f;
 822
 823         if (__pTextObject->GetTotalLineCount() >= 2)
 824         {
 825                 fontSize = __pButton->GetMultilineTextSizeF();
 826                 SetTextSize(fontSize);
 827
 828                 __pTextObject->SetFont(__pFont, 0, __pTextObject->GetTextLength());
 829                 __pTextObject->Compose();
 830         }
 831
 832         __pTextObject->SetForegroundColor(__pButton->GetTextColor(__pButton->GetButtonStatus()), 0, __pTextObject->GetTextLength());
 833         __pTextObject->Draw(*_CanvasImpl::GetInstance(*pCanvas));
 834
 835         delete pCanvas;
 836
 837         return;
 838 }
 839
 840 void
 841 _ButtonPresenter::DrawUnderlineBitmap(void)
 842 {
 843         float selectedBitmapMargin = 0.0f;
 844         float selectedBitmapHeight = 0.0f;
 845         float segmentedHeight = 0.0f;
 846
 847         float leftTouchMargin = __pButton->GetLeftTouchMarginF();
 848         float rightTouchMargin = __pButton->GetRightTouchMarginF();
 849         float bottomTouchMargin = __pButton->GetBottomTouchMarginF();
 850
 851         GET_SHAPE_CONFIG(HEADER::HEADER_ITEM_SELECTED_BITMAP_MARGIN, __pButton->GetOrientation(), selectedBitmapMargin);
 852         GET_SHAPE_CONFIG(HEADER::HEADER_ITEM_SELECTED_BITMAP_HEIGHT, __pButton->GetOrientation(), selectedBitmapHeight);
 853         GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_HEIGHT, __pButton->GetOrientation(), segmentedHeight);
 854
 855         Bitmap* pUnderlineBitmap = __pButton->GetUnderlineBitmap();
 856
 857         if (pUnderlineBitmap)
 858         {
 859                 Canvas* pCanvas = __pButton->GetCanvasN();
 860
 861                 if (pCanvas == null)
 862                 {
 863                         SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 864                         return;
 865                 }
 866
 867                 FloatRectangle bounds(selectedBitmapMargin + leftTouchMargin,
 868                                 __pButton->GetBoundsF().height -  bottomTouchMargin - selectedBitmapHeight,
 869                                 __pButton->GetBoundsF().width - selectedBitmapMargin * 2 - (leftTouchMargin + rightTouchMargin), selectedBitmapHeight);
 870
 871                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pUnderlineBitmap))
 872                 {
 873                         pCanvas->DrawNinePatchedBitmap(bounds, *pUnderlineBitmap);
 874                 }
 875                 else
 876                 {
 877                         pCanvas->DrawBitmap(bounds, *pUnderlineBitmap,
 878                                         FloatRectangle(0.0f, 0.0f, pUnderlineBitmap->GetWidthF(), pUnderlineBitmap->GetHeightF()));
 879                 }
 880
 881                 delete pCanvas;
 882         }
 883
 884         return;
 885 }
 886
 887 bool
 888 _ButtonPresenter::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
 889 {
 890         if (&source != __pButton)
 891         {
 892                 return false;
 893         }
 894
 895         if (!__pButton->IsEnabled())
 896         {
 897                 return true;
 898         }
 899
 900         if (__pButton->GetButtonStyle() == _BUTTON_STYLE_SEGMENT)
 901         {
 902                 return false;
 903         }
 904
 905         __touchMoveHandled = false;
 906         //_ButtonStatus status = __pButton->GetButtonStatus();
 907
 908         //if (status != _BUTTON_STATUS_SELECTED)
 909         //{
 910                 __pButton->SetButtonStatus(_BUTTON_STATUS_PRESSED);
 911         //}
 912
 913         __pButton->Draw();
 914         __pButton->Show();
 915
 916         return true;
 917 }
 918
 919 bool
 920 _ButtonPresenter::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
 921 {
 922         if (&source != __pButton)
 923         {
 924                 return false;
 925         }
 926
 927         if (!__pButton->IsEnabled())
 928         {
 929                 return true;
 930         }
 931
 932         if (__pButton->GetButtonStyle() == _BUTTON_STYLE_SEGMENT)
 933         {
 934                 return false;
 935         }
 936
 937         _ButtonStatus status = __pButton->GetButtonStatus();
 938
 939         if (status == _BUTTON_STATUS_NORMAL)
 940         {
 941                 return true;
 942         }
 943
 944         FloatPoint touchPoint = touchinfo.GetCurrentPosition();
 945
 946         touchPoint.x += source.GetClientBoundsF().x;
 947         touchPoint.y += source.GetClientBoundsF().y;
 948
 949         FloatRectangle bounds = __pButton->GetClientBoundsF();
 950
 951         __pButton->SetButtonStatus(_BUTTON_STATUS_NORMAL);
 952         __pButton->Invalidate();
 953
 954         if (bounds.Contains(touchPoint))
 955         {
 956                 PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pButton);
 957
 958                 __pButton->FireActionEvent();
 959         }
 960
 961         return true;
 962 }
 963
 964 bool
 965 _ButtonPresenter::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
 966 {
 967         if (&source != __pButton)
 968         {
 969                 return false;
 970         }
 971
 972         if (!__pButton->IsEnabled())
 973         {
 974                 return true;
 975         }
 976
 977         if (__pButton->GetButtonStyle() == _BUTTON_STYLE_SEGMENT)
 978         {
 979                 return false;
 980         }
 981
 982         FloatPoint touchPoint = touchinfo.GetCurrentPosition();
 983
 984         touchPoint.x += source.GetClientBoundsF().x;
 985         touchPoint.y += source.GetClientBoundsF().y;
 986
 987         FloatRectangle bounds = __pButton->GetClientBoundsF();
 988         bool isInButtonArea = bounds.Contains(touchPoint);
 989         _ButtonStatus oldStatus = __pButton->GetButtonStatus();
 990
 991         if (isInButtonArea && (__touchMoveHandled != true))
 992         {
 993                 __pButton->SetButtonStatus(_BUTTON_STATUS_PRESSED);
 994         }
 995         else
 996         {
 997                 __pButton->SetButtonStatus(_BUTTON_STATUS_NORMAL);
 998         }
 999
1000         if (__pButton->GetButtonStatus() != oldStatus)
1001         {
1002                 __pButton->Invalidate();
1003         }
1004
1005         return false;
1006 }
1007
1008 bool
1009 _ButtonPresenter::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
1010 {
1011         if (&source != __pButton)
1012         {
1013                 return false;
1014         }
1015
1016         if (!__pButton->IsEnabled())
1017         {
1018                 return true;
1019         }
1020
1021         if (__pButton->GetButtonStyle() == _BUTTON_STYLE_SEGMENT)
1022         {
1023                 return false;
1024         }
1025
1026         __pButton->SetButtonStatus(_BUTTON_STATUS_NORMAL);
1027         __pButton->Invalidate();
1028
1029         return true;
1030 }
1031
1032 void
1033 _ButtonPresenter::OnTouchMoveHandled(const _Control& control)
1034 {
1035         if (__touchMoveHandled == false)
1036         {
1037                 __touchMoveHandled = true;
1038                 __pButton->SetButtonStatus(_BUTTON_STATUS_NORMAL);
1039                 __pButton->Invalidate();
1040         }
1041
1042         return;
1043 }
1044
1045 bool
1046 _ButtonPresenter::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
1047 {
1048         return false;
1049 }
1050
1051 bool
1052 _ButtonPresenter::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
1053 {
1054         _KeyCode keyCode = keyInfo.GetKeyCode();
1055
1056         if (__pButton->IsFocusModeStateEnabled() == true && keyCode == _KEY_ENTER)
1057         {
1058                 __pButton->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
1059         }
1060
1061         return false;
1062 }
1063
1064 void
1065 _ButtonPresenter::OnAncestorEnableStateChanged(const _Control& control)
1066 {
1067         if (!__pButton->IsEnabled())
1068         {
1069                 return;
1070         }
1071
1072         if (__pButton->GetButtonStatus() == _BUTTON_STATUS_PRESSED)
1073         {
1074                 __pButton->SetButtonStatus(_BUTTON_STATUS_NORMAL);
1075                 __pButton->Invalidate();
1076         }
1077
1078         return;
1079 }
1080
1081 void
1082 _ButtonPresenter::OnDrawFocus(void)
1083 {
1084         if (__pButton->IsFocusModeStateEnabled() == false)
1085         {
1086                 __focusPrevStatus = __pButton->GetButtonStatus();
1087                 __pButton->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
1088                 __pButton->Invalidate();
1089         }
1090
1091         return;
1092 }
1093
1094 void
1095 _ButtonPresenter::OnChildControlFocusMoved(const _Control& control)
1096 {
1097         return;
1098 }
1099
1100 bool
1101 _ButtonPresenter::IsChildControlFocusManage(void) const
1102 {
1103         return true;
1104 }
1105
1106 void
1107 _ButtonPresenter::OnFocusableStateChanged(bool focusalbeState)
1108 {
1109         return;
1110 }
1111
1112 void
1113 _ButtonPresenter::OnFocusModeStateChanged(void)
1114 {
1115         __pButton->SetButtonStatus(__focusPrevStatus);
1116         __pButton->Invalidate();
1117
1118         return;
1119 }
1120
1121 bool
1122 _ButtonPresenter::OnFocusGained(const _Control& source)
1123 {
1124         if (__pButton->IsFocusModeStateEnabled() == true)
1125         {
1126                 __focusPrevStatus = __pButton->GetButtonStatus();
1127                 __pButton->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
1128                 __pButton->Invalidate();
1129         }
1130
1131         return true;
1132 }
1133
1134 bool
1135 _ButtonPresenter::OnFocusLost(const _Control& source)
1136 {
1137         __pButton->SetButtonStatus(__focusPrevStatus);
1138         __pButton->Invalidate();
1139
1140         return true;
1141 }
1142
1143 bool
1144 _ButtonPresenter::IsEnabledStateChanged(void)
1145 {
1146         bool __currentEnabledState = __pButton->GetEnableState();
1147         bool ret = false;
1148
1149         if (__currentEnabledState != __previousEnabledState)
1150         {
1151                 __previousEnabledState = __currentEnabledState;
1152                 ret = true;
1153         }
1154
1155         return ret;
1156 }
1157
1158 Canvas*
1159 _ButtonPresenter::OnCanvasRequestedN(const FloatRectangle& bounds)
1160 {
1161         Canvas* pCanvas = null;
1162
1163         if (__lazyDecode == true)
1164         {
1165                 Bitmap* pBackgroundBitmap = null;
1166                 _ButtonStatus status = __pButton->GetButtonStatus();
1167
1168                 if (__pButton->IsUserBackgroundBitmap(status))
1169                 {
1170                         if (status == _BUTTON_STATUS_HIGHLIGHTED)
1171                         {
1172                                 pBackgroundBitmap = __pButton->GetBackgroundBitmap(_BUTTON_STATUS_NORMAL);
1173                         }
1174                         else
1175                         {
1176                                 pBackgroundBitmap = __pButton->GetBackgroundBitmap(status);
1177                         }
1178                 }
1179
1180                 if (pBackgroundBitmap != null)
1181                 {
1182                         pBackgroundBitmap->IsNinePatchedBitmap();
1183                 }
1184
1185                 Draw();
1186
1187                 pCanvas = __pButton->GetCanvasN();
1188         }
1189
1190         return pCanvas;
1191 }
1192
1193 result
1194 _ButtonPresenter::ShowUnderlineBitmap(bool show)
1195 {
1196         __showUnderlineBitmap = show;
1197
1198         return E_SUCCESS;
1199 }
1200
1201 }}} // Tizen::Ui::Controls