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::Base::Runtime;
  36 using namespace Tizen::Graphics;
  37 using namespace Tizen::Graphics::_Text;
  38 using namespace Tizen::App;
  39
  40 namespace Tizen { namespace Ui { namespace Controls
  41 {
  42 _ButtonPresenter::_ButtonPresenter(void)
  43         : __pButton(null)
  44         , __pButtonModel(null)
  45         , __previousEnabledState(false)
  46         , __touchMoveHandled(false)
  47         , __lazyDecode(false)
  48         , __showUnderlineBitmap(false)
  49         , __pFont(null)
  50         , __pTextObject(null)
  51         , __pBase(null)
  52         , __fontStyle(0)
  53         , __fontSize(0.0f)
  54         , __pTextSlideTimer(null)
  55         , __textRect(FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f))
  56         , __pTabLargeSelectedBitmap(null)
  57 {
  58
  59 }
  60
  61 _ButtonPresenter::~_ButtonPresenter(void)
  62 {
  63         if (__pButtonModel)
  64         {
  65                 delete __pButtonModel;
  66                 __pButtonModel = null;
  67         }
  68
  69         if (__pTextObject)
  70         {
  71                 delete __pTextObject;
  72                 __pTextObject = null;
  73         }
  74
  75         if (__pTextSlideTimer)
  76         {
  77                 delete __pTextSlideTimer;
  78                 __pTextSlideTimer = null;
  79         }
  80
  81         if (__pTabLargeSelectedBitmap)
  82         {
  83                 delete __pTabLargeSelectedBitmap;
  84                 __pTabLargeSelectedBitmap = null;
  85         }
  86 }
  87
  88 result
  89 _ButtonPresenter::Construct(const _Button& button)
  90 {
  91         result r = E_SUCCESS;
  92
  93         __pButton = const_cast <_Button*>(&button);
  94         __fontStyle = FONT_STYLE_PLAIN;
  95
  96         GET_SHAPE_CONFIG(BUTTON::DEFAULT_FONT_SIZE, __pButton->GetOrientation(), __fontSize);
  97
  98         __pFont = __pButton->GetFallbackFont();
  99         r = GetLastResult();
 100         SysTryReturn(NID_UI_CTRL, __pFont, r, r, "[%s] Propagating.", GetErrorMessage(r));
 101
 102         __pTextObject = new (std::nothrow) TextObject();
 103         SysTryCatch(NID_UI_CTRL, __pTextObject != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 104
 105         __pTextObject->Construct();
 106
 107         return E_SUCCESS;
 108
 109 CATCH:
 110
 111         delete __pTextObject;
 112         __pTextObject = null;
 113
 114         return r;
 115 }
 116
 117 result
 118 _ButtonPresenter::Install(void)
 119 {
 120         result r = E_SUCCESS;
 121
 122         __pBase = __pButton->GetVisualElement();
 123
 124         _ButtonModel* pModel = new (std::nothrow) _ButtonModel();
 125         SysTryReturn(NID_UI_CTRL, pModel, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 126
 127         r = SetModel(*pModel);
 128         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 129
 130         r = pModel->Construct();
 131         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 132
 133         return E_SUCCESS;
 134
 135 CATCH:
 136         delete pModel;
 137         return r;
 138 }
 139
 140 result
 141 _ButtonPresenter::SetModel(const _ButtonModel& buttonModel)
 142 {
 143         __pButtonModel = const_cast <_ButtonModel*>(&buttonModel);
 144
 145         return E_SUCCESS;
 146 }
 147
 148 result
 149 _ButtonPresenter::InitTextObject(void)
 150 {
 151         TextSimple* pSimpleText = null;
 152
 153         float leftMargin = __pButton->GetLeftMarginF();
 154         float topMargin = __pButton->GetTopMarginF();
 155         float rightMargin = __pButton->GetRightMarginF();
 156         float bottomMargin = __pButton->GetBottomMarginF();
 157
 158         float leftTouchMargin = __pButton->GetLeftTouchMarginF();
 159         float topTouchMargin = __pButton->GetTopTouchMarginF();
 160         float rightTouchMargin = __pButton->GetRightTouchMarginF();
 161         float bottomTouchMargin = __pButton->GetBottomTouchMarginF();
 162
 163         __pTextObject->RemoveAll(true);
 164
 165         pSimpleText = new (std::nothrow) TextSimple(const_cast<wchar_t*>(__pButton->GetText().GetPointer()), __pButton->GetText().GetLength());
 166         SysTryReturn(NID_UI_CTRL, pSimpleText, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 167
 168         __pTextObject->AppendElement(*pSimpleText);
 169         __pTextObject->SetWrap(TEXT_OBJECT_WRAP_TYPE_WORD);
 170         __pTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_ABBREV);
 171         SetTextSize(__pButton->GetTextSizeF());
 172         __pTextObject->SetFont(__pFont, 0, __pTextObject->GetTextLength());
 173         __pTextObject->SetAlignment(TEXT_OBJECT_ALIGNMENT_CENTER | TEXT_OBJECT_ALIGNMENT_MIDDLE);
 174         __pTextObject->SetBounds(FloatRectangle(leftMargin + leftTouchMargin, topMargin + topTouchMargin,
 175                         __pButton->GetBoundsF().width - (leftMargin + rightMargin) - (leftTouchMargin + rightTouchMargin),
 176                         __pButton->GetBoundsF().height - (topMargin + bottomMargin) - (topTouchMargin + bottomTouchMargin)));
 177         __pTextObject->Compose();
 178
 179         return E_SUCCESS;
 180 }
 181
 182 void
 183 _ButtonPresenter::OnFontChanged(Font* pFont)
 184 {
 185         __pFont = pFont;
 186
 187         return;
 188 }
 189
 190 void
 191 _ButtonPresenter::OnFontInfoRequested(unsigned long& style, int& size)
 192 {
 193         style = __fontStyle;
 194         size = _CoordinateSystemUtils::ConvertToInteger(__fontSize);
 195
 196         return;
 197 }
 198
 199 void
 200 _ButtonPresenter::OnFontInfoRequested(unsigned long& style, float& size)
 201 {
 202         style = __fontStyle;
 203         size =  __fontSize;
 204
 205         return;
 206 }
 207
 208 void
 209 _ButtonPresenter::SetTextSize(int size, unsigned long fontStyle)
 210 {
 211         float floatSize = _CoordinateSystemUtils::ConvertToFloat(size);
 212
 213         return SetTextSize(floatSize, fontStyle);
 214 }
 215
 216 void
 217 _ButtonPresenter::SetTextSize(float size, unsigned long fontStyle)
 218 {
 219         result r = E_SUCCESS;
 220
 221         if (__pFont == null)
 222         {
 223                 return;
 224         }
 225
 226         bool isStrikeOut = __pFont->IsStrikeOut();
 227         bool isUnderLine = __pFont->IsUnderlined();
 228
 229         if (__pFont->IsItalic())
 230         {
 231                 fontStyle |= FONT_STYLE_ITALIC;
 232         }
 233
 234         if (__pFont->IsBold())
 235         {
 236                 fontStyle |= FONT_STYLE_BOLD;
 237         }
 238
 239         __fontStyle = fontStyle;
 240         __fontSize = size;
 241
 242         __pFont = __pButton->GetFallbackFont();
 243
 244         r = GetLastResult();
 245         SysTryReturnVoidResult(NID_UI_CTRL, __pFont, r, "[%s] Propagating.", GetErrorMessage(r));
 246
 247         __pFont->SetStrikeOut(isStrikeOut);
 248         __pFont->SetUnderline(isUnderLine);
 249
 250         return;
 251 }
 252
 253 void
 254 _ButtonPresenter::SetFontInfo(unsigned long style, int size)
 255 {
 256         float floatSize = _CoordinateSystemUtils::ConvertToFloat(size);
 257
 258         return SetFontInfo(style, floatSize);
 259 }
 260
 261 void
 262 _ButtonPresenter::SetFontInfo(unsigned long style, float size)
 263 {
 264         __fontStyle = style;
 265         __fontSize = size;
 266
 267         return;
 268 }
 269
 270 TextObject*
 271 _ButtonPresenter::GetTextObject(void) const
 272 {
 273         return __pTextObject;
 274 }
 275
 276 Font*
 277 _ButtonPresenter::GetFont(void) const
 278 {
 279         return __pFont;
 280 }
 281
 282 void
 283 _ButtonPresenter::Draw(void)
 284 {
 285         _ButtonStatus status = __pButton->GetButtonStatus();
 286
 287         Bitmap* pToolbarItemBackgroundBitmap = __pButton->GetToolbarItemBackgroundBitmap(status);
 288
 289         if (pToolbarItemBackgroundBitmap)
 290         {
 291                 DrawToolbarItemBackground();
 292         }
 293         else
 294         {
 295                 DrawBackground();
 296         }
 297
 298         DrawSubTitleEffectBitmap();
 299         DrawBitmap();
 300
 301         if (!__pButton->GetText().IsEmpty())
 302         {
 303                 DrawText();
 304         }
 305
 306         if (__showUnderlineBitmap && __pButton->GetToolbarItemBackgroundBitmap(status) == null && status != _BUTTON_STATUS_PRESSED)
 307         {
 308                 DrawUnderlineBitmap();
 309         }
 310
 311         return;
 312 }
 313
 314 void
 315 _ButtonPresenter::DrawBackground(void)
 316 {
 317         Canvas* pCanvas = null;
 318
 319         Bitmap* pBackgroundBitmap = null;
 320         Bitmap* pReplacementColorBackgroundBitmap = null;
 321         Bitmap* pBackgroundEffectBitmap = null;
 322         Bitmap* pHighlightedBackgroundBitmap = null;
 323         Bitmap* pHighlightedReplacementColorBackgroundBitmap = null;
 324         Color bgColor = __pButton->GetBackgroundColor();
 325         String imagePath = L"";
 326
 327         float leftTouchMargin = __pButton->GetLeftTouchMarginF();
 328         float topTouchMargin = __pButton->GetTopTouchMarginF();
 329         float rightTouchMargin = __pButton->GetRightTouchMarginF();
 330         float bottomTouchMargin = __pButton->GetBottomTouchMarginF();
 331
 332         FloatRectangle bounds(leftTouchMargin, topTouchMargin, __pButton->GetBoundsF().width - (leftTouchMargin + rightTouchMargin)
 333                         , __pButton->GetBoundsF().height - (topTouchMargin + bottomTouchMargin));
 334
 335         _ButtonStatus status = __pButton->GetButtonStatus();
 336
 337         if (__pButton->IsUserBackgroundBitmap(status))
 338         {
 339                 if (status == _BUTTON_STATUS_HIGHLIGHTED)
 340                 {
 341                         pBackgroundBitmap = __pButton->GetBackgroundBitmap(_BUTTON_STATUS_NORMAL);
 342                         pBackgroundEffectBitmap = __pButton->GetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL);
 343
 344                         pHighlightedBackgroundBitmap = __pButton->GetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED);
 345                 }
 346                 else
 347                 {
 348                         pBackgroundBitmap = __pButton->GetBackgroundBitmap(status);
 349                         pBackgroundEffectBitmap = __pButton->GetBackgroundEffectBitmap(status);
 350                 }
 351
 352                 if (pBackgroundBitmap)
 353                 {
 354                         if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundBitmap) == false)
 355                         {
 356                                 imagePath = _BitmapImpl::GetInstance(*pBackgroundBitmap)->GetFileName();
 357                         }
 358
 359                         if (imagePath.IsEmpty() == false && __pButton->GetText() == L""
 360                                         && __pButton->GetBitmap(_BUTTON_STATUS_NORMAL) == null && __pButton->GetBitmap(_BUTTON_STATUS_DISABLED) == null
 361                                         && __pButton->GetBitmap(_BUTTON_STATUS_PRESSED) == null && __pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED) == null)
 362                         {
 363                                 __pBase->SetBackgroundColor(_Colorf(
 364                                                 (float)bgColor.GetRed() / 255, (float)bgColor.GetGreen() / 255, (float)bgColor.GetBlue() / 255, (float)bgColor.GetAlpha() / 255));
 365                                 __pBase->SetImageSource(imagePath);
 366
 367                                 __lazyDecode = true;
 368                         }
 369                         else
 370                         {
 371                                 __pBase->SetImageSource(L"");
 372
 373                                 __lazyDecode = false;
 374
 375                                 pCanvas = __pButton->GetCanvasN();
 376                                 if (pCanvas == null)
 377                                 {
 378                                         SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 379                                         return;
 380                                 }
 381                                 pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 382                                 pCanvas->Clear();
 383
 384                                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundBitmap))// pBackgroundBitmap is 9
 385                                 {
 386                                         if (pBackgroundEffectBitmap)
 387                                         {
 388                                                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundEffectBitmap)) // 9,9
 389                                                 {
 390                                                         pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundBitmap);
 391                                                         if (__pButton->IsUserBackgroundEffectBitmap(status))
 392                                                         {
 393                                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundEffectBitmap);
 394                                                         }
 395                                                 }
 396                                                 else // 9,0
 397                                                 {
 398                                                         pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundBitmap);
 399                                                         if (__pButton->IsUserBackgroundEffectBitmap(status))
 400                                                         {
 401                                                                 pCanvas->DrawBitmap(bounds, *pBackgroundEffectBitmap, FloatRectangle(0.0f, 0.0f, pBackgroundEffectBitmap->GetWidthF(), pBackgroundEffectBitmap->GetHeightF()));
 402                                                         }
 403                                                 }
 404                                         }
 405                                         else // 9, X
 406                                         {
 407                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundBitmap);
 408                                         }
 409                                 }
 410                                 else // pBackgroundBitmap is not 9
 411                                 {
 412                                         if (pBackgroundEffectBitmap)
 413                                         {
 414                                                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundEffectBitmap)) // 0, 9
 415                                                 {
 416                                                         pCanvas->DrawBitmap(bounds, *pBackgroundBitmap, FloatRectangle(0.0f, 0.0f, pBackgroundBitmap->GetWidthF(), pBackgroundBitmap->GetHeightF()));
 417                                                         if (__pButton->IsUserBackgroundEffectBitmap(status))
 418                                                         {
 419                                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundEffectBitmap);
 420                                                         }
 421                                                 }
 422                                                 else // 0, 0
 423                                                 {
 424                                                         pCanvas->DrawBitmap(bounds, *pBackgroundBitmap, FloatRectangle(0.0f, 0.0f, pBackgroundBitmap->GetWidthF(), pBackgroundBitmap->GetHeightF()));
 425                                                         if (__pButton->IsUserBackgroundEffectBitmap(status))
 426                                                         {
 427                                                                 pCanvas->DrawBitmap(bounds, *pBackgroundEffectBitmap, FloatRectangle(0.0f, 0.0f, pBackgroundEffectBitmap->GetWidthF(), pBackgroundEffectBitmap->GetHeightF()));
 428                                                         }
 429                                                 }
 430                                         }
 431                                         else // 0, X
 432                                         {
 433                                                 pCanvas->DrawBitmap(bounds, *pBackgroundBitmap, FloatRectangle(0.0f, 0.0f, pBackgroundBitmap->GetWidthF(), pBackgroundBitmap->GetHeightF()));
 434                                         }
 435                                 }
 436
 437                                 if (pHighlightedBackgroundBitmap)
 438                                 {
 439                                         if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pHighlightedBackgroundBitmap))
 440                                         {
 441                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pHighlightedBackgroundBitmap);
 442                                         }
 443                                         else
 444                                         {
 445                                                 pCanvas->DrawBitmap(bounds, *pHighlightedBackgroundBitmap,
 446                                                                 FloatRectangle(0.0f, 0.0f, pHighlightedBackgroundBitmap->GetWidthF(), pHighlightedBackgroundBitmap->GetHeightF()));
 447                                         }
 448                                 }
 449                         }
 450                 }
 451                 else // pBackgroundBitmap is null
 452                 {
 453                         pCanvas = __pButton->GetCanvasN();
 454                         if (pCanvas == null)
 455                         {
 456                                 SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 457                                 return;
 458                         }
 459                         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 460                         pCanvas->Clear();
 461
 462                         if (pBackgroundEffectBitmap)
 463                         {
 464                                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundEffectBitmap)) // X, 9
 465                                 {
 466                                         if (__pButton->IsUserBackgroundEffectBitmap(status))
 467                                         {
 468                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundEffectBitmap);
 469                                         }
 470                                 }
 471                                 else // X, 0
 472                                 {
 473                                         if (__pButton->IsUserBackgroundEffectBitmap(status))
 474                                         {
 475                                                 pCanvas->DrawBitmap(bounds, *pBackgroundEffectBitmap,
 476                                                                 FloatRectangle(0.0f, 0.0f, pBackgroundEffectBitmap->GetWidthF(), pBackgroundEffectBitmap->GetHeightF()));
 477                                         }
 478                                 }
 479                         }
 480                         else
 481                         {
 482                                 pCanvas->FillRectangle(__pButton->GetColor(status), bounds);
 483                         }
 484                 }
 485         }
 486         else // nobody set bitmap (default bitmap draw) // if (__pButton->IsUserBackgroundBitmap(status))
 487         {
 488                 __pBase->SetImageSource(L"");
 489
 490                 __lazyDecode = false;
 491
 492                 pCanvas = __pButton->GetCanvasN();
 493                 if (pCanvas == null)
 494                 {
 495                         SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 496                         return;
 497                 }
 498                 pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 499                 pCanvas->Clear();
 500
 501                 if (status == _BUTTON_STATUS_DISABLED)
 502                 {
 503                         pBackgroundBitmap = __pButton->GetBackgroundBitmap(_BUTTON_STATUS_NORMAL);
 504
 505                         if(!__pButton->IsUserBackgroundBitmap(_BUTTON_STATUS_NORMAL))
 506                         {
 507                                 pBackgroundEffectBitmap = __pButton->GetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL);
 508                         }
 509
 510                         pReplacementColorBackgroundBitmap =
 511                                         _BitmapImpl::GetColorReplacedBitmapN(*pBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA), __pButton->GetColor(_BUTTON_STATUS_DISABLED));
 512                 }
 513                 else if (status == _BUTTON_STATUS_HIGHLIGHTED)
 514                 {
 515                         pBackgroundBitmap = __pButton->GetBackgroundBitmap(_BUTTON_STATUS_NORMAL);
 516
 517                         if(!__pButton->IsUserBackgroundBitmap(_BUTTON_STATUS_NORMAL))
 518                         {
 519                                 pBackgroundEffectBitmap = __pButton->GetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL);
 520                         }
 521
 522                         pReplacementColorBackgroundBitmap =
 523                                         _BitmapImpl::GetColorReplacedBitmapN(*pBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA), __pButton->GetColor(_BUTTON_STATUS_NORMAL));
 524
 525                         pHighlightedBackgroundBitmap = __pButton->GetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED);
 526
 527                         pHighlightedReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pHighlightedBackgroundBitmap,
 528                                         Color::GetColor(COLOR_ID_MAGENTA), __pButton->GetColor(_BUTTON_STATUS_HIGHLIGHTED));
 529                 }
 530                 else
 531                 {
 532                         pBackgroundBitmap = __pButton->GetBackgroundBitmap(status);
 533                         pBackgroundEffectBitmap = __pButton->GetBackgroundEffectBitmap(status);
 534                         pReplacementColorBackgroundBitmap =
 535                                         _BitmapImpl::GetColorReplacedBitmapN(*pBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA), __pButton->GetColor(status));
 536                 }
 537
 538                 if (pReplacementColorBackgroundBitmap)
 539                 {
 540                         if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pReplacementColorBackgroundBitmap))
 541                         {
 542                                 if (pBackgroundEffectBitmap)
 543                                 {
 544                                         if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundEffectBitmap))
 545                                         {
 546                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pReplacementColorBackgroundBitmap);
 547                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundEffectBitmap);
 548                                         }
 549                                         else
 550                                         {
 551                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pReplacementColorBackgroundBitmap);
 552                                                 pCanvas->DrawBitmap(bounds, *pBackgroundEffectBitmap,
 553                                                                 FloatRectangle(0.0f, 0.0f, pBackgroundEffectBitmap->GetWidthF(), pBackgroundEffectBitmap->GetHeightF()));
 554                                         }
 555                                 }
 556                                 else
 557                                 {
 558                                         pCanvas->DrawNinePatchedBitmap(bounds, *pReplacementColorBackgroundBitmap);
 559                                 }
 560                         }
 561                         else
 562                         {
 563                                 if (pBackgroundEffectBitmap)
 564                                 {
 565                                         if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundEffectBitmap))
 566                                         {
 567                                                 pCanvas->DrawBitmap(bounds, *pReplacementColorBackgroundBitmap,
 568                                                                 FloatRectangle(0.0f, 0.0f, pReplacementColorBackgroundBitmap->GetWidthF(), pReplacementColorBackgroundBitmap->GetHeightF()));
 569                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundEffectBitmap);
 570                                         }
 571                                         else
 572                                         {
 573                                                 pCanvas->DrawBitmap(bounds, *pReplacementColorBackgroundBitmap,
 574                                                                 FloatRectangle(0.0f, 0.0f, pReplacementColorBackgroundBitmap->GetWidthF(), pReplacementColorBackgroundBitmap->GetHeightF()));
 575                                                 pCanvas->DrawBitmap(bounds, *pBackgroundEffectBitmap,
 576                                                                 FloatRectangle(0.0f, 0.0f, pBackgroundEffectBitmap->GetWidthF(), pBackgroundEffectBitmap->GetHeightF()));
 577                                         }
 578                                 }
 579                                 else
 580                                 {
 581                                         pCanvas->DrawBitmap(bounds, *pReplacementColorBackgroundBitmap,
 582                                                         FloatRectangle(0.0f, 0.0f, pReplacementColorBackgroundBitmap->GetWidthF(), pReplacementColorBackgroundBitmap->GetHeightF()));
 583                                 }
 584                         }
 585                 }
 586                 else
 587                 {
 588                         if (pBackgroundEffectBitmap)
 589                         {
 590                                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBackgroundEffectBitmap))
 591                                 {
 592                                         pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundEffectBitmap);
 593                                 }
 594                                 else
 595                                 {
 596                                         pCanvas->DrawBitmap(bounds, *pBackgroundEffectBitmap,
 597                                                         FloatRectangle(0.0f, 0.0f, pBackgroundEffectBitmap->GetWidthF(), pBackgroundEffectBitmap->GetHeightF()));
 598                                 }
 599                         }
 600                         else
 601                         {
 602                                 if (status == _BUTTON_STATUS_DISABLED)
 603                                 {
 604                                         pCanvas->FillRectangle(__pButton->GetColor(_BUTTON_STATUS_NORMAL), bounds);
 605                                 }
 606                                 else
 607                                 {
 608                                         pCanvas->FillRectangle(__pButton->GetColor(status), bounds);
 609                                 }
 610                         }
 611                 }
 612
 613                 if (pHighlightedReplacementColorBackgroundBitmap)
 614                 {
 615                         if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pHighlightedReplacementColorBackgroundBitmap))
 616                         {
 617                                 pCanvas->DrawNinePatchedBitmap(bounds, *pHighlightedReplacementColorBackgroundBitmap);
 618                         }
 619                         else
 620                         {
 621                                 pCanvas->DrawBitmap(bounds, *pHighlightedReplacementColorBackgroundBitmap,
 622                                                 FloatRectangle(0.0f, 0.0f, pHighlightedReplacementColorBackgroundBitmap->GetWidthF(), pHighlightedReplacementColorBackgroundBitmap->GetHeightF()));
 623                         }
 624                 }
 625         }
 626
 627         if (!__pButton->IsUserBackgroundBitmap(status))
 628         {
 629                 __pButton->UnloadBackgroundBitmap(status);
 630         }
 631
 632         if (!__pButton->IsUserBackgroundEffectBitmap(status))
 633         {
 634                 __pButton->UnloadBackgroundEffectBitmap(status);
 635         }
 636
 637         if (pCanvas)
 638         {
 639                 delete pCanvas;
 640         }
 641
 642         delete pReplacementColorBackgroundBitmap;
 643         delete pHighlightedReplacementColorBackgroundBitmap;
 644
 645         return;
 646 }
 647
 648 void
 649 _ButtonPresenter::DrawToolbarItemBackground(void)
 650 {
 651         Canvas* pCanvas = __pButton->GetCanvasN();
 652
 653         if (pCanvas == null)
 654         {
 655                 SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 656                 return;
 657         }
 658
 659         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 660         pCanvas->Clear();
 661
 662         float leftTouchMargin = __pButton->GetLeftTouchMarginF();
 663         float topTouchMargin = __pButton->GetTopTouchMarginF();
 664         float rightTouchMargin = __pButton->GetRightTouchMarginF();
 665         float bottomTouchMargin = __pButton->GetBottomTouchMarginF();
 666
 667         _ButtonStatus status = __pButton->GetButtonStatus();
 668         Bitmap* pToolbarItemBackgroundBitmap = __pButton->GetToolbarItemBackgroundBitmap(status);
 669
 670         if (pToolbarItemBackgroundBitmap)
 671         {
 672                 FloatRectangle bounds(leftTouchMargin, topTouchMargin, __pButton->GetBoundsF().width - (leftTouchMargin + rightTouchMargin),
 673                                 __pButton->GetBoundsF().height - (topTouchMargin + bottomTouchMargin));
 674
 675                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pToolbarItemBackgroundBitmap))
 676                 {
 677                         pCanvas->DrawNinePatchedBitmap(bounds, *pToolbarItemBackgroundBitmap);
 678                 }
 679                 else
 680                 {
 681                         pCanvas->DrawBitmap(bounds, *pToolbarItemBackgroundBitmap,
 682                                         FloatRectangle(0.0f, 0.0f, pToolbarItemBackgroundBitmap->GetWidthF(), pToolbarItemBackgroundBitmap->GetHeightF()));
 683                 }
 684         }
 685
 686         if (__pTabLargeSelectedBitmap)
 687         {
 688                 delete __pTabLargeSelectedBitmap;
 689                 __pTabLargeSelectedBitmap = null;
 690         }
 691
 692         __pTabLargeSelectedBitmap = new (std::nothrow) Bitmap();
 693
 694         if (__pButton->UserDefinedText())
 695         {
 696                 __pTabLargeSelectedBitmap->Construct(*pCanvas, __pButton->GetUserDefinedTextAreaF());
 697         }
 698         else
 699         {
 700                 __pTabLargeSelectedBitmap->Construct(*pCanvas, __textRect);
 701         }
 702
 703         delete pCanvas;
 704
 705         return;
 706 }
 707
 708 void
 709 _ButtonPresenter::DrawBitmap(void)
 710 {
 711         Canvas* pCanvas = null;
 712
 713         _ButtonStatus status = __pButton->GetButtonStatus();
 714
 715         Bitmap* pBitmap = __pButton->GetBitmap(status);
 716         Bitmap* pNormalBitmap = __pButton->GetBitmap(_BUTTON_STATUS_NORMAL);
 717
 718         Bitmap* pEffectBitmap = __pButton->GetEffectBitmap(status);
 719         Bitmap* pNormalEffectBitmap = __pButton->GetEffectBitmap(_BUTTON_STATUS_NORMAL);
 720
 721         float leftTouchMargin = __pButton->GetLeftTouchMarginF();
 722         float topTouchMargin = __pButton->GetTopTouchMarginF();
 723         float rightTouchMargin = __pButton->GetRightTouchMarginF();
 724         float bottomTouchMargin = __pButton->GetBottomTouchMarginF();
 725
 726         FloatRectangle bounds(leftTouchMargin, topTouchMargin, __pButton->GetBoundsF().width - (leftTouchMargin + rightTouchMargin),
 727                         __pButton->GetBoundsF().height - (topTouchMargin + bottomTouchMargin));
 728
 729         if (pBitmap)
 730         {
 731                 pCanvas = __pButton->GetCanvasN();
 732
 733                 if (pCanvas == null)
 734                 {
 735                         SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 736                         return;
 737                 }
 738
 739                 if (__pButton->GetSizeF().width - __pButton->GetBitmapPositionF(status).x - rightTouchMargin < pBitmap->GetWidthF()
 740                                 || __pButton->GetSizeF().height - __pButton->GetBitmapPositionF(status).y - bottomTouchMargin < pBitmap->GetHeightF())
 741                 {
 742                         pCanvas->DrawBitmap(bounds, *pBitmap, FloatRectangle(0.0f, 0.0f, pBitmap->GetWidthF(), pBitmap->GetHeightF()));
 743
 744                         if (pEffectBitmap)
 745                         {
 746                                 pCanvas->DrawBitmap(bounds, *pEffectBitmap,
 747                                                 FloatRectangle(0.0f, 0.0f, pEffectBitmap->GetWidthF(), pEffectBitmap->GetHeightF()));
 748                         }
 749                 }
 750                 else
 751                 {
 752                         pCanvas->DrawBitmap(__pButton->GetBitmapPositionF(status), *pBitmap);
 753
 754                         if (pEffectBitmap)
 755                         {
 756                                 pCanvas->DrawBitmap(__pButton->GetEffectBitmapPositionF(status), *pEffectBitmap);
 757                         }
 758                 }
 759         }
 760         else if (pNormalBitmap)
 761         {
 762                 pCanvas = __pButton->GetCanvasN();
 763
 764                 if (pCanvas == null)
 765                 {
 766                         SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 767                         return;
 768                 }
 769
 770                 if (__pButton->GetSizeF().width - __pButton->GetBitmapPositionF(_BUTTON_STATUS_NORMAL).x - rightTouchMargin < pNormalBitmap->GetWidthF()
 771                                 || __pButton->GetSizeF().height - __pButton->GetBitmapPositionF(_BUTTON_STATUS_NORMAL).y - bottomTouchMargin < pNormalBitmap->GetHeightF())
 772                 {
 773                         pCanvas->DrawBitmap(bounds, *pNormalBitmap, FloatRectangle(0.0f, 0.0f, pNormalBitmap->GetWidthF(), pNormalBitmap->GetHeightF()));
 774
 775                         if (pNormalEffectBitmap)
 776                         {
 777                                 pCanvas->DrawBitmap(bounds, *pNormalEffectBitmap, FloatRectangle(0.0f, 0.0f, pNormalEffectBitmap->GetWidthF(), pNormalEffectBitmap->GetHeightF()));
 778                         }
 779                 }
 780                 else
 781                 {
 782                         pCanvas->DrawBitmap(__pButton->GetBitmapPositionF(_BUTTON_STATUS_NORMAL), *pNormalBitmap);
 783
 784                         if (pNormalEffectBitmap)
 785                         {
 786                                 pCanvas->DrawBitmap(__pButton->GetEffectBitmapPositionF(_BUTTON_STATUS_NORMAL), *pNormalEffectBitmap);
 787                         }
 788                 }
 789         }
 790
 791         delete pCanvas;
 792
 793         return;
 794 }
 795
 796 void
 797 _ButtonPresenter::DrawText(void)
 798 {
 799         TimerForTitleSlideInit();
 800         //TextSimple* pSimpleText = null;
 801         TextObjectAlignment horizontalAlign = TEXT_OBJECT_ALIGNMENT_CENTER;
 802         TextObjectAlignment verticalAlign = TEXT_OBJECT_ALIGNMENT_MIDDLE;
 803
 804         float leftMargin = __pButton->GetLeftMarginF();
 805         float topMargin = __pButton->GetTopMarginF();
 806         float rightMargin = __pButton->GetRightMarginF();
 807         float bottomMargin = __pButton->GetBottomMarginF();
 808
 809         float leftTouchMargin = __pButton->GetLeftTouchMarginF();
 810         float topTouchMargin = __pButton->GetTopTouchMarginF();
 811         float rightTouchMargin = __pButton->GetRightTouchMarginF();
 812         float bottomTouchMargin = __pButton->GetBottomTouchMarginF();
 813
 814         Canvas* pCanvas = __pButton->GetCanvasN();
 815         if (pCanvas == null)
 816         {
 817                 SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 818                 return;
 819         }
 820
 821         switch (__pButton->GetTextHorizontalAlignment())
 822         {
 823         case ALIGNMENT_LEFT:
 824                 horizontalAlign = TEXT_OBJECT_ALIGNMENT_LEFT;
 825                 break;
 826         case ALIGNMENT_CENTER:
 827                 horizontalAlign = TEXT_OBJECT_ALIGNMENT_CENTER;
 828                 break;
 829         default:
 830                 horizontalAlign = TEXT_OBJECT_ALIGNMENT_RIGHT;
 831         }
 832
 833         switch (__pButton->GetTextVerticalAlignment())
 834         {
 835         case ALIGNMENT_TOP:
 836                 verticalAlign = TEXT_OBJECT_ALIGNMENT_TOP;
 837                 break;
 838         case ALIGNMENT_MIDDLE:
 839                 verticalAlign = TEXT_OBJECT_ALIGNMENT_MIDDLE;
 840                 break;
 841         default:
 842                 verticalAlign = TEXT_OBJECT_ALIGNMENT_BOTTOM;
 843         }
 844
 845         //__pTextObject->RemoveAll(true);
 846         //pSimpleText = new (std::nothrow) TextSimple(const_cast<wchar_t*>(__pButton->GetText().GetPointer()), __pButton->GetText().GetLength());
 847         //__pTextObject->AppendElement(*pSimpleText);
 848
 849         __textRect = FloatRectangle(leftMargin + leftTouchMargin, topMargin + topTouchMargin,
 850                         __pButton->GetBoundsF().width - (leftMargin + rightMargin) - (leftTouchMargin + rightTouchMargin),
 851                         __pButton->GetBoundsF().height - (topMargin + bottomMargin) - (topTouchMargin + bottomTouchMargin));
 852
 853         if (__pButton->UserDefinedText())
 854         {
 855                 __pTextObject->SetBounds(__pButton->GetUserDefinedTextAreaF());
 856         }
 857         else
 858         {
 859                 __pTextObject->SetBounds(__textRect);
 860         }
 861
 862         __pTextObject->SetAlignment(horizontalAlign | verticalAlign);
 863
 864         if (__pButton->GetButtonStatus() == _BUTTON_STATUS_SELECTED && __pButton->IsTabTextSlide())
 865         {
 866                 __pTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_SLIDE_LEFT);
 867         }
 868         else
 869         {
 870                 __pTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_ABBREV);
 871         }
 872
 873         __pTextObject->SetFont(__pFont, 0, __pTextObject->GetTextLength());
 874         __pTextObject->Compose();
 875
 876         float fontSize = 0.0f;
 877
 878         if (__pTextObject->GetTotalLineCount() >= 2)
 879         {
 880                 fontSize = __pButton->GetMultilineTextSizeF();
 881                 SetTextSize(fontSize);
 882
 883                 __pTextObject->SetFont(__pFont, 0, __pTextObject->GetTextLength());
 884                 __pTextObject->Compose();
 885         }
 886
 887         __pTextObject->SetForegroundColor(__pButton->GetTextColor(__pButton->GetButtonStatus()), 0, __pTextObject->GetTextLength());
 888
 889         if (__pTextObject->IsActionOn() == true)
 890         {
 891                 __pTextObject->DrawWithOffset(*_CanvasImpl::GetInstance(*pCanvas));
 892
 893                 DrawTabTextDimBitmap();
 894
 895                 TimerForTitleSlideStart();
 896         }
 897         else
 898         {
 899                 __pTextObject->Draw(*_CanvasImpl::GetInstance(*pCanvas));
 900         }
 901
 902
 903         delete pCanvas;
 904
 905         return;
 906 }
 907
 908 void
 909 _ButtonPresenter::DrawUnderlineBitmap(void)
 910 {
 911         float selectedBitmapMargin = 0.0f;
 912         float selectedBitmapHeight = 0.0f;
 913         float segmentedHeight = 0.0f;
 914
 915         float leftTouchMargin = __pButton->GetLeftTouchMarginF();
 916         float rightTouchMargin = __pButton->GetRightTouchMarginF();
 917         float bottomTouchMargin = __pButton->GetBottomTouchMarginF();
 918
 919         GET_SHAPE_CONFIG(HEADER::HEADER_ITEM_SELECTED_BITMAP_MARGIN, __pButton->GetOrientation(), selectedBitmapMargin);
 920         GET_SHAPE_CONFIG(HEADER::HEADER_ITEM_SELECTED_BITMAP_HEIGHT, __pButton->GetOrientation(), selectedBitmapHeight);
 921         GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_HEIGHT, __pButton->GetOrientation(), segmentedHeight);
 922
 923         Bitmap* pUnderlineBitmap = __pButton->GetUnderlineBitmap();
 924
 925         if (pUnderlineBitmap)
 926         {
 927                 Canvas* pCanvas = __pButton->GetCanvasN();
 928
 929                 if (pCanvas == null)
 930                 {
 931                         SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 932                         return;
 933                 }
 934
 935                 FloatRectangle bounds(selectedBitmapMargin + leftTouchMargin,
 936                                 __pButton->GetBoundsF().height -  bottomTouchMargin - selectedBitmapHeight,
 937                                 __pButton->GetBoundsF().width - selectedBitmapMargin * 2 - (leftTouchMargin + rightTouchMargin), selectedBitmapHeight);
 938
 939                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pUnderlineBitmap))
 940                 {
 941                         pCanvas->DrawNinePatchedBitmap(bounds, *pUnderlineBitmap);
 942                 }
 943                 else
 944                 {
 945                         pCanvas->DrawBitmap(bounds, *pUnderlineBitmap,
 946                                         FloatRectangle(0.0f, 0.0f, pUnderlineBitmap->GetWidthF(), pUnderlineBitmap->GetHeightF()));
 947                 }
 948
 949                 delete pCanvas;
 950         }
 951
 952         return;
 953 }
 954
 955 void
 956 _ButtonPresenter::DrawSubTitleEffectBitmap(void)
 957 {
 958         float leftTouchMargin = __pButton->GetLeftTouchMarginF();
 959         float topTouchMargin = __pButton->GetTopTouchMarginF();
 960         float rightTouchMargin = __pButton->GetRightTouchMarginF();
 961         float bottomTouchMargin = __pButton->GetBottomTouchMarginF();
 962
 963         Bitmap* pSubTitleEffectBitmap = __pButton->GetSubTitleEffectBitmap();
 964
 965         if (pSubTitleEffectBitmap)
 966         {
 967                 Canvas* pCanvas = __pButton->GetCanvasN();
 968
 969                 if (pCanvas == null)
 970                 {
 971                         SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 972                         return;
 973                 }
 974
 975                 FloatRectangle bounds(leftTouchMargin, topTouchMargin,
 976                                 __pButton->GetBoundsF().width - (leftTouchMargin + rightTouchMargin), __pButton->GetBoundsF().height - (topTouchMargin + bottomTouchMargin));
 977
 978                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pSubTitleEffectBitmap))
 979                 {
 980                         pCanvas->DrawNinePatchedBitmap(bounds, *pSubTitleEffectBitmap);
 981                 }
 982                 else
 983                 {
 984                         pCanvas->DrawBitmap(bounds, *pSubTitleEffectBitmap,
 985                                         FloatRectangle(0.0f, 0.0f, pSubTitleEffectBitmap->GetWidthF(), pSubTitleEffectBitmap->GetHeightF()));
 986                 }
 987
 988                 delete pCanvas;
 989         }
 990
 991         return;
 992 }
 993
 994 bool
 995 _ButtonPresenter::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
 996 {
 997         if (&source != __pButton)
 998         {
 999                 return false;
1000         }
1001
1002         if (!__pButton->IsEnabled())
1003         {
1004                 return true;
1005         }
1006
1007         if (__pButton->GetButtonStyle() == _BUTTON_STYLE_SEGMENT)
1008         {
1009                 return false;
1010         }
1011
1012         __touchMoveHandled = false;
1013         //_ButtonStatus status = __pButton->GetButtonStatus();
1014
1015         //if (status != _BUTTON_STATUS_SELECTED)
1016         //{
1017                 __pButton->SetButtonStatus(_BUTTON_STATUS_PRESSED);
1018         //}
1019
1020         __pButton->Draw();
1021         __pButton->Show();
1022
1023         return true;
1024 }
1025
1026 bool
1027 _ButtonPresenter::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
1028 {
1029         if (&source != __pButton)
1030         {
1031                 return false;
1032         }
1033
1034         if (!__pButton->IsEnabled())
1035         {
1036                 return true;
1037         }
1038
1039         if (__pButton->GetButtonStyle() == _BUTTON_STYLE_SEGMENT)
1040         {
1041                 return false;
1042         }
1043
1044         _ButtonStatus status = __pButton->GetButtonStatus();
1045
1046         if (status == _BUTTON_STATUS_NORMAL)
1047         {
1048                 return true;
1049         }
1050
1051         FloatPoint touchPoint = touchinfo.GetCurrentPosition();
1052
1053         touchPoint.x += source.GetClientBoundsF().x;
1054         touchPoint.y += source.GetClientBoundsF().y;
1055
1056         FloatRectangle bounds = __pButton->GetClientBoundsF();
1057
1058         __pButton->SetButtonStatus(_BUTTON_STATUS_NORMAL);
1059         __pButton->Invalidate();
1060
1061         if (bounds.Contains(touchPoint))
1062         {
1063                 PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pButton);
1064
1065                 __pButton->FireActionEvent();
1066         }
1067
1068         return true;
1069 }
1070
1071 bool
1072 _ButtonPresenter::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
1073 {
1074         if (&source != __pButton)
1075         {
1076                 return false;
1077         }
1078
1079         if (!__pButton->IsEnabled())
1080         {
1081                 return true;
1082         }
1083
1084         if (__pButton->GetButtonStyle() == _BUTTON_STYLE_SEGMENT)
1085         {
1086                 return false;
1087         }
1088
1089         FloatPoint touchPoint = touchinfo.GetCurrentPosition();
1090
1091         touchPoint.x += source.GetClientBoundsF().x;
1092         touchPoint.y += source.GetClientBoundsF().y;
1093
1094         FloatRectangle bounds = __pButton->GetClientBoundsF();
1095         bool isInButtonArea = bounds.Contains(touchPoint);
1096         _ButtonStatus oldStatus = __pButton->GetButtonStatus();
1097
1098         if (isInButtonArea && (__touchMoveHandled != true))
1099         {
1100                 __pButton->SetButtonStatus(_BUTTON_STATUS_PRESSED);
1101         }
1102         else
1103         {
1104                 __pButton->SetButtonStatus(_BUTTON_STATUS_NORMAL);
1105         }
1106
1107         if (__pButton->GetButtonStatus() != oldStatus)
1108         {
1109                 __pButton->Invalidate();
1110         }
1111
1112         return false;
1113 }
1114
1115 bool
1116 _ButtonPresenter::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
1117 {
1118         if (&source != __pButton)
1119         {
1120                 return false;
1121         }
1122
1123         if (!__pButton->IsEnabled())
1124         {
1125                 return true;
1126         }
1127
1128         if (__pButton->GetButtonStyle() == _BUTTON_STYLE_SEGMENT)
1129         {
1130                 return false;
1131         }
1132
1133         __pButton->SetButtonStatus(_BUTTON_STATUS_NORMAL);
1134         __pButton->Invalidate();
1135
1136         return true;
1137 }
1138
1139 void
1140 _ButtonPresenter::OnTouchMoveHandled(const _Control& control)
1141 {
1142         if (__touchMoveHandled == false)
1143         {
1144                 __touchMoveHandled = true;
1145                 __pButton->SetButtonStatus(_BUTTON_STATUS_NORMAL);
1146                 __pButton->Invalidate();
1147         }
1148
1149         return;
1150 }
1151
1152 bool
1153 _ButtonPresenter::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
1154 {
1155         _KeyCode keyCode = keyInfo.GetKeyCode();
1156
1157         if (__pButton->IsFocusModeStateEnabled() == true && keyCode == _KEY_ENTER)
1158         {
1159                 if (__pButton->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
1160                 {
1161                         __pButton->SetButtonStatus(_BUTTON_STATUS_PRESSED);
1162                 }
1163         }
1164
1165         __pButton->Draw();
1166         __pButton->Show();
1167
1168         return false;
1169 }
1170
1171 bool
1172 _ButtonPresenter::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
1173 {
1174         _KeyCode keyCode = keyInfo.GetKeyCode();
1175
1176         if (__pButton->IsFocusModeStateEnabled() == true && keyCode == _KEY_ENTER)
1177         {
1178                 if (__pButton->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
1179                 {
1180                         __pButton->SetButtonStatus(_BUTTON_STATUS_NORMAL);
1181                         __pButton->Invalidate();
1182
1183                         __pButton->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
1184                 }
1185         }
1186
1187         return false;
1188 }
1189
1190 void
1191 _ButtonPresenter::OnAncestorEnableStateChanged(const _Control& control)
1192 {
1193         if (__pButton->GetButtonStatus() == _BUTTON_STATUS_SELECTED)
1194         {
1195                 return;
1196         }
1197
1198         if (__pButton->GetEnableState())
1199         {
1200                 __pButton->SetButtonStatus(_BUTTON_STATUS_NORMAL);
1201                 __pButton->Invalidate();
1202         }
1203         else
1204         {
1205                 __pButton->SetButtonStatus(_BUTTON_STATUS_DISABLED);
1206                 __pButton->Invalidate();
1207         }
1208
1209         return;
1210 }
1211
1212 void
1213 _ButtonPresenter::OnDrawFocus(void)
1214 {
1215         if (__pButton->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
1216         {
1217                 __pButton->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
1218                 __pButton->Invalidate();
1219         }
1220
1221         return;
1222 }
1223
1224 void
1225 _ButtonPresenter::OnChildControlFocusMoved(const _Control& control)
1226 {
1227         return;
1228 }
1229
1230 bool
1231 _ButtonPresenter::IsChildControlFocusManage(void) const
1232 {
1233         return true;
1234 }
1235
1236 void
1237 _ButtonPresenter::OnFocusableStateChanged(bool focusalbeState)
1238 {
1239         return;
1240 }
1241
1242 void
1243 _ButtonPresenter::OnFocusModeStateChanged(void)
1244 {
1245         if (__pButton->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
1246         {
1247                 __pButton->SetButtonStatus(_BUTTON_STATUS_NORMAL);
1248                 __pButton->Invalidate();
1249         }
1250
1251         return;
1252 }
1253
1254 bool
1255 _ButtonPresenter::OnFocusGained(const _Control& source)
1256 {
1257         if (__pButton->IsFocusModeStateEnabled() == true)
1258         {
1259                 if (__pButton->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
1260                 {
1261                         __pButton->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
1262                         __pButton->Invalidate();
1263                 }
1264         }
1265
1266         return true;
1267 }
1268
1269 bool
1270 _ButtonPresenter::OnFocusLost(const _Control& source)
1271 {
1272         if (__pButton->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
1273         {
1274                 __pButton->SetButtonStatus(_BUTTON_STATUS_NORMAL);
1275                 __pButton->Invalidate();
1276         }
1277
1278         return true;
1279 }
1280
1281 bool
1282 _ButtonPresenter::IsEnabledStateChanged(void)
1283 {
1284         bool __currentEnabledState = __pButton->GetEnableState();
1285         bool ret = false;
1286
1287         if (__currentEnabledState != __previousEnabledState)
1288         {
1289                 __previousEnabledState = __currentEnabledState;
1290                 ret = true;
1291         }
1292
1293         return ret;
1294 }
1295
1296 Canvas*
1297 _ButtonPresenter::OnCanvasRequestedN(const FloatRectangle& bounds)
1298 {
1299         Canvas* pCanvas = null;
1300
1301         if (__lazyDecode == true)
1302         {
1303                 Bitmap* pBackgroundBitmap = null;
1304                 _ButtonStatus status = __pButton->GetButtonStatus();
1305
1306                 if (__pButton->IsUserBackgroundBitmap(status))
1307                 {
1308                         if (status == _BUTTON_STATUS_HIGHLIGHTED)
1309                         {
1310                                 pBackgroundBitmap = __pButton->GetBackgroundBitmap(_BUTTON_STATUS_NORMAL);
1311                         }
1312                         else
1313                         {
1314                                 pBackgroundBitmap = __pButton->GetBackgroundBitmap(status);
1315                         }
1316                 }
1317
1318                 if (pBackgroundBitmap != null)
1319                 {
1320                         if (pBackgroundBitmap->IsNinePatchedBitmap()) // just decode // fix prevent CHECKED_RETURN
1321                         {
1322                                 // empty
1323                         }
1324                 }
1325
1326                 __lazyDecode = false;
1327
1328                 Draw();
1329
1330                 pCanvas = __pButton->GetCanvasN();
1331         }
1332
1333         return pCanvas;
1334 }
1335
1336 result
1337 _ButtonPresenter::ShowUnderlineBitmap(bool show)
1338 {
1339         __showUnderlineBitmap = show;
1340
1341         return E_SUCCESS;
1342 }
1343
1344 void
1345 _ButtonPresenter::OnTimerExpired(Timer& timer)
1346 {
1347         Timer* onTimer = &timer;
1348
1349         if (onTimer == __pTextSlideTimer)
1350         {
1351                 TimerForTitleSlideTimeout();
1352         }
1353
1354         return;
1355 }
1356
1357 result
1358 _ButtonPresenter::TimerForTitleSlideInit(void)
1359 {
1360         result r = E_SUCCESS;
1361
1362         if (__pTextSlideTimer != null)
1363         {
1364                 delete __pTextSlideTimer;
1365                 __pTextSlideTimer = null;
1366         }
1367
1368         return r;
1369 }
1370
1371 result
1372 _ButtonPresenter::TimerForTitleSlideStart(void)
1373 {
1374         result r = E_SUCCESS;
1375
1376         if (__pTextSlideTimer == null)
1377         {
1378                 __pTextSlideTimer = new (std::nothrow) Timer();
1379                 if (__pTextSlideTimer == null)
1380                 {
1381                         r = E_OUT_OF_MEMORY;
1382                         goto CATCH;
1383                 }
1384
1385                 r = __pTextSlideTimer->Construct(*this);
1386
1387                 if (IsFailed(r))
1388                 {
1389                         delete __pTextSlideTimer;
1390                         goto CATCH;
1391                 }
1392         }
1393
1394         r = __pTextSlideTimer->Start(100);
1395
1396         if (IsFailed(r))
1397         {
1398                 goto CATCH;
1399         }
1400
1401 CATCH:
1402         return r;
1403 }
1404
1405 result
1406 _ButtonPresenter::TimerForTitleSlideTimeout(void)
1407 {
1408         Canvas* pCanvas = __pButton->GetCanvasN();
1409         SysTryReturnResult(NID_UI_CTRL, pCanvas, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pCanvas is invalid!");
1410
1411         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
1412
1413         if (__pButton->UserDefinedText())
1414         {
1415                 pCanvas->Clear(__pButton->GetUserDefinedTextAreaF());
1416
1417                 if (__pTabLargeSelectedBitmap)
1418                 {
1419                         pCanvas->DrawBitmap(CoordinateSystem::AlignToDevice(__pButton->GetUserDefinedTextAreaF()), *__pTabLargeSelectedBitmap);
1420                 }
1421         }
1422         else
1423         {
1424                 pCanvas->Clear(__textRect);
1425
1426                 if (__pTabLargeSelectedBitmap)
1427                 {
1428                         pCanvas->DrawBitmap(CoordinateSystem::AlignToDevice(__textRect), *__pTabLargeSelectedBitmap);
1429                 }
1430         }
1431
1432         if (__pTextObject->IsChanged())
1433         {
1434                 if (!__pButton->GetText().IsEmpty())
1435                 {
1436                         DrawText();
1437                 }
1438         }
1439
1440         if (__pTextObject->IsActionOn() == true)
1441         {
1442                 __pTextObject->DrawWithOffset(*_CanvasImpl::GetInstance(*pCanvas));
1443
1444                 DrawTabTextDimBitmap();
1445
1446                 if (__pTextObject->GetRepeatCount() < 3)
1447                 {
1448                         TimerForTitleSlideStart();
1449                 }
1450         }
1451         else
1452         {
1453                 __pTextObject->Draw(*_CanvasImpl::GetInstance(*pCanvas));
1454         }
1455
1456         delete pCanvas;
1457
1458         return E_SUCCESS;
1459 }
1460
1461 void
1462 _ButtonPresenter::DrawTabTextDimBitmap(void)
1463 {
1464         _ButtonStatus status = __pButton->GetButtonStatus();
1465         Bitmap* pToolbarItemBackgroundBitmap = __pButton->GetToolbarItemBackgroundBitmap(status);
1466
1467         if (pToolbarItemBackgroundBitmap)
1468         {
1469                 return;
1470         }
1471
1472         float textDimWidth = 0.0f;
1473         float textDimHeight = 0.0f;
1474
1475         GET_SHAPE_CONFIG(HEADER::TAB_TEXT_DIM_WIDTH, __pButton->GetOrientation(), textDimWidth);
1476         GET_SHAPE_CONFIG(HEADER::TAB_LARGE_TEXT_HEIGHT, __pButton->GetOrientation(), textDimHeight);
1477
1478         Bitmap* pTabTextDimLeftBitmap = __pButton->GetTabTextDimLeftBitmap();
1479
1480         if (pTabTextDimLeftBitmap)
1481         {
1482                 Canvas* pCanvas = __pButton->GetCanvasN();
1483                 FloatRectangle bounds = FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f);
1484
1485                 if (pCanvas == null)
1486                 {
1487                         SysLog(NID_UI_CTRL, "Cannot get a canvas.");
1488                         return;
1489                 }
1490
1491                 if (__pButton->UserDefinedText() && (__pButton->GetBitmap(_BUTTON_STATUS_NORMAL) || __pButton->GetBitmap(_BUTTON_STATUS_DISABLED)
1492                                 || __pButton->GetBitmap(_BUTTON_STATUS_PRESSED) || __pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED)))
1493                 {
1494                         bounds.x = __pButton->GetUserDefinedTextAreaF().x;
1495                         bounds.y = __pButton->GetUserDefinedTextAreaF().y;
1496                         bounds.width = textDimWidth;
1497                         bounds.height = textDimHeight;
1498                 }
1499                 else
1500                 {
1501                         bounds.x = 0.0f;
1502                         bounds.y = (__pButton->GetSizeF().height - textDimHeight) / 2.0f;
1503                         bounds.width = textDimWidth;
1504                         bounds.height = textDimHeight;
1505                 }
1506
1507                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pTabTextDimLeftBitmap))
1508                 {
1509                         pCanvas->DrawNinePatchedBitmap(bounds, *pTabTextDimLeftBitmap);
1510                 }
1511                 else
1512                 {
1513                         pCanvas->DrawBitmap(bounds, *pTabTextDimLeftBitmap,
1514                                         FloatRectangle(0.0f, 0.0f, pTabTextDimLeftBitmap->GetWidthF(), pTabTextDimLeftBitmap->GetHeightF()));
1515                 }
1516
1517                 delete pCanvas;
1518         }
1519
1520         Bitmap* pTabTextDimRightBitmap = __pButton->GetTabTextDimRightBitmap();
1521
1522         if (pTabTextDimRightBitmap)
1523         {
1524                 Canvas* pCanvas = __pButton->GetCanvasN();
1525                 FloatRectangle bounds = FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f);
1526
1527                 if (pCanvas == null)
1528                 {
1529                         SysLog(NID_UI_CTRL, "Cannot get a canvas.");
1530                         return;
1531                 }
1532
1533                 if (__pButton->UserDefinedText() && (__pButton->GetBitmap(_BUTTON_STATUS_NORMAL) || __pButton->GetBitmap(_BUTTON_STATUS_DISABLED)
1534                                 || __pButton->GetBitmap(_BUTTON_STATUS_PRESSED) || __pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED)))
1535                 {
1536                         bounds.x = __pButton->GetSizeF().width - textDimWidth;
1537                         bounds.y = __pButton->GetUserDefinedTextAreaF().y;
1538                         bounds.width = textDimWidth;
1539                         bounds.height = textDimHeight;
1540                 }
1541                 else
1542                 {
1543                         bounds.x = __pButton->GetSizeF().width - textDimWidth;
1544                         bounds.y = (__pButton->GetSizeF().height - textDimHeight) / 2.0f;
1545                         bounds.width = textDimWidth;
1546                         bounds.height = textDimHeight;
1547                 }
1548
1549                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pTabTextDimRightBitmap))
1550                 {
1551                         pCanvas->DrawNinePatchedBitmap(bounds, *pTabTextDimRightBitmap);
1552                 }
1553                 else
1554                 {
1555                         pCanvas->DrawBitmap(bounds, *pTabTextDimRightBitmap,
1556                                         FloatRectangle(0.0f, 0.0f, pTabTextDimRightBitmap->GetWidthF(), pTabTextDimRightBitmap->GetHeightF()));
1557                 }
1558
1559                 delete pCanvas;
1560         }
1561
1562         return;
1563 }
1564
1565 }}} // Tizen::Ui::Controls