src/view/common/evas_object.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16 /*
  17  * @file        evas_object.cpp
  18  * @author      Lukasz Wrzosek (l.wrzosel@samsung.com)
  19  * @version     1.0
  20  * @brief       This file is the implementation for Evas_Object wrapper from Efl.
  21  */
  22
  23 #include "evas_object.h"
  24 #include <dpl/foreach.h>
  25
  26 Evas_Object* EvasObject::IConnection::GetEvasObject()
  27 {
  28     return m_object->GetObject();
  29 }
  30
  31 void EvasObject::IConnection::Disconnect()
  32 {
  33     m_object->DisconnectCallback(this);
  34 }
  35
  36 EvasObject::IConnection::IConnection(EvasObject::EvasObjectShared* object) :
  37     m_object(object)
  38 {
  39 }
  40
  41 void EvasObject::IConnection::SmartCallbackWrapper(void* data,
  42         Evas_Object* /*object*/,
  43         void* event_info)
  44 {
  45     Assert(data);
  46     IConnection* Calle = static_cast<IConnection*>(data);
  47     Calle->Call(event_info);
  48 }
  49
  50 void EvasObject::IConnection::EvasCallbackWrapper(void* data,
  51         Evas* /*evas*/,
  52         Evas_Object* /*object*/,
  53         void* event_info)
  54 {
  55     Assert(data);
  56     IConnection* Calle = static_cast<IConnection*>(data);
  57     Calle->Call(event_info);
  58 }
  59
  60 Evas_Object* EvasObject::EvasObjectShared::GetObject()
  61 {
  62     return m_object;
  63 }
  64
  65 EvasObject::EvasObjectShared::SmartConnectionBase::SmartConnectionBase(
  66         const std::string& name,
  67         EvasObject::EvasObjectShared* object) :
  68     IConnection(object),
  69     m_callbackName(name)
  70 {
  71 }
  72
  73 void EvasObject::EvasObjectShared::SmartConnectionBase::ConnectPrv()
  74 {
  75     evas_object_smart_callback_add(GetEvasObject(),
  76                                    m_callbackName.c_str(),
  77                                    &IConnection::SmartCallbackWrapper, this);
  78 }
  79
  80 void EvasObject::EvasObjectShared::SmartConnectionBase::DisconnectPrv()
  81 {
  82     evas_object_smart_callback_del(GetEvasObject(),
  83                                    m_callbackName.c_str(),
  84                                    &IConnection::SmartCallbackWrapper);
  85 }
  86
  87 EvasObject::EvasObjectShared::EvasConnectionBase::EvasConnectionBase(
  88         Evas_Callback_Type type,
  89         EvasObject::EvasObjectShared* object) :
  90     IConnection(object),
  91     m_callbackType(type)
  92 {
  93 }
  94
  95 void EvasObject::EvasObjectShared::EvasConnectionBase::ConnectPrv()
  96 {
  97     evas_object_event_callback_add(
  98         GetEvasObject(), m_callbackType, &IConnection::EvasCallbackWrapper,
  99         this);
 100 }
 101
 102 void EvasObject::EvasObjectShared::EvasConnectionBase::DisconnectPrv()
 103 {
 104     evas_object_event_callback_del_full(
 105         GetEvasObject(), m_callbackType, &IConnection::EvasCallbackWrapper,
 106         this);
 107 }
 108
 109 EvasObject::EvasObjectShared::EvasObjectShared() :
 110     m_object(NULL)
 111 {
 112 }
 113
 114 EvasObject::EvasObjectShared::EvasObjectShared(Evas_Object* object) :
 115     m_object(object)
 116 {
 117     Assert(m_object);
 118     evas_object_event_callback_add(m_object,
 119                                    EVAS_CALLBACK_DEL,
 120                                    &StaticOnDelEvent,
 121                                    this);
 122 }
 123
 124 void EvasObject::EvasObjectShared::SetObject(Evas_Object* object)
 125 {
 126     Assert(m_object == NULL);
 127     Assert(object != NULL);
 128     m_object = object;
 129     evas_object_event_callback_add(m_object,
 130                                    EVAS_CALLBACK_DEL,
 131                                    &StaticOnDelEvent,
 132                                    this);
 133 }
 134
 135 EvasObject::EvasObjectShared::~EvasObjectShared()
 136 {
 137     if (m_object) {
 138         DisconnectAll();
 139         evas_object_event_callback_del(m_object,
 140                                        EVAS_CALLBACK_DEL,
 141                                        &StaticOnDelEvent);
 142         m_object = NULL;
 143     }
 144 }
 145
 146 bool EvasObject::EvasObjectShared::DisconnectCallback(IConnection* connection)
 147 {
 148     IConnectionsSet::iterator it = m_connections.find(connection);
 149     if (it != m_connections.end()) {
 150         (*it)->DisconnectPrv();
 151         delete connection;
 152         m_connections.erase(it);
 153         return true;
 154     }
 155     return false;
 156 }
 157
 158 void EvasObject::EvasObjectShared::DisconnectAll()
 159 {
 160     FOREACH(it, m_connections)
 161     {
 162         (*it)->DisconnectPrv();
 163         delete *it;
 164     }
 165     m_connections.clear();
 166 }
 167
 168 void EvasObject::EvasObjectShared::StaticOnDelEvent(void* data,
 169         Evas* /*e*/,
 170         Evas_Object* /*o*/,
 171         void* /*ev*/)
 172 {
 173     Assert(data);
 174     EvasObjectShared* This = static_cast<EvasObjectShared*>(data);
 175     if (This->m_object) {
 176         evas_object_event_callback_del(This->m_object,
 177                                        EVAS_CALLBACK_DEL,
 178                                        &StaticOnDelEvent);
 179         This->DisconnectAll();
 180         This->m_object = NULL;
 181     }
 182 }
 183
 184 EvasObject::EvasObject() :
 185     m_object(new EvasObjectShared())
 186 {
 187 }
 188
 189 EvasObject::EvasObject(Evas_Object* object) :
 190     m_object(new EvasObjectShared(object))
 191 {
 192 }
 193
 194 EvasObject::EvasObject(const EvasObject& other) :
 195     m_object(other.m_object)
 196 {
 197 }
 198
 199 //this destructor must be here to let pimpl with shared_ptr work without warning
 200 EvasObject::~EvasObject()
 201 {
 202 }
 203
 204 EvasObject& EvasObject::operator=(const EvasObject& other)
 205 {
 206     Assert(m_object);
 207     m_object = other.m_object;
 208     return *this;
 209 }
 210
 211 EvasObject* EvasObject::operator=(Evas_Object* object)
 212 {
 213     Assert(m_object);
 214     m_object->SetObject(object);
 215     return this;
 216 }
 217
 218 bool EvasObject::DisconnectCallback(IConnection* connection)
 219 {
 220     Assert(m_object);
 221     return m_object->DisconnectCallback(connection);
 222 }
 223
 224 void EvasObject::DisconnectAll()
 225 {
 226     Assert(m_object);
 227     m_object->DisconnectAll();
 228 }
 229
 230 EvasObject::operator Evas_Object *()
 231 {
 232     Assert(m_object);
 233     return m_object->GetObject();
 234 }