src/ui/scenes/FUiScenes_SceneImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #include <FUiScenesISceneEventListener.h>
  19 #include <FUiScenesISceneAnimationProvider.h>
  20 #include <FBaseSysLog.h>
  21 #include "FUiScenes_SceneImpl.h"
  22
  23
  24 using namespace Tizen::Base;
  25 using namespace Tizen::Base::Collection;
  26 using namespace Tizen::Ui::Controls;
  27
  28
  29 namespace Tizen { namespace Ui { namespace Scenes
  30 {
  31
  32
  33 _SceneImpl::_SceneImpl(void)
  34         : __pForm(null)
  35         , __pPanel(null)
  36         , __pArgs(null)
  37         , __pSceneAnimationProvider(null)
  38         , __panelCreatedFromFormResource(false)
  39 {
  40
  41 }
  42
  43 _SceneImpl::~_SceneImpl(void)
  44 {
  45 }
  46
  47 bool
  48 _SceneImpl::Equals(const Object& rhs) const
  49 {
  50         const Scene* pScene = dynamic_cast<const Scene*>(&rhs);
  51         if (pScene == null)
  52         {
  53                 return false;
  54         }
  55
  56         const _SceneImpl* pSceneImpl = _SceneImpl::GetInstance(*pScene);
  57         if (pSceneImpl == this)
  58         {
  59                 return true;
  60         }
  61
  62         if (__sceneId == pSceneImpl->GetSceneId())
  63         {
  64                 return true;
  65         }
  66
  67         return false;
  68 }
  69
  70 int
  71 _SceneImpl::GetHashCode(void) const
  72 {
  73         return __sceneId.GetHashCode();
  74 }
  75
  76 SceneId
  77 _SceneImpl::GetSceneId(void) const
  78 {
  79         return __sceneId;
  80 }
  81
  82 String
  83 _SceneImpl::GetFormId(void) const
  84 {
  85         return __formId;
  86 }
  87
  88 String
  89 _SceneImpl::GetPanelId(void) const
  90 {
  91         return __panelId;
  92 }
  93
  94 Form*
  95 _SceneImpl::GetForm(void) const
  96 {
  97         return __pForm;
  98 }
  99
 100 void
 101 _SceneImpl::SetForm(Form* pForm)
 102 {
 103         __pForm = pForm;
 104 }
 105
 106 Panel*
 107 _SceneImpl::GetPanel(void) const
 108 {
 109         return __pPanel;
 110 }
 111
 112 void
 113 _SceneImpl::SetPanel(Panel* pPanel)
 114 {
 115         __pPanel = pPanel;
 116 }
 117
 118 void
 119 _SceneImpl::SetArgs(IList* pArgs)
 120 {
 121         __pArgs = pArgs;
 122 }
 123
 124 IList*
 125 _SceneImpl::GetArgs(void)
 126 {
 127         return __pArgs;
 128 }
 129
 130 result
 131 _SceneImpl::AddSceneEventListener(const ISceneEventListener& sceneEventlistener)
 132 {
 133         result r = E_SUCCESS;
 134         ISceneEventListener* pListener = const_cast <ISceneEventListener*>(&sceneEventlistener);
 135         bool alreadyExist = __sceneEventListenerList.Contains(pListener);
 136         SysTryReturnResult(NID_UI_SCENES, !alreadyExist, E_OBJ_ALREADY_EXIST, "The event listener already exist.");
 137         r = __sceneEventListenerList.Add(pListener);
 138         SysTryReturn(NID_UI_SCENES, !IsFailed(r), r, r, "[%s] Propagating.", GetErrorMessage(r));
 139         return r;
 140 }
 141
 142 result
 143 _SceneImpl::RemoveSceneEventListener(const ISceneEventListener& sceneEventlistener)
 144 {
 145         result r = E_SUCCESS;
 146         ISceneEventListener* pListener = const_cast <ISceneEventListener*>(&sceneEventlistener);
 147         r = __sceneEventListenerList.Remove(pListener);
 148         SysTryReturn(NID_UI_SCENES, !IsFailed(r), r, r, "[%s] Propagating.", GetErrorMessage(r));
 149         return r;
 150 }
 151
 152 result
 153 _SceneImpl::SetSceneAnimationProvider(ISceneAnimationProvider* pSceneAnimationProvider)
 154 {
 155         ISceneAnimationProvider* pListener = pSceneAnimationProvider;
 156         __pSceneAnimationProvider = pListener;
 157         return E_SUCCESS;
 158 }
 159
 160 bool
 161 _SceneImpl::OnSceneActivatedN(const SceneId& previousSceneId, const SceneId& currentSceneId, IList* pArgs)
 162 {
 163         IEnumeratorT<ISceneEventListener*>* pEnum = __sceneEventListenerList.GetEnumeratorN();
 164         if (!pEnum)
 165         {
 166                 return false;
 167         }
 168
 169         while (pEnum->MoveNext() == E_SUCCESS)
 170         {
 171                 ISceneEventListener* pListener = null;
 172                 pEnum->GetCurrent(pListener);
 173                 if (pListener)
 174                 {
 175                         pListener->OnSceneActivatedN(previousSceneId, currentSceneId, pArgs);
 176                 }
 177         }
 178         delete pEnum;
 179         return true;
 180 }
 181
 182 bool
 183 _SceneImpl::OnSceneDeactivated(const SceneId& currentSceneId, const SceneId& nextSceneId)
 184 {
 185         IEnumeratorT<ISceneEventListener*>* pEnum = __sceneEventListenerList.GetEnumeratorN();
 186         if (!pEnum)
 187         {
 188                 return false;
 189         }
 190
 191         while (pEnum->MoveNext() == E_SUCCESS)
 192         {
 193                 ISceneEventListener* pListener = null;
 194                 pEnum->GetCurrent(pListener);
 195                 if (pListener)
 196                 {
 197                         pListener->OnSceneDeactivated(currentSceneId, nextSceneId);
 198                 }
 199         }
 200         delete pEnum;
 201         return true;
 202 }
 203
 204 bool
 205 _SceneImpl::PrepareAnimation(const SceneId& sceneId, IList* pArgs, SceneTransitionAnimationType type, bool formTransition)
 206 {
 207         if (__pSceneAnimationProvider)
 208         {
 209                 __pSceneAnimationProvider->PrepareAnimation(sceneId, pArgs, type, formTransition);
 210                 return true;
 211         }
 212
 213         return false;
 214 }
 215
 216 bool
 217 _SceneImpl::IsPanelCreatedFromFormResource(void) const
 218 {
 219         return __panelCreatedFromFormResource;
 220 }
 221
 222 void
 223 _SceneImpl::SetPanelCreatedFromFormResource(bool createFromFormResource)
 224 {
 225         __panelCreatedFromFormResource = createFromFormResource;
 226 }
 227
 228 Scene*
 229 _SceneImpl::CreateSceneN(const SceneId& sceneId, const String& formId, const String& panelId)
 230 {
 231         Scene* pScene = new (std::nothrow) Scene();
 232         SysTryReturn(NID_UI_SCENES, pScene != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.",
 233                                  GetErrorMessage(E_OUT_OF_MEMORY));
 234
 235         _SceneImpl* pSceneImpl = _SceneImpl::GetInstance(*pScene);
 236         SysTryCatch(NID_UI_SCENES, pSceneImpl != null, , E_INVALID_STATE,
 237                                 "[%s] Scene is in an invalid state. pSceneImpl is not valid", GetErrorMessage(E_INVALID_STATE));
 238         pSceneImpl->__sceneId = sceneId;
 239         pSceneImpl->__formId = formId;
 240         pSceneImpl->__panelId = panelId;
 241
 242         return pScene;
 243
 244 CATCH:
 245         delete pScene;
 246         return null;
 247 }
 248
 249 _SceneImpl*
 250 _SceneImpl::GetInstance(Scene& scene)
 251 {
 252         return scene.__pSceneImpl;
 253 }
 254
 255 const _SceneImpl*
 256 _SceneImpl::GetInstance(const Scene& scene)
 257 {
 258         return scene.__pSceneImpl;
 259 }
 260
 261 } } } // Tizen::Ui::Scenes