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