src/ui/FUi_DataBinding.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file        FUi_DataBinding.cpp
  19  * @brief       This is the implementation for the _DataBinding class and default transformer.
  20  */
  21
  22 #include <stdio.h>
  23 #include <FBaseInteger.h>
  24 #include <FBaseString.h>
  25 #include <FGrpColor.h>
  26 #include <FGrpDimension.h>
  27 #include <FGrpRectangle.h>
  28 #include <FUiIDataBindingDataTransformer.h>
  29 #include <FUiIDataBindingDataValidator.h>
  30 #include <FUiIDataBindingListener.h>
  31 #include "FUi_Control.h"
  32 #include "FUi_IPropertyChangeEventListener.h"
  33 #include "FUi_PropertyBase.h"
  34 #include "FUi_DataBinding.h"
  35
  36 using namespace Tizen::Base;
  37 using namespace Tizen::Graphics;
  38
  39 namespace
  40 {
  41 using namespace Tizen::Ui;
  42
  43 class _DefaultTransformer
  44         : public Object
  45         , public IDataBindingDataTransformer
  46 {
  47 public:
  48         virtual ~_DefaultTransformer(void);
  49 public:
  50         virtual bool TransformSourceToTarget(const Tizen::Base::String& bindingId, DataBindingDataType sourceType, const Tizen::Base::Object& sourceData, DataBindingDataType targetType, Tizen::Base::Object& targetData);
  51         virtual bool TransformTargetToSource(const Tizen::Base::String& bindingId, DataBindingDataType targetType, const Tizen::Base::Object& targetData, DataBindingDataType sourceType, Tizen::Base::Object& sourceData);
  52         virtual bool IsSourceToTargetTransformable(const Tizen::Base::String& bindingId, DataBindingDataType sourceType, DataBindingDataType targetType);
  53         virtual bool IsTargetToSourceTransformable(const Tizen::Base::String& bindingId, DataBindingDataType targetType, DataBindingDataType sourceType);
  54 private:
  55         bool Transform(DataBindingDataType sourceType, const Tizen::Base::Object& sourceData, DataBindingDataType targetType, Tizen::Base::Object& destinationData);
  56         bool IsTransformable(DataBindingDataType destinationType, DataBindingDataType sourceType);
  57 };
  58
  59 _DefaultTransformer::~_DefaultTransformer(void)
  60 {
  61 }
  62 bool
  63 _DefaultTransformer::TransformSourceToTarget(const Tizen::Base::String& bindingId, DataBindingDataType sourceType, const Tizen::Base::Object& sourceData, DataBindingDataType targetType, Tizen::Base::Object& targetData)
  64 {
  65         return Transform(sourceType, sourceData, targetType, targetData);
  66 }
  67 bool
  68 _DefaultTransformer::TransformTargetToSource(const Tizen::Base::String& bindingId, DataBindingDataType targetType, const Tizen::Base::Object& targetData, DataBindingDataType sourceType, Tizen::Base::Object& sourceData)
  69 {
  70         return Transform(targetType, targetData, sourceType, sourceData);
  71 }
  72 bool
  73 _DefaultTransformer::IsSourceToTargetTransformable(const Tizen::Base::String& bindingId, DataBindingDataType sourceType, DataBindingDataType targetType)
  74 {
  75         return IsTransformable(sourceType, targetType);
  76 }
  77 bool
  78 _DefaultTransformer::IsTargetToSourceTransformable(const Tizen::Base::String& bindingId, DataBindingDataType targetType, DataBindingDataType sourceType)
  79 {
  80         return IsTransformable(targetType, sourceType);
  81 }
  82
  83 bool
  84 _DefaultTransformer::Transform(DataBindingDataType sourceType, const Tizen::Base::Object& sourceData, DataBindingDataType destinationType, Tizen::Base::Object& destinationData)
  85 {
  86         result r = E_SUCCESS;
  87
  88         switch (destinationType)
  89         {
  90         case DATA_BINDING_DATA_TYPE_INTEGER:
  91                 switch (sourceType) // INTEGER from BOOLEAN, DOUBLE, FLOAT, INTEGER, LONG, STRING
  92                 {
  93                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
  94                 {
  95                         Tizen::Base::Integer* pTarget = dynamic_cast<Tizen::Base::Integer*>(&destinationData);
  96                         if(!pTarget)
  97                         {
  98                                 return false;
  99                         }
 100                         pTarget->value = static_cast<Boolean&>(const_cast<Object&>(sourceData)).ToBool()?1:0;
 101                         return true;
 102                 }
 103                 break;
 104                 case DATA_BINDING_DATA_TYPE_FLOAT:
 105                 {
 106                         Tizen::Base::Integer* pTarget = dynamic_cast<Tizen::Base::Integer*>(&destinationData);
 107                         if(!pTarget)
 108                         {
 109                                 return false;
 110                         }
 111                         pTarget->value = static_cast<Float&>(const_cast<Object&>(sourceData)).ToInt();
 112                         return true;
 113                 }
 114                 break;
 115                 case DATA_BINDING_DATA_TYPE_INTEGER:
 116                 {
 117                         Tizen::Base::Integer* pTarget = dynamic_cast<Tizen::Base::Integer*>(&destinationData);
 118                         if(!pTarget)
 119                         {
 120                                 return false;
 121                         }
 122                         pTarget->value = static_cast<Integer&>(const_cast<Object&>(sourceData)).ToInt();
 123                         return true;
 124                 }
 125                 break;
 126                 case DATA_BINDING_DATA_TYPE_LONG:
 127                 {
 128                         Tizen::Base::Integer* pTarget = dynamic_cast<Tizen::Base::Integer*>(&destinationData);
 129                         if(!pTarget)
 130                         {
 131                                 return false;
 132                         }
 133                         pTarget->value = static_cast<Long&>(const_cast<Object&>(sourceData)).ToInt();
 134                         return true;
 135                 }
 136                 break;
 137                 case DATA_BINDING_DATA_TYPE_COLOR:
 138                 {
 139                         Tizen::Base::Integer* pTarget = dynamic_cast<Tizen::Base::Integer*>(&destinationData);
 140                         if(!pTarget)
 141                         {
 142                                 return false;
 143                         }
 144                         pTarget->value = static_cast<Color&>(const_cast<Object&>(sourceData)).GetRGB32();
 145                         return true;
 146                 }
 147                 break;
 148                 default:
 149                         return false;
 150                 }
 151                 break;
 152         case DATA_BINDING_DATA_TYPE_FLOAT:
 153                 switch (sourceType) // FLOAT from DOUBLE, FLOAT, INTEGER, LONG, STRING
 154                 {
 155                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
 156                 {
 157                         Tizen::Base::Float* pTarget = dynamic_cast<Tizen::Base::Float*>(&destinationData);
 158                         if(!pTarget)
 159                         {
 160                                 return false;
 161                         }
 162                         pTarget->value = static_cast<Boolean&>(const_cast<Object&>(sourceData)).ToBool() ? 1.0 : 0.0;
 163                         return true;
 164                 }
 165                 break;
 166                 case DATA_BINDING_DATA_TYPE_FLOAT:
 167                 {
 168                         Tizen::Base::Float* pTarget = dynamic_cast<Tizen::Base::Float*>(&destinationData);
 169                         if(!pTarget)
 170                         {
 171                                 return false;
 172                         }
 173                         pTarget->value = static_cast<Float&>(const_cast<Object&>(sourceData)).ToFloat();
 174                         return true;
 175                 }
 176                 break;
 177                 case DATA_BINDING_DATA_TYPE_INTEGER:
 178                 {
 179                         Tizen::Base::Float* pTarget = dynamic_cast<Tizen::Base::Float*>(&destinationData);
 180                         if(!pTarget)
 181                         {
 182                                 return false;
 183                         }
 184                         pTarget->value = static_cast<Integer&>(const_cast<Object&>(sourceData)).ToFloat();
 185                         return true;
 186                 }
 187                 break;
 188                 case DATA_BINDING_DATA_TYPE_LONG:
 189                 {
 190                         Tizen::Base::Float* pTarget = dynamic_cast<Tizen::Base::Float*>(&destinationData);
 191                         if(!pTarget)
 192                         {
 193                                 return false;
 194                         }
 195                         pTarget->value = static_cast<Long&>(const_cast<Object&>(sourceData)).ToFloat();
 196                         return true;
 197                 }
 198                 break;
 199                 default:
 200                         return false;
 201                 }
 202                 break;
 203         case DATA_BINDING_DATA_TYPE_DOUBLE:
 204                 switch (sourceType) // DOUBLE from DOUBLE, FLOAT, INTEGER, LONG, STRING
 205                 {
 206                 case DATA_BINDING_DATA_TYPE_DOUBLE:
 207                 {
 208                         Tizen::Base::Double* pTarget = dynamic_cast<Tizen::Base::Double*>(&destinationData);
 209                         if(!pTarget)
 210                         {
 211                                 return false;
 212                         }
 213                         pTarget->value = static_cast<Double&>(const_cast<Object&>(sourceData)).ToDouble();
 214                         return true;
 215                 }
 216                 break;
 217                 case DATA_BINDING_DATA_TYPE_FLOAT:
 218                 {
 219                         Tizen::Base::Double* pTarget = dynamic_cast<Tizen::Base::Double*>(&destinationData);
 220                         if(!pTarget)
 221                         {
 222                                 return false;
 223                         }
 224                         pTarget->value = static_cast<Float&>(const_cast<Object&>(sourceData)).ToDouble();
 225                         return true;
 226                 }
 227                 break;
 228                 case DATA_BINDING_DATA_TYPE_INTEGER:
 229                 {
 230                         Tizen::Base::Double* pTarget = dynamic_cast<Tizen::Base::Double*>(&destinationData);
 231                         if(!pTarget)
 232                         {
 233                                 return false;
 234                         }
 235                         pTarget->value = static_cast<Integer&>(const_cast<Object&>(sourceData)).ToDouble();
 236                         return true;
 237                 }
 238                 break;
 239                 case DATA_BINDING_DATA_TYPE_LONG:
 240                 {
 241                         Tizen::Base::Double* pTarget = dynamic_cast<Tizen::Base::Double*>(&destinationData);
 242                         if(!pTarget)
 243                         {
 244                                 return false;
 245                         }
 246                         pTarget->value = static_cast<Long&>(const_cast<Object&>(sourceData)).ToDouble();
 247                         return true;
 248                 }
 249                 break;
 250                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
 251                 {
 252                         Tizen::Base::Double* pTarget = dynamic_cast<Tizen::Base::Double*>(&destinationData);
 253                         if(!pTarget)
 254                         {
 255                                 return false;
 256                         }
 257                         pTarget->value = static_cast<Boolean&>(const_cast<Object&>(sourceData)).ToBool() ? 1.0 : 0.0;
 258                         return true;
 259                 }
 260                 break;
 261                 default:
 262                         return false;
 263                 }
 264                 break;
 265         case DATA_BINDING_DATA_TYPE_LONG:
 266                 switch (sourceType) // LONG from DOUBLE, FLOAT, INTEGER, LONG, STRING
 267                 {
 268                 case DATA_BINDING_DATA_TYPE_FLOAT:
 269                 {
 270                         Tizen::Base::Long* pTarget = dynamic_cast<Tizen::Base::Long*>(&destinationData);
 271                         if(!pTarget)
 272                         {
 273                                 return false;
 274                         }
 275                         pTarget->value = static_cast<Float&>(const_cast<Object&>(sourceData)).ToLong();
 276                         return true;
 277                 }
 278                 break;
 279                 case DATA_BINDING_DATA_TYPE_INTEGER:
 280                 {
 281                         Tizen::Base::Long* pTarget = dynamic_cast<Tizen::Base::Long*>(&destinationData);
 282                         if(!pTarget)
 283                         {
 284                                 return false;
 285                         }
 286                         pTarget->value = static_cast<Integer&>(const_cast<Object&>(sourceData)).ToLong();
 287                         return true;
 288                 }
 289                 break;
 290                 case DATA_BINDING_DATA_TYPE_LONG:
 291                 {
 292                         Tizen::Base::Long* pTarget = dynamic_cast<Tizen::Base::Long*>(&destinationData);
 293                         if(!pTarget)
 294                         {
 295                                 return false;
 296                         }
 297                         pTarget->value = static_cast<Long&>(const_cast<Object&>(sourceData)).ToLong();
 298                         return true;
 299                 }
 300                 break;
 301                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
 302                 {
 303                         Tizen::Base::Long* pTarget = dynamic_cast<Tizen::Base::Long*>(&destinationData);
 304                         if(!pTarget)
 305                         {
 306                                 return false;
 307                         }
 308                         pTarget->value = static_cast<Boolean&>(const_cast<Object&>(sourceData)).ToBool() ? 1 : 0;
 309                         return true;
 310                 }
 311                 break;
 312                 default:
 313                         return false;
 314                 }
 315                 break;
 316         case DATA_BINDING_DATA_TYPE_STRING:
 317                 switch (sourceType) // STRING from DOUBLE, FLOAT, INTEGER, LONG, STRING
 318                 {
 319                 case DATA_BINDING_DATA_TYPE_DOUBLE:
 320                 {
 321                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 322                         if(!pTarget)
 323                         {
 324                                 return false;
 325                         }
 326                         *pTarget = static_cast<Double&>(const_cast<Object&>(sourceData)).ToString();
 327                         return true;
 328                 }
 329                 break;
 330                 case DATA_BINDING_DATA_TYPE_FLOAT:
 331                 {
 332                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 333                         if(!pTarget)
 334                         {
 335                                 return false;
 336                         }
 337                         *pTarget = static_cast<Float&>(const_cast<Object&>(sourceData)).ToString();
 338                         return true;
 339                 }
 340                 break;
 341                 case DATA_BINDING_DATA_TYPE_INTEGER:
 342                 {
 343                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 344                         if(!pTarget)
 345                         {
 346                                 return false;
 347                         }
 348                         *pTarget = static_cast<Integer&>(const_cast<Object&>(sourceData)).ToString();
 349                         return true;
 350                 }
 351                 break;
 352                 case DATA_BINDING_DATA_TYPE_LONG:
 353                 {
 354                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 355                         if(!pTarget)
 356                         {
 357                                 return false;
 358                         }
 359                         *pTarget = static_cast<Long&>(const_cast<Object&>(sourceData)).ToString();
 360                         return true;
 361                 }
 362                 break;
 363                 case DATA_BINDING_DATA_TYPE_STRING:
 364                 {
 365                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 366                         if(!pTarget)
 367                         {
 368                                 return false;
 369                         }
 370                         *pTarget = static_cast<String&>(const_cast<Object&>(sourceData));
 371                         return true;
 372                 }
 373                 break;
 374                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
 375                 {
 376                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 377                         if(!pTarget)
 378                         {
 379                                 return false;
 380                         }
 381                         *pTarget = static_cast<Boolean&>(const_cast<Object&>(sourceData)).ToString();
 382                         return true;
 383                 }
 384                 break;
 385                 case DATA_BINDING_DATA_TYPE_COLOR:
 386                 {
 387                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 388                         if(!pTarget)
 389                         {
 390                                 return false;
 391                         }
 392                         pTarget->Clear();
 393                         r= pTarget->Append(L"#");
 394                         if(r != E_SUCCESS)
 395                         {
 396                                 return false;
 397                         }
 398                         wchar_t tempString[] = L"XXXXXXXX";
 399                         swprintf(tempString, (sizeof(tempString) / sizeof(wchar_t)), L"%X",static_cast<Color &>(const_cast<Object&>(sourceData)).GetRGB32());
 400                         r= pTarget->Append(tempString);
 401                         if(r != E_SUCCESS)
 402                         {
 403                                 return false;
 404                         }
 405                         return true;
 406                 }
 407                 break;
 408                 case DATA_BINDING_DATA_TYPE_DIMENSION:
 409                 {
 410                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 411                         if(!pTarget)
 412                         {
 413                                 return false;
 414                         }
 415                         pTarget->Clear();
 416
 417                         String* pString = new (std::nothrow) String(L"");
 418                         SysTryReturn(NID_UI, pString, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 419
 420                         Dimension* pDimension = &static_cast<Dimension&>(const_cast<Object&>(sourceData));
 421                         r = pString->Append(L"width:");
 422                         if(r != E_SUCCESS)
 423                         {
 424                                 delete pString;
 425                                 return false;
 426                         }
 427                         r = pString->Append(pDimension->width);
 428                         if(r != E_SUCCESS)
 429                         {
 430                                 delete pString;
 431                                 return false;
 432                         }
 433                         r = pString->Append(L", height:");
 434                         if(r != E_SUCCESS)
 435                         {
 436                                 delete pString;
 437                                 return false;
 438                         }
 439                         r = pString->Append(pDimension->height);
 440                         if(r != E_SUCCESS)
 441                         {
 442                                 delete pString;
 443                                 return false;
 444                         }
 445                         *pTarget = *pString;
 446                         delete pString;
 447                         return true;
 448                 }
 449                 break;
 450                 case DATA_BINDING_DATA_TYPE_POINT:
 451                 {
 452                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 453                         if(!pTarget)
 454                         {
 455                                 return false;
 456                         }
 457                         pTarget->Clear();
 458
 459                         String* pString = new (std::nothrow) String(L"");
 460                         SysTryReturn(NID_UI, pString, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 461
 462                         Point* pPoint = &static_cast<Point &>(const_cast<Object&>(sourceData));
 463                         r = pString->Append(L"x:");
 464                         if(r != E_SUCCESS)
 465                         {
 466                                 delete pString;
 467                                 return false;
 468                         }
 469                         r = pString->Append(pPoint->x);
 470                         if(r != E_SUCCESS)
 471                         {
 472                                 delete pString;
 473                                 return false;
 474                         }
 475                         r = pString->Append(L", y:");
 476                         if(r != E_SUCCESS)
 477                         {
 478                                 delete pString;
 479                                 return false;
 480                         }
 481                         r = pString->Append(pPoint->y);
 482                         if(r != E_SUCCESS)
 483                         {
 484                                 delete pString;
 485                                 return false;
 486                         }
 487                         *pTarget = *pString;
 488                         delete pString;
 489                         return true;
 490                 }
 491                 break;
 492                 case DATA_BINDING_DATA_TYPE_RECTANGLE:
 493                 {
 494                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 495                         if(!pTarget)
 496                         {
 497                                 return false;
 498                         }
 499                         pTarget->Clear();
 500
 501                         String* pString = new (std::nothrow) String(L"");
 502                         SysTryReturn(NID_UI, pString, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 503
 504                         Rectangle* pRectangle = &static_cast<Rectangle &>(const_cast<Object&>(sourceData));
 505                         r = pString->Append(L"x:");
 506                         if(r != E_SUCCESS)
 507                         {
 508                                 delete pString;
 509                                 return false;
 510                         }
 511                         r = pString->Append(pRectangle->x);
 512                         if(r != E_SUCCESS)
 513                         {
 514                                 delete pString;
 515                                 return false;
 516                         }
 517                         r = pString->Append(L", y:");
 518                         if(r != E_SUCCESS)
 519                         {
 520                                 delete pString;
 521                                 return false;
 522                         }
 523                         r = pString->Append(pRectangle->y);
 524                         if(r != E_SUCCESS)
 525                         {
 526                                 delete pString;
 527                                 return false;
 528                         }
 529
 530                         r = pString->Append(L", width:");
 531                         if(r != E_SUCCESS)
 532                         {
 533                                 delete pString;
 534                                 return false;
 535                         }
 536                         r = pString->Append(pRectangle->width);
 537                         if(r != E_SUCCESS)
 538                         {
 539                                 delete pString;
 540                                 return false;
 541                         }
 542
 543                         r = pString->Append(L", height:");
 544                         if(r != E_SUCCESS)
 545                         {
 546                                 delete pString;
 547                                 return false;
 548                         }
 549                         r = pString->Append(pRectangle->height);
 550                         if(r != E_SUCCESS)
 551                         {
 552                                 delete pString;
 553                                 return false;
 554                         }
 555                         *pTarget = *pString;
 556                         delete pString;
 557                         return true;
 558                 }
 559                 default:
 560                         return false;
 561                 }
 562                 break;
 563         case DATA_BINDING_DATA_TYPE_COLOR:
 564                 if (sourceType == DATA_BINDING_DATA_TYPE_COLOR)
 565                 {
 566                         Color* pTarget = dynamic_cast<Color*>(&destinationData);
 567                         if(!pTarget)
 568                         {
 569                                 return false;
 570                         }
 571                         *pTarget = static_cast<Color&>(const_cast<Object&>(sourceData));
 572                         return true;
 573                 }
 574                 else if (sourceType == DATA_BINDING_DATA_TYPE_INTEGER)
 575                 {
 576                         Color* pTarget = dynamic_cast<Color*>(&destinationData);
 577                         if(!pTarget)
 578                         {
 579                                 return false;
 580                         }
 581                         *pTarget = static_cast<Integer&>(const_cast<Object&>(sourceData)).ToInt();
 582                         return true;
 583                 }
 584                 else
 585                 {
 586                         return false;
 587                 }
 588                 break;
 589         case DATA_BINDING_DATA_TYPE_POINT:
 590                 switch (sourceType)
 591                 {
 592                         case DATA_BINDING_DATA_TYPE_POINT:
 593                         {
 594                                 Point* pTarget = dynamic_cast<Point*>(&destinationData);
 595                                 if(!pTarget)
 596                                 {
 597                                         return false;
 598                                 }
 599                                 pTarget->SetPosition(static_cast<Point&>(const_cast<Object&>(sourceData)).x, static_cast<Point&>(const_cast<Object&>(sourceData)).y);
 600                                 return true;
 601                         }
 602                         break;
 603                         case DATA_BINDING_DATA_TYPE_FLOAT_POINT:
 604                         {
 605                                 Point* pTarget = dynamic_cast<Point*>(&destinationData);
 606                                 if(!pTarget)
 607                                 {
 608                                         return false;
 609                                 }
 610                                 pTarget->SetPosition(static_cast<FloatPoint&>(const_cast<Object&>(sourceData)).x, static_cast<FloatPoint&>(const_cast<Object&>(sourceData)).y);
 611                                 return true;
 612                         }
 613                         break;
 614                         case DATA_BINDING_DATA_TYPE_RECTANGLE:
 615                         {
 616                                 Point* pTarget = dynamic_cast<Point*>(&destinationData);
 617                                 if(!pTarget)
 618                                 {
 619                                         return false;
 620                                 }
 621                                 pTarget->SetPosition(static_cast<Rectangle&>(const_cast<Object&>(sourceData)).x, static_cast<Rectangle&>(const_cast<Object&>(sourceData)).y);
 622                                 return true;
 623                         }
 624                         break;
 625                         case DATA_BINDING_DATA_TYPE_FLOAT_RECTANGLE:
 626                         {
 627                                 Point* pTarget = dynamic_cast<Point*>(&destinationData);
 628                                 if(!pTarget)
 629                                 {
 630                                         return false;
 631                                 }
 632                                 pTarget->SetPosition(static_cast<FloatRectangle&>(const_cast<Object&>(sourceData)).x, static_cast<FloatRectangle&>(const_cast<Object&>(sourceData)).y);
 633                                 return true;
 634                         }
 635                         break;
 636                         default:
 637                                 return false;
 638                 }
 639                 break;
 640         case DATA_BINDING_DATA_TYPE_RECTANGLE:
 641                 if (sourceType == DATA_BINDING_DATA_TYPE_RECTANGLE)
 642                 {
 643                         Rectangle* pTarget = dynamic_cast<Rectangle*>(&destinationData);
 644                         if(!pTarget)
 645                         {
 646                                 return false;
 647                         }
 648                         pTarget->SetBounds(static_cast<Rectangle&>(const_cast<Object&>(sourceData)).x, static_cast<Rectangle&>(const_cast<Object&>(sourceData)).y, static_cast<Rectangle&>(const_cast<Object&>(sourceData)).width, static_cast<Rectangle&>(const_cast<Object&>(sourceData)).height);
 649                         return true;
 650                 }
 651                 else if (sourceType == DATA_BINDING_DATA_TYPE_FLOAT_RECTANGLE)
 652                 {
 653                         Rectangle* pTarget = dynamic_cast<Rectangle*>(&destinationData);
 654                         if(!pTarget)
 655                         {
 656                                 return false;
 657                         }
 658                         pTarget->SetBounds(static_cast<FloatRectangle&>(const_cast<Object&>(sourceData)).x, static_cast<FloatRectangle&>(const_cast<Object&>(sourceData)).y, static_cast<FloatRectangle&>(const_cast<Object&>(sourceData)).width, static_cast<FloatRectangle&>(const_cast<Object&>(sourceData)).height);
 659                         return true;
 660                 }
 661                 else
 662                 {
 663                         return false;
 664                 }
 665                 break;
 666         case DATA_BINDING_DATA_TYPE_DIMENSION:
 667                 switch (sourceType)
 668                 {
 669                         case DATA_BINDING_DATA_TYPE_DIMENSION:
 670                         {
 671                                 Dimension* pTarget = dynamic_cast<Dimension*>(&destinationData);
 672                                 if(!pTarget)
 673                                 {
 674                                         return false;
 675                                 }
 676                                 pTarget->SetSize(static_cast<Dimension&>(const_cast<Object&>(sourceData)).width, static_cast<Dimension&>(const_cast<Object&>(sourceData)).height);
 677                                 return true;
 678                         }
 679                         break;
 680                         case DATA_BINDING_DATA_TYPE_FLOAT_DIMENSION:
 681                         {
 682                                 Dimension* pTarget = dynamic_cast<Dimension*>(&destinationData);
 683                                 if(!pTarget)
 684                                 {
 685                                         return false;
 686                                 }
 687                                 pTarget->SetSize(static_cast<FloatDimension&>(const_cast<Object&>(sourceData)).width, static_cast<FloatDimension&>(const_cast<Object&>(sourceData)).height);
 688                                 return true;
 689                         }
 690                         break;
 691                         case DATA_BINDING_DATA_TYPE_RECTANGLE:
 692                         {
 693                                 Dimension* pTarget = dynamic_cast<Dimension*>(&destinationData);
 694                                 if(!pTarget)
 695                                 {
 696                                         return false;
 697                                 }
 698                                 pTarget->SetSize(static_cast<Rectangle&>(const_cast<Object&>(sourceData)).width, static_cast<Rectangle&>(const_cast<Object&>(sourceData)).height);
 699                                 return true;
 700                         }
 701                         break;
 702                         case DATA_BINDING_DATA_TYPE_FLOAT_RECTANGLE:
 703                         {
 704                                 Point* pTarget = dynamic_cast<Point*>(&destinationData);
 705                                 if(!pTarget)
 706                                 {
 707                                         return false;
 708                                 }
 709                                 pTarget->SetPosition(static_cast<FloatRectangle&>(const_cast<Object&>(sourceData)).x, static_cast<FloatRectangle&>(const_cast<Object&>(sourceData)).y);
 710                                 return true;
 711                         }
 712                         break;
 713                         default:
 714                                 return false;
 715                 }
 716                 break;
 717         default:
 718                 return false;
 719         }
 720 }
 721 bool
 722 _DefaultTransformer::IsTransformable(DataBindingDataType sourceType, DataBindingDataType destinationType)
 723 {
 724         bool returnValue = false;
 725
 726         switch (destinationType)
 727         {
 728         case DATA_BINDING_DATA_TYPE_INTEGER:
 729                 switch (sourceType) // INTEGER from BOOLEAN, DOUBLE, FLOAT, INTEGER, LONG, STRING
 730                 {
 731                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
 732                         //fall through
 733                 case DATA_BINDING_DATA_TYPE_FLOAT:
 734                         //fall through
 735                 case DATA_BINDING_DATA_TYPE_INTEGER:
 736                         //fall through
 737                 case DATA_BINDING_DATA_TYPE_LONG:
 738                         //fall through
 739                 case DATA_BINDING_DATA_TYPE_COLOR:
 740                         returnValue = true;
 741                         break;
 742                 default:
 743                         break;
 744                 }
 745                 break;
 746         case DATA_BINDING_DATA_TYPE_FLOAT:
 747                 switch (sourceType) // FLOAT from DOUBLE, FLOAT, INTEGER, LONG, STRING
 748                 {
 749                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
 750                         //fall through
 751                 case DATA_BINDING_DATA_TYPE_FLOAT:
 752                         //fall through
 753                 case DATA_BINDING_DATA_TYPE_INTEGER:
 754                         //fall through
 755                 case DATA_BINDING_DATA_TYPE_LONG:
 756                         returnValue = true;
 757                         break;
 758                 default:
 759                         break;
 760                 }
 761                 break;
 762
 763         case DATA_BINDING_DATA_TYPE_DOUBLE:
 764                 switch (sourceType) // DOUBLE from DOUBLE, FLOAT, INTEGER, LONG, STRING
 765                 {
 766                 case DATA_BINDING_DATA_TYPE_DOUBLE:
 767                         //fall through
 768                 case DATA_BINDING_DATA_TYPE_FLOAT:
 769                         //fall through
 770                 case DATA_BINDING_DATA_TYPE_INTEGER:
 771                         //fall through
 772                 case DATA_BINDING_DATA_TYPE_LONG:
 773                         //fall through
 774                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
 775                         returnValue = true;
 776                         break;
 777                 default:
 778                         break;
 779                 }
 780                 break;
 781
 782         case DATA_BINDING_DATA_TYPE_LONG:
 783                 switch (sourceType) // LONG from DOUBLE, FLOAT, INTEGER, LONG, STRING
 784                 {
 785                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
 786                         //fall through
 787                 case DATA_BINDING_DATA_TYPE_FLOAT:
 788                         //fall through
 789                 case DATA_BINDING_DATA_TYPE_INTEGER:
 790                         //fall through
 791                 case DATA_BINDING_DATA_TYPE_LONG:
 792                         returnValue = true;
 793                         break;
 794                 default:
 795                         break;
 796                 }
 797                 break;
 798
 799         case DATA_BINDING_DATA_TYPE_STRING:
 800                 switch (sourceType) // STRING from all type
 801                 {
 802                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
 803                         //fall through
 804                 case DATA_BINDING_DATA_TYPE_COLOR:
 805                         //fall through
 806                 case DATA_BINDING_DATA_TYPE_DIMENSION:
 807                         //fall through
 808                 case DATA_BINDING_DATA_TYPE_DOUBLE:
 809                         //fall through
 810                 case DATA_BINDING_DATA_TYPE_FLOAT:
 811                         //fall through
 812                 case DATA_BINDING_DATA_TYPE_INTEGER:
 813                         //fall through
 814                 case DATA_BINDING_DATA_TYPE_LONG:
 815                         //fall through
 816                 case DATA_BINDING_DATA_TYPE_POINT:
 817                         //fall through
 818                 case DATA_BINDING_DATA_TYPE_RECTANGLE:
 819                         //fall through
 820                 case DATA_BINDING_DATA_TYPE_STRING:
 821                         returnValue = true;
 822                         break;
 823                 default:
 824                         break;
 825                 }
 826                 break;
 827
 828         case DATA_BINDING_DATA_TYPE_COLOR:
 829                 switch (sourceType) // COLOR from INTEGER, COLOR
 830                 {
 831                 case DATA_BINDING_DATA_TYPE_COLOR:
 832                         //fall through
 833                 case DATA_BINDING_DATA_TYPE_INTEGER:
 834                         returnValue = true;
 835                         break;
 836                 default:
 837                         break;
 838                 }
 839                 break;
 840
 841         case DATA_BINDING_DATA_TYPE_POINT:
 842                 switch (sourceType) // POINT from POINT, RECTANGLE
 843                 {
 844                 case DATA_BINDING_DATA_TYPE_FLOAT_RECTANGLE:
 845                         //fall through
 846                 case DATA_BINDING_DATA_TYPE_FLOAT_POINT:
 847                         //fall through
 848                 case DATA_BINDING_DATA_TYPE_POINT:
 849                         //fall through
 850                 case DATA_BINDING_DATA_TYPE_RECTANGLE:
 851                         returnValue = true;
 852                         break;
 853                 default:
 854                         break;
 855                 }
 856                 break;
 857
 858         case DATA_BINDING_DATA_TYPE_RECTANGLE:
 859                 switch (sourceType) // RECTANGLE from FLOATRECTANGLE, RECTANGLE
 860                 {
 861                 case DATA_BINDING_DATA_TYPE_FLOAT_RECTANGLE:
 862                         //fall through
 863                 case DATA_BINDING_DATA_TYPE_RECTANGLE:
 864                         returnValue = true;
 865                         break;
 866
 867                 default:
 868                         break;
 869                 }
 870                 break;
 871         case DATA_BINDING_DATA_TYPE_DIMENSION:
 872                 switch (sourceType) // POINT from POINT, RECTANGLE
 873                 {
 874                 case DATA_BINDING_DATA_TYPE_FLOAT_RECTANGLE:
 875                         //fall through
 876                 case DATA_BINDING_DATA_TYPE_FLOAT_DIMENSION:
 877                         //fall through
 878                 case DATA_BINDING_DATA_TYPE_DIMENSION:
 879                         //fall through
 880                 case DATA_BINDING_DATA_TYPE_RECTANGLE:
 881                         returnValue = true;
 882                         break;
 883                 default:
 884                         break;
 885                 }
 886                 break;
 887         case DATA_BINDING_DATA_TYPE_FLOAT_POINT:
 888                 switch (sourceType) // POINT from POINT, RECTANGLE
 889                 {
 890                 case DATA_BINDING_DATA_TYPE_FLOAT_RECTANGLE:
 891                         //fall through
 892                 case DATA_BINDING_DATA_TYPE_FLOAT_POINT:
 893                         //fall through
 894                 case DATA_BINDING_DATA_TYPE_POINT:
 895                         //fall through
 896                 case DATA_BINDING_DATA_TYPE_RECTANGLE:
 897                         returnValue = true;
 898                         break;
 899                 default:
 900                         break;
 901                 }
 902                 break;
 903         case DATA_BINDING_DATA_TYPE_FLOAT_RECTANGLE:
 904                 switch (sourceType) // RECTANGLE from FLOATRECTANGLE, RECTANGLE
 905                 {
 906                 case DATA_BINDING_DATA_TYPE_FLOAT_RECTANGLE:
 907                         //fall through
 908                 case DATA_BINDING_DATA_TYPE_RECTANGLE:
 909                         returnValue = true;
 910                         break;
 911
 912                 default:
 913                         break;
 914                 }
 915                 break;
 916         case DATA_BINDING_DATA_TYPE_FLOAT_DIMENSION:
 917                 switch (sourceType) // POINT from POINT, RECTANGLE
 918                 {
 919                 case DATA_BINDING_DATA_TYPE_FLOAT_RECTANGLE:
 920                         //fall through
 921                 case DATA_BINDING_DATA_TYPE_FLOAT_DIMENSION:
 922                         //fall through
 923                 case DATA_BINDING_DATA_TYPE_DIMENSION:
 924                         //fall through
 925                 case DATA_BINDING_DATA_TYPE_RECTANGLE:
 926                         returnValue = true;
 927                         break;
 928                 default:
 929                         break;
 930                 }
 931         default:
 932                 break;
 933         }
 934         return returnValue;
 935 }
 936
 937
 938 bool
 939 IsTypeSupported(VariantType variantType)
 940 {
 941         bool returnValue = false;
 942
 943         switch (variantType)
 944         {
 945         case VARIANT_TYPE_INT:
 946                 //fall through
 947         case VARIANT_TYPE_BOOL:
 948                 //fall through
 949         case VARIANT_TYPE_FLOAT:
 950                 //fall through
 951         case VARIANT_TYPE_DOUBLE:
 952                 //fall through
 953         case VARIANT_TYPE_LONG:
 954                 //fall through
 955         case VARIANT_TYPE_STRING:
 956                 //fall through
 957         case VARIANT_TYPE_COLOR:
 958                 //fall through
 959         case VARIANT_TYPE_POINT:
 960                 //fall through
 961         case VARIANT_TYPE_RECTANGLE:
 962                 //fall through
 963         case VARIANT_TYPE_FLOAT_DIMENSION:
 964                 //fall through
 965         case VARIANT_TYPE_FLOAT_POINT:
 966                 //fall through
 967         case VARIANT_TYPE_FLOAT_RECTANGLE:
 968                 //fall through
 969         case VARIANT_TYPE_DIMENSION:
 970                 returnValue = true;
 971                 break;
 972         default:
 973                 break;
 974         }
 975         return returnValue;
 976 }
 977 DataBindingDataType
 978 ConvertVariantTypeToDataBindingDataType(VariantType variantType)
 979 {
 980         DataBindingDataType dataType = DATA_BINDING_DATA_TYPE_BOOLEAN;
 981
 982         switch (variantType)
 983         {
 984         case VARIANT_TYPE_INT:
 985                 dataType = DATA_BINDING_DATA_TYPE_INTEGER;
 986                 break;
 987
 988         case VARIANT_TYPE_BOOL:
 989                 dataType = DATA_BINDING_DATA_TYPE_BOOLEAN;
 990                 break;
 991
 992         case VARIANT_TYPE_FLOAT:
 993                 dataType = DATA_BINDING_DATA_TYPE_FLOAT;
 994                 break;
 995
 996         case VARIANT_TYPE_DOUBLE:
 997                 dataType = DATA_BINDING_DATA_TYPE_DOUBLE;
 998                 break;
 999
1000         case VARIANT_TYPE_LONG:
1001                 dataType = DATA_BINDING_DATA_TYPE_LONG;
1002                 break;
1003
1004         case VARIANT_TYPE_STRING:
1005                 dataType = DATA_BINDING_DATA_TYPE_STRING;
1006                 break;
1007
1008         case VARIANT_TYPE_COLOR:
1009                 dataType = DATA_BINDING_DATA_TYPE_COLOR;
1010                 break;
1011
1012         case VARIANT_TYPE_POINT:
1013                 dataType = DATA_BINDING_DATA_TYPE_POINT;
1014                 break;
1015
1016         case VARIANT_TYPE_RECTANGLE:
1017                 dataType = DATA_BINDING_DATA_TYPE_RECTANGLE;
1018                 break;
1019
1020         case VARIANT_TYPE_DIMENSION:
1021                 dataType = DATA_BINDING_DATA_TYPE_DIMENSION;
1022                 break;
1023
1024         case VARIANT_TYPE_FLOAT_DIMENSION:
1025                 dataType = DATA_BINDING_DATA_TYPE_FLOAT_DIMENSION;
1026                 break;
1027
1028         case VARIANT_TYPE_FLOAT_POINT:
1029                 dataType = DATA_BINDING_DATA_TYPE_FLOAT_POINT;
1030                 break;
1031
1032         case VARIANT_TYPE_FLOAT_RECTANGLE:
1033                 dataType = DATA_BINDING_DATA_TYPE_FLOAT_RECTANGLE;
1034                 break;
1035
1036         default:
1037                 SysAssertf(0, "Not Support Type");
1038                 break;
1039         }
1040         return dataType;
1041 }
1042
1043 VariantType
1044 ConvertDataBindingDataTypeToVariantType(DataBindingDataType dataType)
1045 {
1046         VariantType variantType = VARIANT_TYPE_NONE;
1047         switch (dataType)
1048         {
1049         case DATA_BINDING_DATA_TYPE_BOOLEAN:
1050                 variantType = VARIANT_TYPE_BOOL;
1051                 break;
1052
1053         case DATA_BINDING_DATA_TYPE_COLOR:
1054                 variantType = VARIANT_TYPE_COLOR;
1055                 break;
1056
1057         case DATA_BINDING_DATA_TYPE_DIMENSION:
1058                 variantType = VARIANT_TYPE_DIMENSION;
1059                 break;
1060
1061         case DATA_BINDING_DATA_TYPE_DOUBLE:
1062                 variantType = VARIANT_TYPE_DOUBLE;
1063                 break;
1064
1065         case DATA_BINDING_DATA_TYPE_FLOAT:
1066                 variantType = VARIANT_TYPE_FLOAT;
1067                 break;
1068
1069         case DATA_BINDING_DATA_TYPE_INTEGER:
1070                 variantType = VARIANT_TYPE_INT;
1071                 break;
1072
1073         case DATA_BINDING_DATA_TYPE_LONG:
1074                 variantType = VARIANT_TYPE_LONG;
1075                 break;
1076
1077         case DATA_BINDING_DATA_TYPE_POINT:
1078                 variantType = VARIANT_TYPE_POINT;
1079                 break;
1080
1081         case DATA_BINDING_DATA_TYPE_RECTANGLE:
1082                 variantType = VARIANT_TYPE_RECTANGLE;
1083                 break;
1084
1085         case DATA_BINDING_DATA_TYPE_STRING:
1086                 variantType = VARIANT_TYPE_STRING;
1087                 break;
1088
1089         case DATA_BINDING_DATA_TYPE_FLOAT_DIMENSION:
1090                 variantType = VARIANT_TYPE_FLOAT_DIMENSION;
1091                 break;
1092
1093         case DATA_BINDING_DATA_TYPE_FLOAT_POINT:
1094                 variantType = VARIANT_TYPE_FLOAT_POINT;
1095                 break;
1096
1097         case DATA_BINDING_DATA_TYPE_FLOAT_RECTANGLE:
1098                 variantType = VARIANT_TYPE_FLOAT_RECTANGLE;
1099                 break;
1100
1101         default:
1102                 break;
1103         }
1104         return variantType;
1105 }
1106
1107
1108 class _DataBindingPropertyChangeEventListner
1109         : public _IPropertyChangeEventListener
1110         , virtual public Tizen::Base::Runtime::IEventListener
1111 {
1112 public:
1113         _DataBindingPropertyChangeEventListner(const _DataBinding& dataBinding)
1114         {
1115                 __pDataBinding = &const_cast<_DataBinding&>(dataBinding);
1116         };
1117         virtual ~_DataBindingPropertyChangeEventListner(void){};
1118         virtual void OnPropertyChanging(_PropertyBase& source, const String& name, const Variant& oldValue, const Variant& newValue){};
1119         virtual void OnPropertyChanged(_PropertyBase& source, const String& name, const Variant& oldValue, const Variant& newValue)
1120         {
1121                 const Variant variant = source.GetProperty(name);
1122                 if (variant.IsEmpty() || oldValue == newValue)
1123                 {
1124                         return;
1125                 }
1126                 if (name == __pDataBinding->GetPropertyName())
1127                 {
1128                         __pDataBinding->Update(DATA_BINDING_DESTINATION_TYPE_SOURCE);
1129                 }
1130         };
1131 private:
1132         _DataBinding* __pDataBinding;
1133 }; //class _DataBindingPropertyChangeEventListner
1134
1135 _DefaultTransformer defaultTransformer;
1136 }
1137 namespace Tizen { namespace Ui
1138 {
1139 _DataBinding::_DataBinding(void)
1140         : __controlHandle()
1141         , __bindingId(L"")
1142         , __propertyName(L"")
1143         , __pDataSource(null)
1144         , __sourceType(DATA_BINDING_DATA_TYPE_BOOLEAN)
1145         , __targetType(DATA_BINDING_DATA_TYPE_BOOLEAN)
1146         , __flow(DATA_BINDING_FLOW_ONE_WAY)
1147         , __trigger(DATA_BINDING_TRIGGER_EXPLICIT)
1148         , __pListener(null)
1149         , __pValidator(null)
1150         , __pTransformer(null)
1151         , __pPropertyChangeEventListener(null)
1152 {
1153 }
1154 _DataBinding::~_DataBinding(void)
1155 {
1156         if (__pPropertyChangeEventListener)
1157         {
1158                 _Control* pControl = _ControlManager::GetInstance()->GetObject(__controlHandle);
1159                 if (pControl)
1160                 {
1161                         pControl->RemovePropertyChangeEventListener(*__pPropertyChangeEventListener);
1162                 }
1163                 delete __pPropertyChangeEventListener;
1164                 __pPropertyChangeEventListener = null;
1165         }
1166 }
1167
1168 result
1169 _DataBinding::Construct(const _Control& control, const String& bindingId, const String& propertyName
1170                                            , Object& dataSource, DataBindingDataType sourceType, DataBindingFlow flow, DataBindingTrigger trigger
1171                                            , const IDataBindingListener* pListener, const IDataBindingDataValidator* pValidator, const IDataBindingDataTransformer* pTransformer)
1172 {
1173         __controlHandle = control.GetHandle();
1174         _Control* pControl = _ControlManager::GetInstance()->GetObject(__controlHandle);
1175         SysTryReturn(NID_UI, pControl, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] The control that was binded is gone.");
1176         __propertyName = propertyName;
1177         __pDataSource = &dataSource;
1178         __sourceType = sourceType;
1179         __flow = flow;
1180         __trigger = trigger;
1181         __pListener = const_cast<IDataBindingListener*>(pListener);
1182         __pValidator = const_cast<IDataBindingDataValidator*>(pValidator);
1183
1184         if (pTransformer != null)
1185                 __pTransformer = const_cast<IDataBindingDataTransformer*>(pTransformer);
1186         else
1187                 __pTransformer = &::defaultTransformer;
1188
1189         Variant variant = pControl->GetProperty(propertyName);
1190
1191         SysTryReturn(NID_UI, GetLastResult() != E_KEY_NOT_FOUND, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Property is not found.");
1192
1193         SysTryReturn(NID_UI, ::IsTypeSupported(variant.GetType()), E_UNSUPPORTED_FORMAT, E_UNSUPPORTED_FORMAT
1194                                 , "[E_UNSUPPORTED_FORMAT] Property type is unsupported type.");
1195
1196         __targetType = ::ConvertVariantTypeToDataBindingDataType(variant.GetType());
1197
1198         switch(__flow)
1199         {
1200                 case DATA_BINDING_FLOW_ONE_WAY:
1201                         SysTryReturn(NID_UI, __pTransformer->IsSourceToTargetTransformable(bindingId, __sourceType, __targetType)
1202                                                 , E_UNSUPPORTED_FORMAT, E_UNSUPPORTED_FORMAT, "[E_UNSUPPORTED_FORMAT] transformer can not transform source type to target type.");
1203                         break;
1204                 case DATA_BINDING_FLOW_ONE_WAY_TO_SOURCE:
1205                         SysTryReturn(NID_UI, __pTransformer->IsTargetToSourceTransformable(bindingId, __targetType, __sourceType)
1206                                                 , E_UNSUPPORTED_FORMAT, E_UNSUPPORTED_FORMAT, "[E_UNSUPPORTED_FORMAT] transformer can not transform target type to source type.");
1207                         break;
1208                 case DATA_BINDING_FLOW_TWO_WAY:
1209                         SysTryReturn(NID_UI, __pTransformer->IsSourceToTargetTransformable(bindingId, __sourceType, __targetType)
1210                                                 && __pTransformer->IsTargetToSourceTransformable(bindingId, __targetType, __sourceType)
1211                                                 , E_UNSUPPORTED_FORMAT, E_UNSUPPORTED_FORMAT, "[E_UNSUPPORTED_FORMAT] transformer can not transform both target type and source type.");
1212                         break;
1213                 default:
1214                         SysAssert(0);
1215         }
1216
1217         if (trigger == DATA_BINDING_TRIGGER_IMMEDIATE)
1218         {
1219                 __pPropertyChangeEventListener = new (std::nothrow) ::_DataBindingPropertyChangeEventListner(*this);
1220                 SysTryReturn(NID_UI, __pPropertyChangeEventListener, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1221                 pControl->AddPropertyChangeEventListener(*__pPropertyChangeEventListener);
1222         }
1223         return E_SUCCESS;
1224 }
1225
1226 result
1227 _DataBinding::Update(DataBindingDestinationType destinationType)
1228 {
1229         bool valid = true;
1230         Object* pTransformedObject = null;
1231         result r = E_SYSTEM;
1232         Object* pOriginObject = null;
1233         _Control* pControl = _ControlManager::GetInstance()->GetObject(__controlHandle);
1234         SysTryCatch(NID_UI, pControl, , E_SYSTEM, "[E_SYSTEM] The control that was binded is gone.");
1235
1236         if (destinationType == DATA_BINDING_DESTINATION_TYPE_SOURCE)
1237         {
1238                 DataBindingDataType originType = __targetType;
1239                 Variant variant = pControl->GetProperty(__propertyName);
1240                 DataBindingDataType transformedType = __sourceType;
1241
1242                 switch (variant.GetType())
1243                 {
1244                 case VARIANT_TYPE_INT:
1245                         pOriginObject = new (std::nothrow) Integer(variant.ToInt());
1246                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1247                         break;
1248
1249                 case VARIANT_TYPE_BOOL:
1250                         pOriginObject = new (std::nothrow) Boolean(variant.ToBool());
1251                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1252                         break;
1253
1254                 case VARIANT_TYPE_FLOAT:
1255                         pOriginObject = new (std::nothrow) Float(variant.ToFloat());
1256                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1257                         break;
1258
1259                 case VARIANT_TYPE_DOUBLE:
1260                         pOriginObject = new (std::nothrow) Double(variant.ToDouble());
1261                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1262                         break;
1263
1264                 case VARIANT_TYPE_LONG:
1265                         pOriginObject = new (std::nothrow) Long(variant.ToLong());
1266                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1267                         break;
1268
1269                 case VARIANT_TYPE_STRING:
1270                         pOriginObject = new (std::nothrow) String(variant.ToString());
1271                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1272                         break;
1273
1274                 case VARIANT_TYPE_COLOR:
1275                         pOriginObject = new (std::nothrow) Color(variant.ToColor());
1276                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1277                         break;
1278
1279                 case VARIANT_TYPE_POINT:
1280                         pOriginObject = new (std::nothrow) Point(variant.ToPoint().x, variant.ToPoint().y);
1281                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1282                         break;
1283
1284                 case VARIANT_TYPE_RECTANGLE:
1285                         pOriginObject = new (std::nothrow) Rectangle(variant.ToRectangle().x, variant.ToRectangle().y, variant.ToRectangle().width, variant.ToRectangle().height);
1286                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1287                         break;
1288
1289                 case VARIANT_TYPE_DIMENSION:
1290                         pOriginObject = new (std::nothrow) Dimension(variant.ToDimension().width, variant.ToDimension().height);
1291                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1292                         break;
1293                 case VARIANT_TYPE_FLOAT_POINT:
1294                         pOriginObject = new (std::nothrow) FloatPoint(variant.ToFloatPoint());
1295                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1296                         break;
1297                 case VARIANT_TYPE_FLOAT_RECTANGLE:
1298                         pOriginObject = new (std::nothrow) FloatRectangle(variant.ToFloatRectangle());
1299                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1300                         break;
1301                 case VARIANT_TYPE_FLOAT_DIMENSION:
1302                         pOriginObject = new (std::nothrow) FloatDimension(variant.ToFloatDimension());
1303                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1304                         break;
1305
1306
1307
1308                 default:
1309                         SysTryCatch(NID_UI, pControl, , E_SYSTEM, "[E_SYSTEM] The control that was binded is gone.");
1310                 }
1311
1312                 switch(__sourceType)
1313                 {
1314                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
1315                 {
1316                         pTransformedObject = new (std::nothrow) Boolean(false);
1317                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1318                         break;
1319                 }
1320                 case DATA_BINDING_DATA_TYPE_COLOR:
1321                 {
1322                         pTransformedObject = new (std::nothrow) Color;
1323                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1324                         break;
1325                 }
1326                 case DATA_BINDING_DATA_TYPE_DIMENSION:
1327                 {
1328                         pTransformedObject = new (std::nothrow) Dimension;
1329                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1330                         break;
1331                 }
1332                 case DATA_BINDING_DATA_TYPE_DOUBLE:
1333                 {
1334                         pTransformedObject = new (std::nothrow) Double;
1335                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1336                         break;
1337                 }
1338                 case DATA_BINDING_DATA_TYPE_FLOAT:
1339                 {
1340                         pTransformedObject = new (std::nothrow) Float;
1341                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1342                         break;
1343                 }
1344                 case DATA_BINDING_DATA_TYPE_INTEGER:
1345                 {
1346                         pTransformedObject = new (std::nothrow) Integer;
1347                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1348                         break;
1349                 }
1350                 case DATA_BINDING_DATA_TYPE_LONG:
1351                 {
1352                         pTransformedObject = new (std::nothrow) Long;
1353                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1354                         break;
1355                 }
1356                 case DATA_BINDING_DATA_TYPE_POINT:
1357                 {
1358                         pTransformedObject = new (std::nothrow) Point;
1359                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1360                         break;
1361                 }
1362                 case DATA_BINDING_DATA_TYPE_RECTANGLE:
1363                 {
1364                         pTransformedObject = new (std::nothrow) Rectangle;
1365                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1366                         break;
1367                 }
1368                 case DATA_BINDING_DATA_TYPE_STRING:
1369                 {
1370                         pTransformedObject = new (std::nothrow) String;
1371                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1372                         break;
1373                 }
1374                 case DATA_BINDING_DATA_TYPE_FLOAT_POINT:
1375                 {
1376                         pTransformedObject = new (std::nothrow) FloatPoint;
1377                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1378                         break;
1379                 }
1380                 case DATA_BINDING_DATA_TYPE_FLOAT_RECTANGLE:
1381                 {
1382                         pTransformedObject = new (std::nothrow) FloatRectangle;
1383                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1384                         break;
1385                 }
1386                 case DATA_BINDING_DATA_TYPE_FLOAT_DIMENSION:
1387                 {
1388                         pTransformedObject = new (std::nothrow) FloatDimension;
1389                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1390                         break;
1391                 }
1392                 default:
1393                         SysTryCatch(NID_UI, false, , E_SYSTEM, "[E_SYSTEM] System Error");
1394                 }
1395                 SysTryCatch(NID_UI, pTransformedObject, , E_SYSTEM, "[E_SYSTEM] data transfer is failed by memory shortage.");
1396                 SysTryCatch(NID_UI, __pTransformer->TransformTargetToSource(__bindingId, originType, *pOriginObject, transformedType, *pTransformedObject) == true, , E_SYSTEM, "[E_SYSTEM] data transfer is failed by transformer.");
1397
1398                 if (__pValidator != null)
1399                 {
1400                         valid = __pValidator->ValidateDataToSource(__bindingId, *pTransformedObject);
1401                 }
1402                 if (valid == false)
1403                 {
1404                         if (__pListener != null)
1405                         {
1406                                 __pListener->OnDataBindingValidationFailed(__bindingId, pControl->GetName(), __propertyName, destinationType);
1407                         }
1408                         SysTryCatch(NID_UI, 0, , E_SYSTEM, "[E_SYSTEM] data transfer is failed by validator.");
1409                 }
1410
1411                 switch (variant.GetType())
1412                 {
1413
1414                 case VARIANT_TYPE_INT:
1415                         static_cast<Integer&>(*__pDataSource) = static_cast<Integer*>(pTransformedObject)->ToInt();
1416                         break;
1417
1418                 case VARIANT_TYPE_BOOL:
1419                         static_cast<Boolean&>(*__pDataSource) = static_cast<Boolean*>(pTransformedObject)->ToBool();
1420                         break;
1421
1422                 case VARIANT_TYPE_FLOAT:
1423                         static_cast<Float&>(*__pDataSource) = static_cast<Float*>(pTransformedObject)->ToFloat();
1424                         break;
1425
1426                 case VARIANT_TYPE_DOUBLE:
1427                         static_cast<Double&>(*__pDataSource) = static_cast<Double*>(pTransformedObject)->ToDouble();
1428                         break;
1429
1430                 case VARIANT_TYPE_LONG:
1431                         static_cast<Long&>(*__pDataSource) = static_cast<Long*>(pTransformedObject)->ToLong();
1432                         break;
1433
1434                 case VARIANT_TYPE_STRING:
1435                         static_cast<String&>(*__pDataSource) = static_cast<String&>(*pTransformedObject);
1436                         break;
1437
1438                 case VARIANT_TYPE_COLOR:
1439                         static_cast<Color&>(*__pDataSource) = static_cast<Color&>(*pTransformedObject);
1440                         break;
1441
1442                 case VARIANT_TYPE_POINT:
1443                         static_cast<Point*>(__pDataSource)->SetPosition(static_cast<Point&>(*pTransformedObject));
1444                         break;
1445
1446                 case VARIANT_TYPE_RECTANGLE:
1447                         static_cast<Rectangle*>(__pDataSource)->SetBounds(static_cast<Rectangle&>(*pTransformedObject).x, static_cast<Rectangle&>(*pTransformedObject).y, static_cast<Rectangle&>(*pTransformedObject).width, static_cast<Rectangle&>(*pTransformedObject).height);
1448                         break;
1449
1450                 case VARIANT_TYPE_DIMENSION:
1451                         static_cast<Dimension*>(__pDataSource)->SetSize(static_cast<Dimension&>(*pTransformedObject).width, static_cast<Dimension&>(*pTransformedObject).height);
1452                         break;
1453
1454                 case VARIANT_TYPE_FLOAT_POINT:
1455                         static_cast<FloatPoint*>(__pDataSource)->SetPosition(static_cast<FloatPoint&>(*pTransformedObject).x, static_cast<FloatPoint&>(*pTransformedObject).y);
1456                         break;
1457
1458                 case VARIANT_TYPE_FLOAT_RECTANGLE:
1459                         static_cast<FloatRectangle*>(__pDataSource)->SetBounds(static_cast<FloatRectangle&>(*pTransformedObject).x, static_cast<FloatRectangle&>(*pTransformedObject).y, static_cast<FloatRectangle&>(*pTransformedObject).width, static_cast<FloatRectangle&>(*pTransformedObject).height);
1460                         break;
1461
1462                 case VARIANT_TYPE_FLOAT_DIMENSION:
1463                         static_cast<FloatDimension*>(__pDataSource)->SetSize(static_cast<FloatDimension&>(*pTransformedObject).width, static_cast<FloatDimension&>(*pTransformedObject).height);
1464                         break;
1465                 default:
1466                         break;
1467                 }
1468
1469                 if (__pListener != null)
1470                 {
1471                         __pListener->OnDataBindingSourceUpdated(__bindingId, pControl->GetName(), __propertyName);
1472                 }
1473                 r = E_SUCCESS;
1474         }
1475         else // DATA_BINDING_DESTINATION_TYPE_TARGET
1476         {
1477                 DataBindingDataType originType = __sourceType;
1478                 Object* pOriginObject = __pDataSource;
1479                 DataBindingDataType transformedType = __targetType;
1480
1481                 switch(__targetType)
1482                 {
1483                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
1484                 {
1485                         pTransformedObject = new (std::nothrow) Boolean(false);
1486                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1487                         break;
1488                 }
1489                 case DATA_BINDING_DATA_TYPE_COLOR:
1490                 {
1491                         pTransformedObject = new (std::nothrow) Color;
1492                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1493                         break;
1494                 }
1495                 case DATA_BINDING_DATA_TYPE_DIMENSION:
1496                 {
1497                         pTransformedObject = new (std::nothrow) Dimension;
1498                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1499                         break;
1500                 }
1501                 case DATA_BINDING_DATA_TYPE_DOUBLE:
1502                 {
1503                         pTransformedObject = new (std::nothrow) Double;
1504                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1505                         break;
1506                 }
1507                 case DATA_BINDING_DATA_TYPE_FLOAT:
1508                 {
1509                         pTransformedObject = new (std::nothrow) Float;
1510                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1511                         break;
1512                 }
1513                 case DATA_BINDING_DATA_TYPE_INTEGER:
1514                 {
1515                         pTransformedObject = new (std::nothrow) Integer;
1516                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1517                         break;
1518                 }
1519                 case DATA_BINDING_DATA_TYPE_LONG:
1520                 {
1521                         pTransformedObject = new (std::nothrow) Long;
1522                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1523                         break;
1524                 }
1525                 case DATA_BINDING_DATA_TYPE_POINT:
1526                 {
1527                         pTransformedObject = new (std::nothrow) Point;
1528                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1529                         break;
1530                 }
1531                 case DATA_BINDING_DATA_TYPE_RECTANGLE:
1532                 {
1533                         pTransformedObject = new (std::nothrow) Rectangle;
1534                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1535                         break;
1536                 }
1537                 case DATA_BINDING_DATA_TYPE_STRING:
1538                 {
1539                         pTransformedObject = new (std::nothrow) String;
1540                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1541                         break;
1542                 }
1543                 case DATA_BINDING_DATA_TYPE_FLOAT_POINT:
1544                 {
1545                         pTransformedObject = new (std::nothrow) FloatPoint;
1546                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1547                         break;
1548                 }
1549                 case DATA_BINDING_DATA_TYPE_FLOAT_RECTANGLE:
1550                 {
1551                         pTransformedObject = new (std::nothrow) FloatRectangle;
1552                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1553                         break;
1554                 }
1555                 case DATA_BINDING_DATA_TYPE_FLOAT_DIMENSION:
1556                 {
1557                         pTransformedObject = new (std::nothrow) FloatDimension;
1558                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1559                         break;
1560                 }
1561                 default:
1562                         SysTryCatch(NID_UI, false, , E_SYSTEM, "[E_SYSTEM] System Error");
1563                 }
1564                 SysTryCatch(NID_UI, pTransformedObject, , E_SYSTEM, "[E_SYSTEM] data transfer is failed by memory shortage.");
1565                 SysTryCatch(NID_UI, __pTransformer->TransformSourceToTarget(__bindingId, originType, *pOriginObject, transformedType, *pTransformedObject) == true, , E_SYSTEM, "[E_SYSTEM] data transfer is failed by transformer.");
1566
1567                 if (__pValidator != null)
1568                 {
1569                         valid = __pValidator->ValidateDataToTarget(__bindingId, *pTransformedObject);
1570                 }
1571                 if (valid == false)
1572                 {
1573                         if (__pListener != null)
1574                         {
1575                                 __pListener->OnDataBindingValidationFailed(__bindingId, pControl->GetName(), __propertyName, destinationType);
1576                         }
1577                         SysTryCatch(NID_UI, 0, , E_SYSTEM, "[E_SYSTEM] data transfer is failed by validator.");
1578                 }
1579                 else
1580                 {
1581                         Variant variant;
1582                         switch (transformedType)
1583                         {
1584                         case DATA_BINDING_DATA_TYPE_BOOLEAN:
1585                                 variant = static_cast<Boolean*>(pTransformedObject)->ToBool();
1586                                 break;
1587
1588                         case DATA_BINDING_DATA_TYPE_COLOR:
1589                                 variant = *static_cast<Color*>(pTransformedObject);
1590                                 break;
1591
1592                         case DATA_BINDING_DATA_TYPE_DIMENSION:
1593                                 variant = *static_cast<Dimension*>(pTransformedObject);
1594                                 break;
1595
1596                         case DATA_BINDING_DATA_TYPE_DOUBLE:
1597                                 variant = static_cast<Double*>( pTransformedObject)->ToDouble();
1598                                 break;
1599
1600                         case DATA_BINDING_DATA_TYPE_FLOAT:
1601                                 variant = static_cast<Float*>(pTransformedObject)->ToFloat();
1602                                 break;
1603
1604                         case DATA_BINDING_DATA_TYPE_INTEGER:
1605                                 variant = static_cast<Integer*>(pTransformedObject)->ToInt();
1606                                 break;
1607
1608                         case DATA_BINDING_DATA_TYPE_LONG:
1609                                 variant = static_cast<Long*>(pTransformedObject)->ToLong();
1610                                 break;
1611
1612                         case DATA_BINDING_DATA_TYPE_POINT:
1613                                 variant = *static_cast<Point*>(pTransformedObject);
1614                                 break;
1615
1616                         case DATA_BINDING_DATA_TYPE_RECTANGLE:
1617                                 variant = *static_cast<Rectangle*>(pTransformedObject);
1618                                 break;
1619
1620                         case DATA_BINDING_DATA_TYPE_STRING:
1621                                 variant = *static_cast<String*>(pTransformedObject);
1622                                 break;
1623
1624                         case DATA_BINDING_DATA_TYPE_FLOAT_POINT:
1625                                 variant = *static_cast<FloatPoint*>(pTransformedObject);
1626                                 break;
1627
1628                         case DATA_BINDING_DATA_TYPE_FLOAT_RECTANGLE:
1629                                 variant = *static_cast<FloatRectangle*>(pTransformedObject);
1630                                 break;
1631
1632                         case DATA_BINDING_DATA_TYPE_FLOAT_DIMENSION:
1633                                 variant = *static_cast<FloatDimension*>(pTransformedObject);
1634                                 break;
1635                         default:
1636                                 goto CATCH;
1637                         }
1638                         pControl->SetProperty(__propertyName, variant);
1639                         if (__pListener != null)
1640                         {
1641                                 __pListener->OnDataBindingTargetUpdated(__bindingId, pControl->GetName(), __propertyName);
1642                         }
1643                 }
1644                 r = E_SUCCESS;
1645         }
1646 CATCH:
1647         delete pOriginObject;
1648         delete pTransformedObject;
1649         return r;
1650 }
1651 result
1652 _DataBinding::SetDataBindingListener(const IDataBindingListener* pListener)
1653 {
1654         __pListener = const_cast<IDataBindingListener*>(pListener);
1655         return E_SUCCESS;
1656 }
1657 _ControlHandle
1658 _DataBinding::Get_ControlHandle(void) const
1659 {
1660         return __controlHandle;
1661 }
1662 String
1663 _DataBinding::GetPropertyName(void) const
1664 {
1665         return __propertyName;
1666 }
1667 DataBindingDataType
1668 _DataBinding::GetSourceDataType(void) const
1669 {
1670         return __sourceType;
1671 }
1672 DataBindingDataType
1673 _DataBinding::GetTargetDataType(void) const
1674 {
1675         return __targetType;
1676 }
1677 DataBindingFlow
1678 _DataBinding::GetDataFlow(void) const
1679 {
1680         return __flow;
1681 }
1682 DataBindingTrigger
1683 _DataBinding::GetTrigger(void) const
1684 {
1685         return __trigger;
1686 }
1687
1688 }} // Tizen::Ui