dali/internal/event/images/image-impl.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   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
  18 // CLASS HEADER
  19 #include <dali/internal/event/images/image-impl.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/public-api/common/dali-common.h>
  23 #include <dali/public-api/object/type-registry.h>
  24
  25 #include <dali/integration-api/debug.h>
  26 #include <dali/internal/event/resources/resource-ticket.h>
  27 #include <dali/internal/event/common/thread-local-storage.h>
  28 #include <dali/internal/event/resources/resource-client.h>
  29 #include <dali/internal/event/images/image-factory.h>
  30 #include <dali/internal/event/images/nine-patch-image-impl.h>
  31 #include <dali/internal/event/common/stage-impl.h>
  32
  33 using namespace Dali::Integration;
  34
  35 namespace Dali
  36 {
  37
  38 namespace Internal
  39 {
  40
  41 namespace
  42 {
  43
  44 BaseHandle CreateImage()
  45 {
  46   ImagePtr image = Image::New();
  47   return Dali::Image(image.Get());
  48 }
  49
  50 TypeRegistration mType( typeid(Dali::Image), typeid(Dali::BaseHandle), CreateImage );
  51
  52 Dali::SignalConnectorType signalConnector1(mType, Dali::Image::SIGNAL_IMAGE_LOADING_FINISHED,    &Image::DoConnectSignal);
  53 Dali::SignalConnectorType signalConnector2(mType, Dali::Image::SIGNAL_IMAGE_UPLOADED,            &Image::DoConnectSignal);
  54
  55 }
  56
  57 Image::Image( LoadPolicy loadPol, ReleasePolicy releasePol )
  58 : mImageFactory(ThreadLocalStorage::Get().GetImageFactory()),
  59   mWidth(0),
  60   mHeight(0),
  61   mConnectionCount(0),
  62   mLoadPolicy(loadPol),
  63   mReleasePolicy(releasePol)
  64 {
  65 }
  66
  67 ImagePtr Image::New()
  68 {
  69   ImagePtr image = new Image;
  70   image->Initialize();
  71   return image;
  72 }
  73
  74 ImagePtr Image::New( const std::string& filename, const Dali::ImageAttributes& attributes, LoadPolicy loadPol, ReleasePolicy releasePol )
  75 {
  76   ImagePtr image;
  77   if( IsNinePatchFileName(filename) )
  78   {
  79     image = NinePatchImage::New( filename, attributes, loadPol, releasePol );
  80   }
  81   else
  82   {
  83     image = new Image( loadPol, releasePol );
  84     image->Initialize();
  85
  86     // consider the requested size as natural size, 0 means we don't (yet) know it
  87     image->mWidth = attributes.GetWidth();
  88     image->mHeight = attributes.GetHeight();
  89     image->mRequest = image->mImageFactory.RegisterRequest( filename, &attributes );
  90
  91     if( Dali::Image::Immediate == loadPol )
  92     {
  93       // Trigger loading of the image on a as soon as it can be done
  94       image->mTicket = image->mImageFactory.Load( *image->mRequest.Get() );
  95       image->mTicket->AddObserver( *image );
  96     }
  97   }
  98   DALI_LOG_SET_OBJECT_STRING( image, filename );
  99
 100   return image;
 101 }
 102
 103 ImagePtr Image::New( NativeImage& nativeImg )
 104 {
 105   ImagePtr image = new Image;
 106   image->Initialize();
 107
 108   ResourceClient &resourceClient = ThreadLocalStorage::Get().GetResourceClient();
 109
 110   image->mWidth  = nativeImg.GetWidth();
 111   image->mHeight = nativeImg.GetHeight();
 112
 113   const ResourceTicketPtr& ticket = resourceClient.AddNativeImage( nativeImg );
 114   DALI_ASSERT_DEBUG( dynamic_cast<ImageTicket*>( ticket.Get() ) && "Resource ticket not ImageTicket subclass for image resource.\n" );
 115   image->mTicket = static_cast<ImageTicket*>(ticket.Get());
 116   image->mTicket->AddObserver( *image );
 117
 118   return image;
 119 }
 120
 121 Image::~Image()
 122 {
 123   if( mTicket )
 124   {
 125     mTicket->RemoveObserver( *this );
 126     if( Stage::IsInstalled() )
 127     {
 128       mImageFactory.ReleaseTicket( mTicket.Get() );
 129     }
 130   }
 131
 132   if( Stage::IsInstalled() )
 133   {
 134     UnregisterObject();
 135   }
 136 }
 137
 138 bool Image::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 139 {
 140   bool connected( true );
 141   DALI_ASSERT_DEBUG( dynamic_cast<Image*>( object ) && "Resource ticket not ImageTicket subclass for image resource.\n" );
 142   Image* image = static_cast<Image*>(object);
 143
 144   if( Dali::Image::SIGNAL_IMAGE_LOADING_FINISHED == signalName )
 145   {
 146     image->LoadingFinishedSignal().Connect( tracker, functor );
 147   }
 148   else if(Dali::Image::SIGNAL_IMAGE_UPLOADED == signalName)
 149   {
 150     image->UploadedSignal().Connect( tracker, functor );
 151   }
 152   else
 153   {
 154     // signalName does not match any signal
 155     connected = false;
 156   }
 157
 158   return connected;
 159 }
 160
 161 ResourceId Image::GetResourceId() const
 162 {
 163   ResourceId ret = mTicket ? mTicket->GetId() : 0;
 164
 165   return ret;
 166 }
 167
 168 const Dali::ImageAttributes& Image::GetAttributes() const
 169 {
 170   if( mTicket )
 171   {
 172     return mImageFactory.GetActualAttributes( mTicket );
 173   }
 174   else
 175   {
 176     return mImageFactory.GetRequestAttributes( mRequest );
 177   }
 178 }
 179
 180 const std::string& Image::GetFilename() const
 181 {
 182   return mImageFactory.GetRequestPath( mRequest );
 183 }
 184
 185 void Image::Reload()
 186 {
 187   if ( mRequest )
 188   {
 189     ResourceTicketPtr ticket = mImageFactory.Reload( *mRequest.Get() );
 190     SetTicket( ticket.Get() );
 191   }
 192 }
 193
 194 void Image::ResourceLoadingFailed(const ResourceTicket& ticket)
 195 {
 196   mLoadingFinishedV2.Emit( Dali::Image( this ) );
 197 }
 198
 199 void Image::ResourceLoadingSucceeded(const ResourceTicket& ticket)
 200 {
 201   mLoadingFinishedV2.Emit( Dali::Image( this ) );
 202 }
 203
 204 void Image::ResourceUploaded(const ResourceTicket& ticket)
 205 {
 206   mUploadedV2.Emit( Dali::Image( this ) );
 207 }
 208
 209 void Image::ResourceSavingSucceeded( const ResourceTicket& ticket )
 210 {
 211   // do nothing
 212 }
 213
 214 void Image::ResourceSavingFailed( const ResourceTicket& ticket )
 215 {
 216   // do nothing
 217 }
 218
 219 unsigned int Image::GetWidth() const
 220 {
 221   // if width is 0, it means we've not yet loaded the image
 222   if( 0u == mWidth )
 223   {
 224     Size size;
 225     mImageFactory.GetImageSize( mRequest, mTicket, size );
 226     mWidth = size.width;
 227     // The app will probably ask for the height immediately, so don't waste the synchronous file IO that ImageFactory may have just done:
 228     DALI_ASSERT_DEBUG( 0 == mHeight || unsigned(size.height) == mHeight );
 229     if( 0 == mHeight )
 230     {
 231       mHeight = size.height;
 232     }
 233   }
 234   return mWidth;
 235 }
 236
 237 unsigned int Image::GetHeight() const
 238 {
 239   if( 0u == mHeight )
 240   {
 241     Size size;
 242     mImageFactory.GetImageSize( mRequest, mTicket, size );
 243     mHeight = size.height;
 244     DALI_ASSERT_DEBUG( 0 == mWidth || unsigned(size.width) == mWidth );
 245     if( 0 == mWidth )
 246     {
 247       mWidth = size.width;
 248     }
 249   }
 250   return mHeight;
 251 }
 252
 253 Vector2 Image::GetNaturalSize() const
 254 {
 255   Vector2 naturalSize(mWidth, mHeight);
 256   if( 0u == mWidth || 0u == mHeight )
 257   {
 258     mImageFactory.GetImageSize( mRequest, mTicket, naturalSize );
 259     mWidth = naturalSize.width;
 260     mHeight = naturalSize.height;
 261   }
 262   return naturalSize;
 263 }
 264
 265 void Image::Connect()
 266 {
 267   ++mConnectionCount;
 268
 269   if( mConnectionCount == 1 )
 270   {
 271     // ticket was thrown away when related actors went offstage or image loading on demand
 272     if( !mTicket )
 273     {
 274       DALI_ASSERT_DEBUG( mRequest.Get() );
 275       ResourceTicketPtr newTicket = mImageFactory.Load( *mRequest.Get() );
 276       SetTicket( newTicket.Get() );
 277     }
 278   }
 279 }
 280
 281 void Image::Disconnect()
 282 {
 283   if( !mTicket )
 284   {
 285     return;
 286   }
 287
 288   DALI_ASSERT_DEBUG( mConnectionCount > 0 );
 289   --mConnectionCount;
 290   if( mConnectionCount == 0 && mReleasePolicy == Dali::Image::Unused )
 291   {
 292     // release image memory when it's not visible anymore (decrease ref. count of texture)
 293     SetTicket( NULL );
 294   }
 295 }
 296
 297 void Image::Initialize()
 298 {
 299   RegisterObject();
 300 }
 301
 302 void Image::SetTicket( ResourceTicket* ticket )
 303 {
 304   if( ticket == mTicket.Get() )
 305   {
 306     return;
 307   }
 308
 309   if( mTicket )
 310   {
 311     mTicket->RemoveObserver( *this );
 312     mImageFactory.ReleaseTicket( mTicket.Get() );
 313   }
 314
 315   if( ticket )
 316   {
 317     mTicket.Reset( ticket );
 318     mTicket->AddObserver( *this );
 319   }
 320   else
 321   {
 322     mTicket.Reset();
 323   }
 324 }
 325
 326 bool Image::IsNinePatchFileName( const std::string& filename )
 327 {
 328   bool match = false;
 329
 330   std::string::const_reverse_iterator iter = filename.rbegin();
 331   enum { SUFFIX, HASH, HASH_DOT, DONE } state = SUFFIX;
 332   while(iter < filename.rend())
 333   {
 334     switch(state)
 335     {
 336       case SUFFIX:
 337       {
 338         if(*iter == '.')
 339         {
 340           state = HASH;
 341         }
 342         else if(!isalnum(*iter))
 343         {
 344           state = DONE;
 345         }
 346       }
 347       break;
 348       case HASH:
 349       {
 350         if( *iter == '#' || *iter == '9' )
 351         {
 352           state = HASH_DOT;
 353         }
 354         else
 355         {
 356           state = DONE;
 357         }
 358       }
 359       break;
 360       case HASH_DOT:
 361       {
 362         if(*iter == '.')
 363         {
 364           match = true;
 365         }
 366         state = DONE; // Stop testing characters
 367       }
 368       break;
 369       case DONE:
 370       {
 371       }
 372       break;
 373     }
 374
 375     // Satisfy prevent
 376     if( state == DONE )
 377     {
 378       break;
 379     }
 380
 381     ++iter;
 382   }
 383   return match;
 384 }
 385
 386
 387 } // namespace Internal
 388
 389 } // namespace Dali