src/ui/FUi_UiBuilder.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 /**
  19 * @file         FUi_UiBuilder.cpp
  20 * @brief                This is the implementation file for _UiBuilder class.
  21 */
  22
  23 #include <new>
  24 #include <FAppApp.h>
  25 #include <FUiIOrientationEventListener.h>
  26 #include <FUi_ControlImplManager.h>
  27 #include "FGrp_Screen.h"
  28 #include <FBaseSysLog.h>
  29 #include "FUiCtrl_FrameImpl.h"
  30 #include "FUi_UiBuilder.h"
  31 #include "FUi_UiBuilderXmlHandler.h"
  32 #include "FUi_ControlManager.h"
  33
  34 using namespace Tizen::Base;
  35 using namespace Tizen::Base::Collection;
  36 using namespace Tizen::Io;
  37 using namespace Tizen::Ui;
  38 using namespace Tizen::Ui::Controls;
  39 using namespace Tizen::Media;
  40 using namespace Tizen::Graphics;
  41
  42 namespace Tizen { namespace Ui
  43 {
  44 _UiBuilder::_UiBuilder(void)
  45         : __version(0)
  46         , __lastIndex(0)
  47         , __logicalResolution(0)
  48         , __pUiBuilderControlList(null)
  49         , __pContainer(null)
  50         , __rotate(UIBUIDER_SCREEN_NONE)
  51         , __pTransform(null)
  52         , __xmlFile(L"")
  53 {
  54 }
  55
  56 _UiBuilder::~_UiBuilder(void)
  57 {
  58         if (__pUiBuilderControlList)
  59         {
  60                 _UiBuilderControl* pUiBuilderControl = null;
  61                 int controlCount = __pUiBuilderControlList->GetCount();
  62                 for (int i = 0; i < controlCount; i++)
  63                 {
  64                         __pUiBuilderControlList->GetAt(i, pUiBuilderControl);
  65                         delete pUiBuilderControl;
  66                 }
  67                 __pUiBuilderControlList->RemoveAll();
  68                 delete __pUiBuilderControlList;
  69                 __pUiBuilderControlList = null;
  70         }
  71 }
  72
  73 _UiBuilderControl*
  74 _UiBuilder::GetControl(int index) const
  75 {
  76         SysTryReturn(NID_UI, index >= 0 && index < UIBUILDER_CONTROL_MAX_COUNT, null, E_INVALID_ARG,
  77                                 "[E_INVALID_ARG] Index is over than max control count");
  78
  79         _UiBuilderControl* pUiBuilderControl = null;
  80         __pUiBuilderControlList->GetAt(index, pUiBuilderControl);
  81         if (pUiBuilderControl == null)
  82         {
  83                 SysLogException(NID_UI, GetLastResult(), "Failed to GetControl()");
  84                 return null;
  85         }
  86
  87         return pUiBuilderControl;
  88 }
  89
  90 _UiBuilderControl*
  91 _UiBuilder::GetControl(const Tizen::Base::String& id) const
  92 {
  93         IEnumeratorT<_UiBuilderControl*>* pEnum = __pUiBuilderControlList->GetEnumeratorN();
  94         SysTryReturn(NID_UI, pEnum != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Unable to get IEnumeratorT.");
  95         _UiBuilderControl* pUiBuilderControl = null;
  96
  97         while (pEnum->MoveNext() == E_SUCCESS)
  98         {
  99                 pEnum->GetCurrent(pUiBuilderControl);
 100                 String controlId = pUiBuilderControl->GetId();
 101
 102                 if (controlId.Equals(id, false))
 103                 {
 104                         delete pEnum;
 105                         return pUiBuilderControl;
 106                 }
 107         }
 108         delete pEnum;
 109         return null;
 110
 111 }
 112
 113 void
 114 _UiBuilder::SetVersion(int xmlVersion)
 115 {
 116         __version = xmlVersion;
 117 }
 118
 119 int
 120 _UiBuilder::GetVersion(void) const
 121 {
 122         return __version;
 123 }
 124
 125 result
 126 _UiBuilder::Construct(const String& xmlFile, Container* pContainer)
 127 {
 128         result r = E_SUCCESS;
 129
 130         __pContainer =  pContainer;
 131         __xmlFile = xmlFile;
 132         __pUiBuilderControlList = new (std::nothrow) ArrayListT<_UiBuilderControl*>;
 133         SysTryCatch(NID_UI, __pUiBuilderControlList != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Unable to create __pUiBuilderControlList.");
 134
 135         return r;
 136
 137         CATCH:
 138
 139         delete __pUiBuilderControlList;
 140         return r;
 141 }
 142
 143 result
 144 _UiBuilder::MakeUI(_UiBuilderControl* pControl)
 145 {
 146         result r = E_SUCCESS;
 147
 148         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 149         if(pUiBuilderControlTableManager == null)
 150         {
 151                 return E_OUT_OF_MEMORY;
 152         }
 153
 154         for (int i = 0; i < UIBUILDER_CONTROL_MAX_COUNT; i++)
 155         {
 156                 if (pUiBuilderControlTableManager->GetName(i).IsEmpty())
 157                 {
 158                         break;
 159                 }
 160
 161                 if (pControl->GetType().Equals(pUiBuilderControlTableManager->GetName(i), false))
 162                 {
 163                         _UiBuilderControlMakerFunctionPointer pControlMakerFunctionPointer = pUiBuilderControlTableManager->GetControlMaker(i);
 164                         if (pControlMakerFunctionPointer != null)
 165                         {
 166                                 _UiBuilderControlMaker* pMaker = pControlMakerFunctionPointer(this);
 167                                 r = pMaker->MakeControl(pControl);
 168
 169                                 delete pMaker;
 170                                 return r;
 171                         }
 172                 }
 173
 174         }
 175
 176         return E_OPERATION_FAILED;
 177 }
 178
 179 result
 180 _UiBuilder::Parse(void)
 181 {
 182         File file;
 183         ByteBuffer buffer;
 184         FileAttributes attrib;
 185         int readCount = 0;
 186         byte* pXmlContents = null;
 187         result r = E_SUCCESS;
 188         bool findPath = false;
 189         int size = 0;
 190         String xmlFilePath(L"");
 191         String temp;
 192         String homePath;
 193
 194         __logicalResolution = _CoordinateSystem::GetInstance()->GetLogicalResolutionInt();
 195
 196         xmlFilePath.Append(__xmlFile);
 197         xmlFilePath.Append(L".xml");
 198
 199         _ControlManager* pControlManager = _ControlManager::GetInstance();
 200         SysTryReturn(NID_UI, pControlManager != null, E_OPERATION_FAILED, E_OPERATION_FAILED, "[E_OPERATION_FAILED] Unable to get the control manager");
 201
 202         int screenWidth = _Screen::GetWidth();
 203         int screenHeight = _Screen::GetHeight();
 204
 205         // find xml file with device deviceResolution
 206         temp = xmlFilePath;
 207         r = temp.Insert("/", 0);
 208         SysTryReturn(NID_UI, r == E_SUCCESS, E_OPERATION_FAILED, E_OPERATION_FAILED, "[%s] Propagated.", GetErrorMessage(r));
 209         r = temp.Insert(screenHeight, 0);
 210         SysTryReturn(NID_UI, r == E_SUCCESS, E_OPERATION_FAILED, E_OPERATION_FAILED, "[%s] Propagated.", GetErrorMessage(r));
 211         r = temp.Insert("x", 0);
 212         SysTryReturn(NID_UI, r == E_SUCCESS, E_OPERATION_FAILED, E_OPERATION_FAILED, "[%s] Propagated.", GetErrorMessage(r));
 213         r = temp.Insert(screenWidth, 0);
 214         SysTryReturn(NID_UI, r == E_SUCCESS, E_OPERATION_FAILED, E_OPERATION_FAILED, "[%s] Propagated.", GetErrorMessage(r));
 215         r = temp.Insert("res/", 0);
 216         SysTryReturn(NID_UI, r == E_SUCCESS, E_OPERATION_FAILED, E_OPERATION_FAILED, "[%s] Propagated.", GetErrorMessage(r));
 217
 218         homePath = Tizen::App::App::GetInstance()->GetAppRootPath();
 219         r = temp.Insert(homePath, 0);
 220         SysTryReturn(NID_UI, r == E_SUCCESS, E_OPERATION_FAILED, E_OPERATION_FAILED, "[%s] Propagated.", GetErrorMessage(r));
 221         SysLog(NID_IO, "[UiBuilder] ui builder res path: %ls", temp.GetPointer());
 222
 223         // find device deviceResolution directory
 224         if (!File::IsFileExist(temp))
 225         {
 226                 temp = xmlFilePath;
 227                 r = temp.Insert("res/screen-size-normal/", 0);
 228                 SysTryReturn(NID_UI, r == E_SUCCESS, E_OPERATION_FAILED, E_OPERATION_FAILED, "[%s] Propagated.", GetErrorMessage(r));
 229
 230                 homePath = Tizen::App::App::GetInstance()->GetAppRootPath();
 231                 r = temp.Insert(homePath, 0);
 232                 SysTryReturn(NID_UI, r == E_SUCCESS, E_OPERATION_FAILED, E_OPERATION_FAILED, "[%s] Propagated.", GetErrorMessage(r));
 233                 SysLog(NID_IO, "[UiBuilder] ui builder home path: %ls, res path: %ls", homePath.GetPointer(), temp.GetPointer());
 234
 235                 if (!pControlManager->IsCoordinateSystemLogical() || !File::IsFileExist(temp))         // if autoscale on, find ScreenSize normal
 236                 {
 237                         findPath = false;
 238                         SysLogException(NID_UI, E_FILE_NOT_FOUND, "[E_FILE_NOT_FOUND] Parse failed -- %ls file not found.", temp.GetPointer());
 239                         return E_FILE_NOT_FOUND;
 240                 }
 241         }
 242
 243         findPath = true;
 244         xmlFilePath = temp;
 245         r = file.Construct(xmlFilePath, L"r");
 246         if (IsFailed(r))
 247         {
 248                 SysLogException(NID_UI, E_OPERATION_FAILED, "[E_OPERATION_FAILED] Parse Failed -- XML file Construct.");
 249                 return E_OPERATION_FAILED;
 250         }
 251
 252         r = Tizen::Io::File::GetAttributes(xmlFilePath, attrib);
 253         if (IsFailed(r))
 254         {
 255                 SysLogException(NID_UI, E_OPERATION_FAILED, "[E_OPERATION_FAILED] Parse Failed -- XML file GetAttributes.");
 256                 return E_OPERATION_FAILED;
 257         }
 258         size = (int) attrib.GetFileSize();
 259
 260         r = buffer.Construct(size);
 261         if (IsFailed(r))
 262         {
 263                 SysLogException(NID_UI, E_OPERATION_FAILED, "[E_OPERATION_FAILED] Parse Failed - Buffer Construct Failed.");
 264                 return E_OPERATION_FAILED;
 265         }
 266
 267         r = file.Read(buffer);
 268         if (IsFailed(r))
 269         {
 270                 SysLogException(NID_UI, E_OPERATION_FAILED, "[E_OPERATION_FAILED] Parse Failed -- can't read the file.");
 271                 return E_OPERATION_FAILED;
 272         }
 273
 274         readCount = buffer.GetPosition();
 275         pXmlContents = new (std::nothrow) byte[readCount];
 276         SysTryReturn(NID_UI, pXmlContents != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Unable to create XmlContents.");
 277         buffer.Flip();
 278
 279         r = buffer.GetArray(pXmlContents, 0, readCount);
 280         if (IsFailed(r))
 281         {
 282                 SysLogException(NID_UI, E_OPERATION_FAILED, "[E_OPERATION_FAILED] Parse Failed -- buffer.GetArray is Failed.");
 283                 delete[] pXmlContents;
 284                 return E_OPERATION_FAILED;
 285         }
 286
 287         _UiBuilderXmlHandler xmlHandler;
 288         bool returnValue = false;
 289         char* pXmlBuffer = (char*) pXmlContents;
 290
 291
 292         returnValue = xmlHandler.Construct(this);
 293         if (returnValue ==  false)
 294         {
 295                 delete[] pXmlContents;
 296                 return E_OPERATION_FAILED;
 297         }
 298
 299         r = xmlHandler.ParseXml(pXmlBuffer, readCount);
 300         if (r != E_SUCCESS)
 301         {
 302                 SysLogException(NID_UI, r, "[%s] Propagation.", GetErrorMessage(r));
 303                 return r;
 304         }
 305
 306         if (__pTransform != null)
 307         {
 308                 _UiBuilderControl* pUiBuilderControl;
 309                 for (int i = 0; i < UIBUILDER_CONTROL_MAX_COUNT; i++)
 310                 {
 311                         pUiBuilderControl = GetControl(i);
 312                         if (pUiBuilderControl != null)
 313                         {
 314                                 _UiBuilderControlLayout* pUiBuilderControlLayoutPortrait;
 315                                 _UiBuilderControlLayout* pUiBuilderControlLayoutLandscape;
 316
 317                                 pUiBuilderControlLayoutPortrait = pUiBuilderControl->GetAttribute(UIBUILDER_ATTRIBUTE_PORTRAIT);
 318                 FloatRectangle rect =   pUiBuilderControlLayoutPortrait->GetRectF();
 319                 FloatRectangle realBounds = __pTransform->Transform(rect);
 320                                 pUiBuilderControlLayoutPortrait->SetRect(realBounds.x, realBounds.y, realBounds.width, realBounds.height);
 321
 322                                 pUiBuilderControlLayoutLandscape = pUiBuilderControl->GetAttribute(UIBUILDER_ATTRIBUTE_LANDSCAPE);
 323                 rect = pUiBuilderControlLayoutLandscape->GetRectF();
 324                                 realBounds = __pTransform->Transform(rect);
 325                                 pUiBuilderControlLayoutLandscape->SetRect(realBounds.x, realBounds.y, realBounds.width,         realBounds.height);
 326                         }
 327                         else
 328                         {
 329                                 break;
 330                         }
 331                 }
 332
 333         }
 334
 335         //Make UiControls with UiBuilderControls
 336         IEnumeratorT<_UiBuilderControl*>* pEnum = __pUiBuilderControlList->GetEnumeratorN();
 337         SysTryCatch(NID_UI, pEnum != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Unable to get IEnumeratorT.");
 338
 339         while (pEnum->MoveNext() == E_SUCCESS)
 340         {
 341                 _UiBuilderControl* pUiBuilderControl = null;
 342                 pEnum->GetCurrent(pUiBuilderControl);
 343                 if (pUiBuilderControl != null)
 344                 {
 345                         r = MakeUI(pUiBuilderControl);
 346                         SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[UiBuilder] Failed to create control %ls", pUiBuilderControl->GetType().GetPointer());
 347                         delete pUiBuilderControl;
 348                 }
 349         }
 350
 351         if (__pUiBuilderControlList)
 352         {
 353                 __pUiBuilderControlList->RemoveAll();
 354                 delete __pUiBuilderControlList;
 355                 __pUiBuilderControlList = null;
 356         }
 357
 358         if (__pTransform)
 359         {
 360                 delete __pTransform;
 361                 __pTransform = null;
 362         }
 363         delete[] pXmlContents;
 364         delete pEnum;
 365         return E_SUCCESS;
 366
 367         CATCH:
 368         if (__pTransform)
 369         {
 370                 delete __pTransform;
 371                 __pTransform = null;
 372         }
 373         delete[] pXmlContents;
 374         delete pEnum;
 375         return r;
 376
 377 }
 378
 379 _UiBuilderControl*
 380 _UiBuilder::CreateControl(void)
 381 {
 382         if (__pUiBuilderControlList == null)
 383         {
 384                 __pUiBuilderControlList = new (std::nothrow) ArrayListT<_UiBuilderControl*>;
 385                 SysTryReturn(NID_UI, __pUiBuilderControlList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Unable to create __pUiBuilderControlList.");
 386         }
 387
 388         _UiBuilderControl* pUiBuilderControl = null;
 389         pUiBuilderControl = new (std::nothrow) _UiBuilderControl;
 390         if (pUiBuilderControl != null)
 391         {
 392                 __pUiBuilderControlList->Add(pUiBuilderControl);
 393         }
 394         else
 395         {
 396                 SysLogException(NID_UI, E_OUT_OF_MEMORY, "Failed to CreateControl()");
 397                 return null;
 398         }
 399
 400         return  pUiBuilderControl;
 401 }
 402
 403 Tizen::Ui::Container*
 404 _UiBuilder::GetContainer() const
 405 {
 406         return __pContainer;
 407 }
 408
 409 void
 410 _UiBuilder::SetUiBuilderRotateState(_UiBuilderScreenRotate rotate)
 411 {
 412         __rotate = rotate;
 413 }
 414
 415 _UiBuilderScreenRotate
 416 _UiBuilder::GetUiBuilderRotateState() const
 417 {
 418         return __rotate;
 419 }
 420
 421 result
 422 _UiBuilder::SetFormXmlResolution(int formXmlResoluton)
 423 {
 424         result r = E_SUCCESS;
 425
 426         if (__pTransform == null)
 427         {
 428                 if (formXmlResoluton == 720 && __logicalResolution == 480)
 429                 {
 430                         __pTransform = _CoordinateSystem::GetTransformerN(720, _CoordinateSystem::GetInstance()->GetLogicalBaseScreenSize(), Dimension(480, 800), _CoordinateSystem::GetInstance()->GetPhysicalBaseScreenSize());
 431                         SysTryReturn(NID_UI, __pTransform != null, null, GetLastResult(),
 432                                                         "Failed to get Transformer");
 433                 }
 434                 if (formXmlResoluton == 480 && __logicalResolution == 720)
 435                 {
 436                         __pTransform = _CoordinateSystem::GetTransformerN(480, _CoordinateSystem::GetInstance()->GetLogicalBaseScreenSize(), Dimension(720, 1280), _CoordinateSystem::GetInstance()->GetPhysicalBaseScreenSize());
 437                         SysTryReturn(NID_UI, __pTransform != null, GetLastResult(), GetLastResult(),
 438                                                         "Failed to get Transformer");
 439                 }
 440         }
 441         else
 442         {
 443                 SysLog(NID_UI, "__pTransform is already exists");
 444                 r = E_SYSTEM;
 445         }
 446         return r;
 447 }
 448
 449 void
 450 _UiBuilder::SetLayoutOrientation(_UiBuilderControl* pUiBuilderControl, Tizen::Ui::Control* pControl)
 451 {
 452         _ControlImpl* pControlImpl = _ControlImpl::GetInstance(*pControl);
 453         _UiBuilderControlLayout* pLayout = null;
 454     FloatRectangle rect;
 455
 456         pLayout = pUiBuilderControl->GetAttribute(UIBUILDER_ATTRIBUTE_PORTRAIT);
 457     rect = pLayout->GetRectF();
 458     pControlImpl->SetBuilderBounds(_CONTROL_ORIENTATION_PORTRAIT, rect);
 459
 460         pLayout = pUiBuilderControl->GetAttribute(UIBUILDER_ATTRIBUTE_LANDSCAPE);
 461     rect = pLayout->GetRectF();
 462     pControlImpl->SetBuilderBounds(_CONTROL_ORIENTATION_LANDSCAPE, rect);
 463 }
 464
 465 _ICoordinateSystemTransformer*
 466 _UiBuilder::GetTransformer() const
 467 {
 468         return __pTransform;
 469 }
 470
 471 } }  // Tizen::Ui