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