src/ui/FUi_DataBinding.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.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://floralicense.org/license/
  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
 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                 case DATA_BINDING_DATA_TYPE_INTEGER:
 115                 {
 116                         Tizen::Base::Integer* pTarget = dynamic_cast<Tizen::Base::Integer*>(&destinationData);
 117                         if(!pTarget)
 118                         {
 119                                 return false;
 120                         }
 121                         pTarget->value = static_cast<Integer&>(const_cast<Object&>(sourceData)).ToInt();
 122                         return true;
 123                 }
 124
 125                 case DATA_BINDING_DATA_TYPE_LONG:
 126                 {
 127                         Tizen::Base::Integer* pTarget = dynamic_cast<Tizen::Base::Integer*>(&destinationData);
 128                         if(!pTarget)
 129                         {
 130                                 return false;
 131                         }
 132                         pTarget->value = static_cast<Long&>(const_cast<Object&>(sourceData)).ToInt();
 133                         return true;
 134                 }
 135
 136                 case DATA_BINDING_DATA_TYPE_COLOR:
 137                 {
 138                         Tizen::Base::Integer* pTarget = dynamic_cast<Tizen::Base::Integer*>(&destinationData);
 139                         if(!pTarget)
 140                         {
 141                                 return false;
 142                         }
 143                         pTarget->value = static_cast<Color&>(const_cast<Object&>(sourceData)).GetRGB32();
 144                         return true;
 145                 }
 146
 147                 default:
 148                         return false;
 149                 }
 150
 151         case DATA_BINDING_DATA_TYPE_FLOAT:
 152                 switch (sourceType) // FLOAT from DOUBLE, FLOAT, INTEGER, LONG, STRING
 153                 {
 154                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
 155                 {
 156                         Tizen::Base::Float* pTarget = dynamic_cast<Tizen::Base::Float*>(&destinationData);
 157                         if(!pTarget)
 158                         {
 159                                 return false;
 160                         }
 161                         pTarget->value = static_cast<Boolean&>(const_cast<Object&>(sourceData)).ToBool() ? 1.0 : 0.0;
 162                         return true;
 163                 }
 164                 case DATA_BINDING_DATA_TYPE_FLOAT:
 165                 {
 166                         Tizen::Base::Float* pTarget = dynamic_cast<Tizen::Base::Float*>(&destinationData);
 167                         if(!pTarget)
 168                         {
 169                                 return false;
 170                         }
 171                         pTarget->value = static_cast<Float&>(const_cast<Object&>(sourceData)).ToFloat();
 172                         return true;
 173                 }
 174
 175                 case DATA_BINDING_DATA_TYPE_INTEGER:
 176                 {
 177                         Tizen::Base::Float* pTarget = dynamic_cast<Tizen::Base::Float*>(&destinationData);
 178                         if(!pTarget)
 179                         {
 180                                 return false;
 181                         }
 182                         pTarget->value = static_cast<Integer&>(const_cast<Object&>(sourceData)).ToFloat();
 183                         return true;
 184                 }
 185                 case DATA_BINDING_DATA_TYPE_LONG:
 186                 {
 187                         Tizen::Base::Float* pTarget = dynamic_cast<Tizen::Base::Float*>(&destinationData);
 188                         if(!pTarget)
 189                         {
 190                                 return false;
 191                         }
 192                         pTarget->value = static_cast<Long&>(const_cast<Object&>(sourceData)).ToFloat();
 193                         return true;
 194                 }
 195                 default:
 196                         return false;
 197                 }
 198
 199         case DATA_BINDING_DATA_TYPE_DOUBLE:
 200                 switch (sourceType) // DOUBLE from DOUBLE, FLOAT, INTEGER, LONG, STRING
 201                 {
 202                 case DATA_BINDING_DATA_TYPE_DOUBLE:
 203                 {
 204                         Tizen::Base::Double* pTarget = dynamic_cast<Tizen::Base::Double*>(&destinationData);
 205                         if(!pTarget)
 206                         {
 207                                 return false;
 208                         }
 209                         pTarget->value = static_cast<Double&>(const_cast<Object&>(sourceData)).ToDouble();
 210                         return true;
 211                 }
 212                 case DATA_BINDING_DATA_TYPE_FLOAT:
 213                 {
 214                         Tizen::Base::Double* pTarget = dynamic_cast<Tizen::Base::Double*>(&destinationData);
 215                         if(!pTarget)
 216                         {
 217                                 return false;
 218                         }
 219                         pTarget->value = static_cast<Float&>(const_cast<Object&>(sourceData)).ToDouble();
 220                         return true;
 221                 }
 222                 case DATA_BINDING_DATA_TYPE_INTEGER:
 223                 {
 224                         Tizen::Base::Double* pTarget = dynamic_cast<Tizen::Base::Double*>(&destinationData);
 225                         if(!pTarget)
 226                         {
 227                                 return false;
 228                         }
 229                         pTarget->value = static_cast<Integer&>(const_cast<Object&>(sourceData)).ToDouble();
 230                         return true;
 231                 }
 232                 case DATA_BINDING_DATA_TYPE_LONG:
 233                 {
 234                         Tizen::Base::Double* pTarget = dynamic_cast<Tizen::Base::Double*>(&destinationData);
 235                         if(!pTarget)
 236                         {
 237                                 return false;
 238                         }
 239                         pTarget->value = static_cast<Long&>(const_cast<Object&>(sourceData)).ToDouble();
 240                         return true;
 241                 }
 242                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
 243                 {
 244                         Tizen::Base::Double* pTarget = dynamic_cast<Tizen::Base::Double*>(&destinationData);
 245                         if(!pTarget)
 246                         {
 247                                 return false;
 248                         }
 249                         pTarget->value = static_cast<Boolean&>(const_cast<Object&>(sourceData)).ToBool() ? 1.0 : 0.0;
 250                         return true;
 251                 }
 252                 default:
 253                         return false;
 254                 }
 255
 256         case DATA_BINDING_DATA_TYPE_LONG:
 257                 switch (sourceType) // LONG from DOUBLE, FLOAT, INTEGER, LONG, STRING
 258                 {
 259                 case DATA_BINDING_DATA_TYPE_FLOAT:
 260                 {
 261                         Tizen::Base::Long* pTarget = dynamic_cast<Tizen::Base::Long*>(&destinationData);
 262                         if(!pTarget)
 263                         {
 264                                 return false;
 265                         }
 266                         pTarget->value = static_cast<Float&>(const_cast<Object&>(sourceData)).ToLong();
 267                         return true;
 268                 }
 269                 case DATA_BINDING_DATA_TYPE_INTEGER:
 270                 {
 271                         Tizen::Base::Long* pTarget = dynamic_cast<Tizen::Base::Long*>(&destinationData);
 272                         if(!pTarget)
 273                         {
 274                                 return false;
 275                         }
 276                         pTarget->value = static_cast<Integer&>(const_cast<Object&>(sourceData)).ToLong();
 277                         return true;
 278                 }
 279                 case DATA_BINDING_DATA_TYPE_LONG:
 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<Long&>(const_cast<Object&>(sourceData)).ToLong();
 287                         return true;
 288                 }
 289                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
 290                 {
 291                         Tizen::Base::Long* pTarget = dynamic_cast<Tizen::Base::Long*>(&destinationData);
 292                         if(!pTarget)
 293                         {
 294                                 return false;
 295                         }
 296                         pTarget->value = static_cast<Boolean&>(const_cast<Object&>(sourceData)).ToBool() ? 1 : 0;
 297                         return true;
 298                 }
 299                 default:
 300                         return false;
 301                 }
 302
 303         case DATA_BINDING_DATA_TYPE_STRING:
 304                 switch (sourceType) // STRING from DOUBLE, FLOAT, INTEGER, LONG, STRING
 305                 {
 306                 case DATA_BINDING_DATA_TYPE_DOUBLE:
 307                 {
 308                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 309                         if(!pTarget)
 310                         {
 311                                 return false;
 312                         }
 313                         *pTarget = static_cast<Double&>(const_cast<Object&>(sourceData)).ToString();
 314                         return true;
 315                 }
 316
 317                 case DATA_BINDING_DATA_TYPE_FLOAT:
 318                 {
 319                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 320                         if(!pTarget)
 321                         {
 322                                 return false;
 323                         }
 324                         *pTarget = static_cast<Float&>(const_cast<Object&>(sourceData)).ToString();
 325                         return true;
 326                 }
 327
 328                 case DATA_BINDING_DATA_TYPE_INTEGER:
 329                 {
 330                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 331                         if(!pTarget)
 332                         {
 333                                 return false;
 334                         }
 335                         *pTarget = static_cast<Integer&>(const_cast<Object&>(sourceData)).ToString();
 336                         return true;
 337                 }
 338
 339                 case DATA_BINDING_DATA_TYPE_LONG:
 340                 {
 341                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 342                         if(!pTarget)
 343                         {
 344                                 return false;
 345                         }
 346                         *pTarget = static_cast<Long&>(const_cast<Object&>(sourceData)).ToString();
 347                         return true;
 348                 }
 349
 350                 case DATA_BINDING_DATA_TYPE_STRING:
 351                 {
 352                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 353                         if(!pTarget)
 354                         {
 355                                 return false;
 356                         }
 357                         *pTarget = static_cast<String&>(const_cast<Object&>(sourceData));
 358                         return true;
 359                 }
 360                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
 361                 {
 362                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 363                         if(!pTarget)
 364                         {
 365                                 return false;
 366                         }
 367                         *pTarget = static_cast<Boolean&>(const_cast<Object&>(sourceData)).ToString();
 368                         return true;
 369                 }
 370
 371                 case DATA_BINDING_DATA_TYPE_COLOR:
 372                 {
 373                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 374                         if(!pTarget)
 375                         {
 376                                 return false;
 377                         }
 378                         pTarget->Clear();
 379                         r= pTarget->Append(L"#");
 380                         if(r != E_SUCCESS)
 381                         {
 382                                 return false;
 383                         }
 384                         wchar_t tempString[] = L"XXXXXXXX";
 385                         swprintf(tempString, (sizeof(tempString) / sizeof(wchar_t)), L"%X",static_cast<Color &>(const_cast<Object&>(sourceData)).GetRGB32());
 386                         r= pTarget->Append(tempString);
 387                         if(r != E_SUCCESS)
 388                         {
 389                                 return false;
 390                         }
 391                         return true;
 392                 }
 393
 394                 case DATA_BINDING_DATA_TYPE_DIMENSION:
 395                 {
 396                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 397                         if(!pTarget)
 398                         {
 399                                 return false;
 400                         }
 401                         pTarget->Clear();
 402
 403                         String* pString = new (std::nothrow) String(L"");
 404                         SysTryReturn(NID_UI, pString, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 405
 406                         Dimension* pDimension = &static_cast<Dimension&>(const_cast<Object&>(sourceData));
 407                         r = pString->Append(L"width:");
 408                         if(r != E_SUCCESS)
 409                         {
 410                                 delete pString;
 411                                 return false;
 412                         }
 413                         r = pString->Append(pDimension->width);
 414                         if(r != E_SUCCESS)
 415                         {
 416                                 delete pString;
 417                                 return false;
 418                         }
 419                         r = pString->Append(L", height:");
 420                         if(r != E_SUCCESS)
 421                         {
 422                                 delete pString;
 423                                 return false;
 424                         }
 425                         r = pString->Append(pDimension->height);
 426                         if(r != E_SUCCESS)
 427                         {
 428                                 delete pString;
 429                                 return false;
 430                         }
 431                         *pTarget = *pString;
 432                         delete pString;
 433                         return true;
 434                 }
 435
 436                 case DATA_BINDING_DATA_TYPE_POINT:
 437                 {
 438                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 439                         if(!pTarget)
 440                         {
 441                                 return false;
 442                         }
 443                         pTarget->Clear();
 444
 445                         String* pString = new (std::nothrow) String(L"");
 446                         SysTryReturn(NID_UI, pString, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 447
 448                         Point* pPoint = &static_cast<Point &>(const_cast<Object&>(sourceData));
 449                         r = pString->Append(L"x:");
 450                         if(r != E_SUCCESS)
 451                         {
 452                                 delete pString;
 453                                 return false;
 454                         }
 455                         r = pString->Append(pPoint->x);
 456                         if(r != E_SUCCESS)
 457                         {
 458                                 delete pString;
 459                                 return false;
 460                         }
 461                         r = pString->Append(L", y:");
 462                         if(r != E_SUCCESS)
 463                         {
 464                                 delete pString;
 465                                 return false;
 466                         }
 467                         r = pString->Append(pPoint->y);
 468                         if(r != E_SUCCESS)
 469                         {
 470                                 delete pString;
 471                                 return false;
 472                         }
 473                         *pTarget = *pString;
 474                         delete pString;
 475                         return true;
 476                 }
 477
 478                 case DATA_BINDING_DATA_TYPE_RECTANGLE:
 479                 {
 480                         Tizen::Base::String* pTarget = dynamic_cast<Tizen::Base::String*>(&destinationData);
 481                         if(!pTarget)
 482                         {
 483                                 return false;
 484                         }
 485                         pTarget->Clear();
 486
 487                         String* pString = new (std::nothrow) String(L"");
 488                         SysTryReturn(NID_UI, pString, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 489
 490                         Rectangle* pRectangle = &static_cast<Rectangle &>(const_cast<Object&>(sourceData));
 491                         r = pString->Append(L"x:");
 492                         if(r != E_SUCCESS)
 493                         {
 494                                 delete pString;
 495                                 return false;
 496                         }
 497                         r = pString->Append(pRectangle->x);
 498                         if(r != E_SUCCESS)
 499                         {
 500                                 delete pString;
 501                                 return false;
 502                         }
 503                         r = pString->Append(L", y:");
 504                         if(r != E_SUCCESS)
 505                         {
 506                                 delete pString;
 507                                 return false;
 508                         }
 509                         r = pString->Append(pRectangle->y);
 510                         if(r != E_SUCCESS)
 511                         {
 512                                 delete pString;
 513                                 return false;
 514                         }
 515
 516                         r = pString->Append(L", width:");
 517                         if(r != E_SUCCESS)
 518                         {
 519                                 delete pString;
 520                                 return false;
 521                         }
 522                         r = pString->Append(pRectangle->width);
 523                         if(r != E_SUCCESS)
 524                         {
 525                                 delete pString;
 526                                 return false;
 527                         }
 528
 529                         r = pString->Append(L", height:");
 530                         if(r != E_SUCCESS)
 531                         {
 532                                 delete pString;
 533                                 return false;
 534                         }
 535                         r = pString->Append(pRectangle->height);
 536                         if(r != E_SUCCESS)
 537                         {
 538                                 delete pString;
 539                                 return false;
 540                         }
 541                         *pTarget = *pString;
 542                         delete pString;
 543                         return true;
 544                 }
 545                 default:
 546                         return false;
 547                 }
 548
 549         case DATA_BINDING_DATA_TYPE_COLOR:
 550                 if (sourceType == DATA_BINDING_DATA_TYPE_COLOR)
 551                 {
 552                         Color* pTarget = dynamic_cast<Color*>(&destinationData);
 553                         if(!pTarget)
 554                         {
 555                                 return false;
 556                         }
 557                         *pTarget = static_cast<Color&>(const_cast<Object&>(sourceData));
 558                         return true;
 559                 }
 560                 else if (sourceType == DATA_BINDING_DATA_TYPE_INTEGER)
 561                 {
 562                         Color* pTarget = dynamic_cast<Color*>(&destinationData);
 563                         if(!pTarget)
 564                         {
 565                                 return false;
 566                         }
 567                         *pTarget = static_cast<Integer&>(const_cast<Object&>(sourceData)).ToInt();
 568                         return true;
 569                 }
 570                 else
 571                 {
 572                         return false;
 573                 }
 574
 575         case DATA_BINDING_DATA_TYPE_POINT:
 576                 if (sourceType == DATA_BINDING_DATA_TYPE_POINT)
 577                 {
 578                         Point* pTarget = dynamic_cast<Point*>(&destinationData);
 579                         if(!pTarget)
 580                         {
 581                                 return false;
 582                         }
 583                         pTarget->SetPosition(static_cast<Point&>(const_cast<Object&>(sourceData)).x, static_cast<Point&>(const_cast<Object&>(sourceData)).y);
 584                         return true;
 585                 }
 586                 else if (sourceType == DATA_BINDING_DATA_TYPE_RECTANGLE)
 587                 {
 588                         Point* pTarget = dynamic_cast<Point*>(&destinationData);
 589                         if(!pTarget)
 590                         {
 591                                 return false;
 592                         }
 593                         pTarget->SetPosition(static_cast<Rectangle&>(const_cast<Object&>(sourceData)).x, static_cast<Rectangle&>(const_cast<Object&>(sourceData)).y);
 594                         return true;
 595                 }
 596                 else
 597                 {
 598                         return false;
 599                 }
 600
 601         case DATA_BINDING_DATA_TYPE_RECTANGLE:
 602                 if (sourceType == DATA_BINDING_DATA_TYPE_RECTANGLE)
 603                 {
 604                         Rectangle* pTarget = dynamic_cast<Rectangle*>(&destinationData);
 605                         if(!pTarget)
 606                         {
 607                                 return false;
 608                         }
 609                         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);
 610                         return true;
 611                 }
 612                 else
 613                 {
 614                         return false;
 615                 }
 616
 617         case DATA_BINDING_DATA_TYPE_DIMENSION:
 618                 if (sourceType == DATA_BINDING_DATA_TYPE_DIMENSION)
 619                 {
 620                         Dimension* pTarget = dynamic_cast<Dimension*>(&destinationData);
 621                         if(!pTarget)
 622                         {
 623                                 return false;
 624                         }
 625                         pTarget->SetSize(static_cast<Dimension&>(const_cast<Object&>(sourceData)).width, static_cast<Dimension&>(const_cast<Object&>(sourceData)).height);
 626                         return true;
 627                 }
 628                 else if (sourceType == DATA_BINDING_DATA_TYPE_RECTANGLE)
 629                 {
 630                         Dimension* pTarget = dynamic_cast<Dimension*>(&destinationData);
 631                         if(!pTarget)
 632                         {
 633                                 return false;
 634                         }
 635                         pTarget->SetSize(static_cast<Rectangle&>(const_cast<Object&>(sourceData)).width, static_cast<Rectangle&>(const_cast<Object&>(sourceData)).height);
 636                         return true;
 637                 }
 638                 else
 639                 {
 640                         return false;
 641                 }
 642
 643         default:
 644                 return false;
 645         }
 646 }
 647 bool
 648 _DefaultTransformer::IsTransformable(DataBindingDataType sourceType, DataBindingDataType destinationType)
 649 {
 650         bool returnValue = false;
 651
 652         switch (destinationType)
 653         {
 654         case DATA_BINDING_DATA_TYPE_INTEGER:
 655                 switch (sourceType) // INTEGER from BOOLEAN, DOUBLE, FLOAT, INTEGER, LONG, STRING
 656                 {
 657                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
 658                         //fall through
 659                 case DATA_BINDING_DATA_TYPE_FLOAT:
 660                         //fall through
 661                 case DATA_BINDING_DATA_TYPE_INTEGER:
 662                         //fall through
 663                 case DATA_BINDING_DATA_TYPE_LONG:
 664                         //fall through
 665                 case DATA_BINDING_DATA_TYPE_COLOR:
 666                         returnValue = true;
 667                         break;
 668                 default:
 669                         break;
 670                 }
 671                 break;
 672
 673         case DATA_BINDING_DATA_TYPE_FLOAT:
 674                 switch (sourceType) // FLOAT from DOUBLE, FLOAT, INTEGER, LONG, STRING
 675                 {
 676                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
 677                         //fall through
 678                 case DATA_BINDING_DATA_TYPE_FLOAT:
 679                         //fall through
 680                 case DATA_BINDING_DATA_TYPE_INTEGER:
 681                         //fall through
 682                 case DATA_BINDING_DATA_TYPE_LONG:
 683                         returnValue = true;
 684                         break;
 685                 default:
 686                         break;
 687                 }
 688                 break;
 689
 690         case DATA_BINDING_DATA_TYPE_DOUBLE:
 691                 switch (sourceType) // DOUBLE from DOUBLE, FLOAT, INTEGER, LONG, STRING
 692                 {
 693                 case DATA_BINDING_DATA_TYPE_DOUBLE:
 694                         //fall through
 695                 case DATA_BINDING_DATA_TYPE_FLOAT:
 696                         //fall through
 697                 case DATA_BINDING_DATA_TYPE_INTEGER:
 698                         //fall through
 699                 case DATA_BINDING_DATA_TYPE_LONG:
 700                         //fall through
 701                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
 702                         returnValue = true;
 703                         break;
 704                 default:
 705                         break;
 706                 }
 707                 break;
 708
 709         case DATA_BINDING_DATA_TYPE_LONG:
 710                 switch (sourceType) // LONG from DOUBLE, FLOAT, INTEGER, LONG, STRING
 711                 {
 712                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
 713                         //fall through
 714                 case DATA_BINDING_DATA_TYPE_FLOAT:
 715                         //fall through
 716                 case DATA_BINDING_DATA_TYPE_INTEGER:
 717                         //fall through
 718                 case DATA_BINDING_DATA_TYPE_LONG:
 719                         returnValue = true;
 720                         break;
 721                 default:
 722                         break;
 723                 }
 724                 break;
 725
 726         case DATA_BINDING_DATA_TYPE_STRING:
 727                 switch (sourceType) // STRING from all type
 728                 {
 729                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
 730                         //fall through
 731                 case DATA_BINDING_DATA_TYPE_COLOR:
 732                         //fall through
 733                 case DATA_BINDING_DATA_TYPE_DIMENSION:
 734                         //fall through
 735                 case DATA_BINDING_DATA_TYPE_DOUBLE:
 736                         //fall through
 737                 case DATA_BINDING_DATA_TYPE_FLOAT:
 738                         //fall through
 739                 case DATA_BINDING_DATA_TYPE_INTEGER:
 740                         //fall through
 741                 case DATA_BINDING_DATA_TYPE_LONG:
 742                         //fall through
 743                 case DATA_BINDING_DATA_TYPE_POINT:
 744                         //fall through
 745                 case DATA_BINDING_DATA_TYPE_RECTANGLE:
 746                         //fall through
 747                 case DATA_BINDING_DATA_TYPE_STRING:
 748                         returnValue = true;
 749                         break;
 750                 default:
 751                         break;
 752                 }
 753                 break;
 754
 755         case DATA_BINDING_DATA_TYPE_COLOR:
 756                 switch (sourceType) // COLOR from INTEGER, COLOR
 757                 {
 758                 case DATA_BINDING_DATA_TYPE_COLOR:
 759                         //fall through
 760                 case DATA_BINDING_DATA_TYPE_INTEGER:
 761                         returnValue = true;
 762                         break;
 763                 default:
 764                         break;
 765                 }
 766                 break;
 767
 768         case DATA_BINDING_DATA_TYPE_POINT:
 769                 switch (sourceType) // POINT from POINT, RECTANGLE
 770                 {
 771                 case DATA_BINDING_DATA_TYPE_POINT:
 772                         //fall through
 773                 case DATA_BINDING_DATA_TYPE_RECTANGLE:
 774                         returnValue = true;
 775                         break;
 776
 777                 default:
 778                         break;
 779                 }
 780                 break;
 781
 782         case DATA_BINDING_DATA_TYPE_RECTANGLE:
 783                 if (sourceType == DATA_BINDING_DATA_TYPE_RECTANGLE)
 784                         returnValue = true;
 785                 break;
 786         case DATA_BINDING_DATA_TYPE_DIMENSION:
 787                 switch (sourceType) // POINT from POINT, RECTANGLE
 788                 {
 789                 case DATA_BINDING_DATA_TYPE_DIMENSION:
 790                         //fall through
 791                 case DATA_BINDING_DATA_TYPE_RECTANGLE:
 792                         returnValue = true;
 793                         break;
 794                 default:
 795                         break;
 796                 }
 797                 break;
 798         default:
 799                 break;
 800         }
 801         return returnValue;
 802 }
 803
 804
 805 bool
 806 IsTypeSupported(VariantType variantType)
 807 {
 808         bool returnValue = false;
 809
 810         switch (variantType)
 811         {
 812         case VARIANT_TYPE_INT:
 813                 //fall through
 814         case VARIANT_TYPE_BOOL:
 815                 //fall through
 816         case VARIANT_TYPE_FLOAT:
 817                 //fall through
 818         case VARIANT_TYPE_DOUBLE:
 819                 //fall through
 820         case VARIANT_TYPE_LONG:
 821                 //fall through
 822         case VARIANT_TYPE_STRING:
 823                 //fall through
 824         case VARIANT_TYPE_COLOR:
 825                 //fall through
 826         case VARIANT_TYPE_POINT:
 827                 //fall through
 828         case VARIANT_TYPE_RECTANGLE:
 829                 //fall through
 830         case VARIANT_TYPE_DIMENSION:
 831                 returnValue = true;
 832                 break;
 833         default:
 834                 break;
 835         }
 836         return returnValue;
 837 }
 838 DataBindingDataType
 839 ConvertVariantTypeToDataBindingDataType(VariantType variantType)
 840 {
 841         DataBindingDataType dataType = DATA_BINDING_DATA_TYPE_BOOLEAN;
 842
 843         switch (variantType)
 844         {
 845         case VARIANT_TYPE_INT:
 846                 dataType = DATA_BINDING_DATA_TYPE_INTEGER;
 847                 break;
 848
 849         case VARIANT_TYPE_BOOL:
 850                 dataType = DATA_BINDING_DATA_TYPE_BOOLEAN;
 851                 break;
 852
 853         case VARIANT_TYPE_FLOAT:
 854                 dataType = DATA_BINDING_DATA_TYPE_FLOAT;
 855                 break;
 856
 857         case VARIANT_TYPE_DOUBLE:
 858                 dataType = DATA_BINDING_DATA_TYPE_DOUBLE;
 859                 break;
 860
 861         case VARIANT_TYPE_LONG:
 862                 dataType = DATA_BINDING_DATA_TYPE_LONG;
 863                 break;
 864
 865         case VARIANT_TYPE_STRING:
 866                 dataType = DATA_BINDING_DATA_TYPE_STRING;
 867                 break;
 868
 869         case VARIANT_TYPE_COLOR:
 870                 dataType = DATA_BINDING_DATA_TYPE_COLOR;
 871                 break;
 872
 873         case VARIANT_TYPE_POINT:
 874                 dataType = DATA_BINDING_DATA_TYPE_POINT;
 875                 break;
 876
 877         case VARIANT_TYPE_RECTANGLE:
 878                 dataType = DATA_BINDING_DATA_TYPE_RECTANGLE;
 879                 break;
 880
 881         case VARIANT_TYPE_DIMENSION:
 882                 dataType = DATA_BINDING_DATA_TYPE_DIMENSION;
 883                 break;
 884         default:
 885                 SysAssertf(0, "Not Support Type");
 886                 break;
 887         }
 888         return dataType;
 889 }
 890
 891 VariantType
 892 ConvertDataBindingDataTypeToVariantType(DataBindingDataType dataType)
 893 {
 894         VariantType variantType = VARIANT_TYPE_NONE;
 895         switch (dataType)
 896         {
 897         case DATA_BINDING_DATA_TYPE_BOOLEAN:
 898                 variantType = VARIANT_TYPE_BOOL;
 899                 break;
 900
 901         case DATA_BINDING_DATA_TYPE_COLOR:
 902                 variantType = VARIANT_TYPE_COLOR;
 903                 break;
 904
 905         case DATA_BINDING_DATA_TYPE_DIMENSION:
 906                 variantType = VARIANT_TYPE_DIMENSION;
 907                 break;
 908
 909         case DATA_BINDING_DATA_TYPE_DOUBLE:
 910                 variantType = VARIANT_TYPE_DOUBLE;
 911                 break;
 912
 913         case DATA_BINDING_DATA_TYPE_FLOAT:
 914                 variantType = VARIANT_TYPE_FLOAT;
 915                 break;
 916
 917         case DATA_BINDING_DATA_TYPE_INTEGER:
 918                 variantType = VARIANT_TYPE_INT;
 919                 break;
 920
 921         case DATA_BINDING_DATA_TYPE_LONG:
 922                 variantType = VARIANT_TYPE_LONG;
 923                 break;
 924
 925         case DATA_BINDING_DATA_TYPE_POINT:
 926                 variantType = VARIANT_TYPE_POINT;
 927                 break;
 928
 929         case DATA_BINDING_DATA_TYPE_RECTANGLE:
 930                 variantType = VARIANT_TYPE_RECTANGLE;
 931                 break;
 932
 933         case DATA_BINDING_DATA_TYPE_STRING:
 934                 variantType = VARIANT_TYPE_STRING;
 935                 break;
 936
 937         default:
 938                 break;
 939         }
 940         return variantType;
 941 }
 942
 943
 944 class _DataBindingPropertyChangeEventListner
 945         : public _IPropertyChangeEventListener
 946         , virtual public Tizen::Base::Runtime::IEventListener
 947 {
 948 public:
 949         _DataBindingPropertyChangeEventListner(const _DataBinding& dataBinding)
 950         {
 951                 __pDataBinding = &const_cast<_DataBinding&>(dataBinding);
 952         };
 953         virtual ~_DataBindingPropertyChangeEventListner(void){};
 954         virtual void OnPropertyChanging(_PropertyBase& source, const String& name, const Variant& oldValue, const Variant& newValue){};
 955         virtual void OnPropertyChanged(_PropertyBase& source, const String& name, const Variant& oldValue, const Variant& newValue)
 956         {
 957                 const Variant variant = source.GetProperty(name);
 958                 if (variant.IsEmpty() || oldValue == newValue)
 959                 {
 960                         return;
 961                 }
 962                 if (name == __pDataBinding->GetPropertyName())
 963                 {
 964                         __pDataBinding->Update(DATA_BINDING_DESTINATION_TYPE_SOURCE);
 965                 }
 966         };
 967 private:
 968         _DataBinding* __pDataBinding;
 969 }; //class _DataBindingPropertyChangeEventListner
 970
 971 _DefaultTransformer defaultTransformer;
 972 }
 973 namespace Tizen { namespace Ui
 974 {
 975 _DataBinding::_DataBinding(void)
 976         : __controlHandle()
 977         , __bindingId(L"")
 978         , __propertyName(L"")
 979         , __pDataSource(null)
 980         , __sourceType(DATA_BINDING_DATA_TYPE_BOOLEAN)
 981         , __targetType(DATA_BINDING_DATA_TYPE_BOOLEAN)
 982         , __flow(DATA_BINDING_FLOW_ONE_WAY)
 983         , __trigger(DATA_BINDING_TRIGGER_EXPLICIT)
 984         , __pListener(null)
 985         , __pValidator(null)
 986         , __pTransformer(null)
 987         , __pPropertyChangeEventListener(null)
 988 {
 989 }
 990 _DataBinding::~_DataBinding(void)
 991 {
 992         delete __pPropertyChangeEventListener;
 993         __pPropertyChangeEventListener = null;
 994 }
 995
 996 result
 997 _DataBinding::Construct(const _Control& control, const String& bindingId, const String& propertyName
 998                                            , Object& dataSource, DataBindingDataType sourceType, DataBindingFlow flow, DataBindingTrigger trigger
 999                                            , const IDataBindingListener* pListener, const IDataBindingDataValidator* pValidator, const IDataBindingDataTransformer* pTransformer)
1000 {
1001         __controlHandle = control.GetHandle();
1002         _Control* pControl = _ControlManager::GetInstance()->GetObject(__controlHandle);
1003         SysTryReturn(NID_UI, pControl, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] The control that was binded is gone.");
1004         __propertyName = propertyName;
1005         __pDataSource = &dataSource;
1006         __sourceType = sourceType;
1007         __flow = flow;
1008         __trigger = trigger;
1009         __pListener = const_cast<IDataBindingListener*>(pListener);
1010         __pValidator = const_cast<IDataBindingDataValidator*>(pValidator);
1011
1012         if (pTransformer != null)
1013                 __pTransformer = const_cast<IDataBindingDataTransformer*>(pTransformer);
1014         else
1015                 __pTransformer = &::defaultTransformer;
1016
1017         Variant variant = pControl->GetProperty(propertyName);
1018
1019         SysTryReturn(NID_UI, GetLastResult() != E_KEY_NOT_FOUND, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Property is not found.");
1020
1021         SysTryReturn(NID_UI, ::IsTypeSupported(variant.GetType()), E_UNSUPPORTED_FORMAT, E_UNSUPPORTED_FORMAT
1022                                 , "[E_UNSUPPORTED_FORMAT] Property type is unsupported type.");
1023
1024         __targetType = ::ConvertVariantTypeToDataBindingDataType(variant.GetType());
1025
1026         switch(__flow)
1027         {
1028                 case DATA_BINDING_FLOW_ONE_WAY:
1029                         SysTryReturn(NID_UI, __pTransformer->IsSourceToTargetTransformable(bindingId, __sourceType, __targetType)
1030                                                 , E_UNSUPPORTED_FORMAT, E_UNSUPPORTED_FORMAT, "[E_UNSUPPORTED_FORMAT] transformer can not transform source type to target type.");
1031                         break;
1032                 case DATA_BINDING_FLOW_ONE_WAY_TO_SOURCE:
1033                         SysTryReturn(NID_UI, __pTransformer->IsTargetToSourceTransformable(bindingId, __targetType, __sourceType)
1034                                                 , E_UNSUPPORTED_FORMAT, E_UNSUPPORTED_FORMAT, "[E_UNSUPPORTED_FORMAT] transformer can not transform target type to source type.");
1035                         break;
1036                 case DATA_BINDING_FLOW_TWO_WAY:
1037                         SysTryReturn(NID_UI, __pTransformer->IsSourceToTargetTransformable(bindingId, __sourceType, __targetType)
1038                                                 && __pTransformer->IsTargetToSourceTransformable(bindingId, __targetType, __sourceType)
1039                                                 , E_UNSUPPORTED_FORMAT, E_UNSUPPORTED_FORMAT, "[E_UNSUPPORTED_FORMAT] transformer can not transform both target type and source type.");
1040                         break;
1041                 default:
1042                         SysAssert(0);
1043         }
1044
1045         if (trigger == DATA_BINDING_TRIGGER_IMMEDIATE)
1046         {
1047                 __pPropertyChangeEventListener = new (std::nothrow) ::_DataBindingPropertyChangeEventListner(*this);
1048                 SysTryReturn(NID_UI, __pPropertyChangeEventListener, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1049                 pControl->AddPropertyChangeEventListener(*__pPropertyChangeEventListener);
1050         }
1051         return E_SUCCESS;
1052 }
1053
1054 result
1055 _DataBinding::Update(DataBindingDestinationType destinationType)
1056 {
1057         bool valid = true;
1058         Object* pTransformedObject = null;
1059         result r = E_SYSTEM;
1060         Object* pOriginObject = null;
1061         _Control* pControl = _ControlManager::GetInstance()->GetObject(__controlHandle);
1062         SysTryCatch(NID_UI, pControl, , E_SYSTEM, "[E_SYSTEM] The control that was binded is gone.");
1063
1064         if (destinationType == DATA_BINDING_DESTINATION_TYPE_SOURCE)
1065         {
1066                 DataBindingDataType originType = __targetType;
1067                 Variant variant = pControl->GetProperty(__propertyName);
1068                 DataBindingDataType transformedType = __sourceType;
1069
1070                 switch (variant.GetType())
1071                 {
1072                 case VARIANT_TYPE_INT:
1073                         pOriginObject = new (std::nothrow) Integer(variant.ToInt());
1074                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1075                         break;
1076
1077                 case VARIANT_TYPE_BOOL:
1078                         pOriginObject = new (std::nothrow) Boolean(variant.ToBool());
1079                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1080                         break;
1081
1082                 case VARIANT_TYPE_FLOAT:
1083                         pOriginObject = new (std::nothrow) Float(variant.ToFloat());
1084                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1085                         break;
1086
1087                 case VARIANT_TYPE_DOUBLE:
1088                         pOriginObject = new (std::nothrow) Double(variant.ToDouble());
1089                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1090                         break;
1091
1092                 case VARIANT_TYPE_LONG:
1093                         pOriginObject = new (std::nothrow) Long(variant.ToLong());
1094                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1095                         break;
1096
1097                 case VARIANT_TYPE_STRING:
1098                         pOriginObject = new (std::nothrow) String(variant.ToString());
1099                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1100                         break;
1101
1102                 case VARIANT_TYPE_COLOR:
1103                         pOriginObject = new (std::nothrow) Color(variant.ToColor());
1104                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1105                         break;
1106
1107                 case VARIANT_TYPE_POINT:
1108                         pOriginObject = new (std::nothrow) Point(variant.ToPoint().x, variant.ToPoint().y);
1109                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1110                         break;
1111
1112                 case VARIANT_TYPE_RECTANGLE:
1113                         pOriginObject = new (std::nothrow) Rectangle(variant.ToRectangle().x, variant.ToRectangle().y, variant.ToRectangle().width, variant.ToRectangle().height);
1114                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1115                         break;
1116
1117                 case VARIANT_TYPE_DIMENSION:
1118                         pOriginObject = new (std::nothrow) Dimension(variant.ToDimension().width, variant.ToDimension().height);
1119                         SysTryReturn(NID_UI, pOriginObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1120                         break;
1121                 default:
1122                         SysTryCatch(NID_UI, pControl, , E_SYSTEM, "[E_SYSTEM] The control that was binded is gone.");
1123                 }
1124
1125                 switch(__sourceType)
1126                 {
1127                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
1128                 {
1129                         pTransformedObject = new (std::nothrow) Boolean(false);
1130                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1131                         break;
1132                 }
1133                 case DATA_BINDING_DATA_TYPE_COLOR:
1134                 {
1135                         pTransformedObject = new (std::nothrow) Color;
1136                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1137                         break;
1138                 }
1139                 case DATA_BINDING_DATA_TYPE_DIMENSION:
1140                 {
1141                         pTransformedObject = new (std::nothrow) Dimension;
1142                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1143                         break;
1144                 }
1145                 case DATA_BINDING_DATA_TYPE_DOUBLE:
1146                 {
1147                         pTransformedObject = new (std::nothrow) Double;
1148                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1149                         break;
1150                 }
1151                 case DATA_BINDING_DATA_TYPE_FLOAT:
1152                 {
1153                         pTransformedObject = new (std::nothrow) Float;
1154                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1155                         break;
1156                 }
1157                 case DATA_BINDING_DATA_TYPE_INTEGER:
1158                 {
1159                         pTransformedObject = new (std::nothrow) Integer;
1160                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1161                         break;
1162                 }
1163                 case DATA_BINDING_DATA_TYPE_LONG:
1164                 {
1165                         pTransformedObject = new (std::nothrow) Long;
1166                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1167                         break;
1168                 }
1169                 case DATA_BINDING_DATA_TYPE_POINT:
1170                 {
1171                         pTransformedObject = new (std::nothrow) Point;
1172                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1173                         break;
1174                 }
1175                 case DATA_BINDING_DATA_TYPE_RECTANGLE:
1176                 {
1177                         pTransformedObject = new (std::nothrow) Rectangle;
1178                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1179                         break;
1180                 }
1181                 case DATA_BINDING_DATA_TYPE_STRING:
1182                 {
1183                         pTransformedObject = new (std::nothrow) String;
1184                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1185                         break;
1186                 }
1187                 default:
1188                         SysTryCatch(NID_UI, false, , E_SYSTEM, "[E_SYSTEM] System Error");
1189                 }
1190                 SysTryCatch(NID_UI, pTransformedObject, , E_SYSTEM, "[E_SYSTEM] data transfer is failed by memory shortage.");
1191                 SysTryCatch(NID_UI, __pTransformer->TransformTargetToSource(__bindingId, originType, *pOriginObject, transformedType, *pTransformedObject) == true, , E_SYSTEM, "[E_SYSTEM] data transfer is failed by transformer.");
1192
1193                 if (__pValidator != null)
1194                 {
1195                         valid = __pValidator->ValidateDataToSource(__bindingId, *pTransformedObject);
1196                 }
1197                 if (valid == false)
1198                 {
1199                         if (__pListener != null)
1200                         {
1201                                 __pListener->OnDataBindingValidationFailed(__bindingId, pControl->GetName(), __propertyName, destinationType);
1202                         }
1203                         SysTryCatch(NID_UI, 0, , E_SYSTEM, "[E_SYSTEM] data transfer is failed by validator.");
1204                 }
1205
1206                 switch (variant.GetType())
1207                 {
1208
1209                 case VARIANT_TYPE_INT:
1210                         static_cast<Integer&>(*__pDataSource) = static_cast<Integer*>(pTransformedObject)->ToInt();
1211                         break;
1212
1213                 case VARIANT_TYPE_BOOL:
1214                         static_cast<Boolean&>(*__pDataSource) = static_cast<Boolean*>(pTransformedObject)->ToBool();
1215                         break;
1216
1217                 case VARIANT_TYPE_FLOAT:
1218                         static_cast<Float&>(*__pDataSource) = static_cast<Float*>(pTransformedObject)->ToFloat();
1219                         break;
1220
1221                 case VARIANT_TYPE_DOUBLE:
1222                         static_cast<Double&>(*__pDataSource) = static_cast<Double*>(pTransformedObject)->ToDouble();
1223                         break;
1224
1225                 case VARIANT_TYPE_LONG:
1226                         static_cast<Long&>(*__pDataSource) = static_cast<Long*>(pTransformedObject)->ToLong();
1227                         break;
1228
1229                 case VARIANT_TYPE_STRING:
1230                         static_cast<String&>(*__pDataSource) = static_cast<String&>(*pTransformedObject);
1231                         break;
1232
1233                 case VARIANT_TYPE_COLOR:
1234                         static_cast<Color&>(*__pDataSource) = static_cast<Color&>(*pTransformedObject);
1235                         break;
1236
1237                 case VARIANT_TYPE_POINT:
1238                         static_cast<Point*>(__pDataSource)->SetPosition(static_cast<Point&>(*pTransformedObject));
1239                         break;
1240
1241                 case VARIANT_TYPE_RECTANGLE:
1242                         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);
1243                         break;
1244
1245                 case VARIANT_TYPE_DIMENSION:
1246                         static_cast<Dimension*>(__pDataSource)->SetSize(static_cast<Dimension&>(*pTransformedObject).width, static_cast<Dimension&>(*pTransformedObject).height);
1247                         break;
1248                 default:
1249                         break;
1250                 }
1251
1252                 if (__pListener != null)
1253                 {
1254                         __pListener->OnDataBindingSourceUpdated(__bindingId, pControl->GetName(), __propertyName);
1255                 }
1256                 r = E_SUCCESS;
1257         }
1258         else // DATA_BINDING_DESTINATION_TYPE_TARGET
1259         {
1260                 DataBindingDataType originType = __sourceType;
1261                 Object* pOriginObject = __pDataSource;
1262                 DataBindingDataType transformedType = __targetType;
1263
1264                 switch(__targetType)
1265                 {
1266                 case DATA_BINDING_DATA_TYPE_BOOLEAN:
1267                 {
1268                         pTransformedObject = new (std::nothrow) Boolean(false);
1269                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1270                         break;
1271                 }
1272                 case DATA_BINDING_DATA_TYPE_COLOR:
1273                 {
1274                         pTransformedObject = new (std::nothrow) Color;
1275                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1276                         break;
1277                 }
1278                 case DATA_BINDING_DATA_TYPE_DIMENSION:
1279                 {
1280                         pTransformedObject = new (std::nothrow) Dimension;
1281                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1282                         break;
1283                 }
1284                 case DATA_BINDING_DATA_TYPE_DOUBLE:
1285                 {
1286                         pTransformedObject = new (std::nothrow) Double;
1287                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1288                         break;
1289                 }
1290                 case DATA_BINDING_DATA_TYPE_FLOAT:
1291                 {
1292                         pTransformedObject = new (std::nothrow) Float;
1293                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1294                         break;
1295                 }
1296                 case DATA_BINDING_DATA_TYPE_INTEGER:
1297                 {
1298                         pTransformedObject = new (std::nothrow) Integer;
1299                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1300                         break;
1301                 }
1302                 case DATA_BINDING_DATA_TYPE_LONG:
1303                 {
1304                         pTransformedObject = new (std::nothrow) Long;
1305                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1306                         break;
1307                 }
1308                 case DATA_BINDING_DATA_TYPE_POINT:
1309                 {
1310                         pTransformedObject = new (std::nothrow) Point;
1311                         SysTryReturn(NID_UI, pTransformedObject, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
1312                         break;
1313                 }
1314                 case DATA_BINDING_DATA_TYPE_RECTANGLE:
1315                 {
1316                         pTransformedObject = new (std::nothrow) Rectangle;
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_STRING:
1321                 {
1322                         pTransformedObject = new (std::nothrow) String;
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                 default:
1327                         SysTryCatch(NID_UI, false, , E_SYSTEM, "[E_SYSTEM] System Error");
1328                 }
1329                 SysTryCatch(NID_UI, pTransformedObject, , E_SYSTEM, "[E_SYSTEM] data transfer is failed by memory shortage.");
1330                 SysTryCatch(NID_UI, __pTransformer->TransformSourceToTarget(__bindingId, originType, *pOriginObject, transformedType, *pTransformedObject) == true, , E_SYSTEM, "[E_SYSTEM] data transfer is failed by transformer.");
1331
1332                 if (__pValidator != null)
1333                 {
1334                         valid = __pValidator->ValidateDataToTarget(__bindingId, *pTransformedObject);
1335                 }
1336                 if (valid == false)
1337                 {
1338                         if (__pListener != null)
1339                         {
1340                                 __pListener->OnDataBindingValidationFailed(__bindingId, pControl->GetName(), __propertyName, destinationType);
1341                         }
1342                         SysTryCatch(NID_UI, 0, , E_SYSTEM, "[E_SYSTEM] data transfer is failed by validator.");
1343                 }
1344                 else
1345                 {
1346                         Variant variant;
1347                         switch (transformedType)
1348                         {
1349                         case DATA_BINDING_DATA_TYPE_BOOLEAN:
1350                                 variant = static_cast<Boolean*>(pTransformedObject)->ToBool();
1351                                 break;
1352
1353                         case DATA_BINDING_DATA_TYPE_COLOR:
1354                                 variant = *static_cast<Color*>(pTransformedObject);
1355                                 break;
1356
1357                         case DATA_BINDING_DATA_TYPE_DIMENSION:
1358                                 variant = *static_cast<Dimension*>(pTransformedObject);
1359                                 break;
1360
1361                         case DATA_BINDING_DATA_TYPE_DOUBLE:
1362                                 variant = static_cast<Double*>( pTransformedObject)->ToDouble();
1363                                 break;
1364
1365                         case DATA_BINDING_DATA_TYPE_FLOAT:
1366                                 variant = static_cast<Float*>(pTransformedObject)->ToFloat();
1367                                 break;
1368
1369                         case DATA_BINDING_DATA_TYPE_INTEGER:
1370                                 variant = static_cast<Integer*>(pTransformedObject)->ToInt();
1371                                 break;
1372
1373                         case DATA_BINDING_DATA_TYPE_LONG:
1374                                 variant = static_cast<Long*>(pTransformedObject)->ToLong();
1375                                 break;
1376
1377                         case DATA_BINDING_DATA_TYPE_POINT:
1378                                 variant = *static_cast<Point*>(pTransformedObject);
1379                                 break;
1380
1381                         case DATA_BINDING_DATA_TYPE_RECTANGLE:
1382                                 variant = *static_cast<Rectangle*>(pTransformedObject);
1383                                 break;
1384
1385                         case DATA_BINDING_DATA_TYPE_STRING:
1386                                 variant = *static_cast<String*>(pTransformedObject);
1387                                 break;
1388
1389                         default:
1390                                 goto CATCH;
1391                         }
1392                         pControl->SetProperty(__propertyName, variant);
1393                         if (__pListener != null)
1394                         {
1395                                 __pListener->OnDataBindingTargetUpdated(__bindingId, pControl->GetName(), __propertyName);
1396                         }
1397                 }
1398                 r = E_SUCCESS;
1399         }
1400 CATCH:
1401         delete pOriginObject;
1402         delete pTransformedObject;
1403         return r;
1404 }
1405 result
1406 _DataBinding::SetDataBindingListener(const IDataBindingListener* pListener)
1407 {
1408         __pListener = const_cast<IDataBindingListener*>(pListener);
1409         return E_SUCCESS;
1410 }
1411 _ControlHandle
1412 _DataBinding::Get_ControlHandle(void) const
1413 {
1414         return __controlHandle;
1415 }
1416 String
1417 _DataBinding::GetPropertyName(void) const
1418 {
1419         return __propertyName;
1420 }
1421 DataBindingDataType
1422 _DataBinding::GetSourceDataType(void) const
1423 {
1424         return __sourceType;
1425 }
1426 DataBindingDataType
1427 _DataBinding::GetTargetDataType(void) const
1428 {
1429         return __targetType;
1430 }
1431 DataBindingFlow
1432 _DataBinding::GetDataFlow(void) const
1433 {
1434         return __flow;
1435 }
1436 DataBindingTrigger
1437 _DataBinding::GetTrigger(void) const
1438 {
1439         return __trigger;
1440 }
1441
1442 }} // Tizen::Ui