// Button::PROPERTY_NORMAL_STATE_ACTOR
{
- button.SetButtonImage( Image::New( "IMAGE_PATH_1") );
+ button.SetButtonImage( ResourceImage::New( "IMAGE_PATH_1") );
DALI_TEST_EQUALS( "IMAGE_PATH_1", button.GetProperty( Button::PROPERTY_NORMAL_STATE_ACTOR ).GetValue( "image" ).GetValue( "filename" ).Get< std::string >(), TEST_LOCATION );
Property::Map map;
// Button::PROPERTY_SELECTED_STATE_ACTOR
{
- button.SetSelectedImage( Image::New( "IMAGE_PATH_2") );
+ button.SetSelectedImage( ResourceImage::New( "IMAGE_PATH_2") );
DALI_TEST_EQUALS( "IMAGE_PATH_2", button.GetProperty( Button::PROPERTY_SELECTED_STATE_ACTOR ).GetValue( "image" ).GetValue( "filename" ).Get< std::string >(), TEST_LOCATION );
Property::Map map;
// Button::PROPERTY_DISABLED_STATE_ACTOR
{
- button.SetDisabledImage( Image::New( "IMAGE_PATH_3") );
+ button.SetDisabledImage( ResourceImage::New( "IMAGE_PATH_3") );
DALI_TEST_EQUALS( "IMAGE_PATH_3", button.GetProperty( Button::PROPERTY_DISABLED_STATE_ACTOR ).GetValue( "image" ).GetValue( "filename" ).Get< std::string >(), TEST_LOCATION );
Property::Map map;
DALI_TEST_CHECK( !control.GetBackgroundActor() );
DALI_TEST_EQUALS( control.GetBackgroundColor(), Color::TRANSPARENT, TEST_LOCATION );
- Image image = Image::New("TestImage");
+ Image image = ResourceImage::New("TestImage");
control.SetBackground( image );
DALI_TEST_CHECK( control.GetBackgroundActor() );
DALI_TEST_EQUALS( control.GetBackgroundColor(), Color::WHITE, TEST_LOCATION );
//check the size of the off screen rendered image
Wait( application, OFFSCREEN_RENDER_DURATION );
- ImageAttributes attributes( tile.GetImage().GetAttributes() );
- DALI_TEST_EQUALS( static_cast<float>(attributes.GetWidth()), VIEW_AREA_SIZE.x, TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<float>(attributes.GetHeight()), VIEW_AREA_SIZE.y, TEST_LOCATION );
+ DALI_TEST_EQUALS( tile.GetImage().GetWidth(), VIEW_AREA_SIZE.x, TEST_LOCATION );
+ DALI_TEST_EQUALS( tile.GetImage().GetHeight(), VIEW_AREA_SIZE.y, TEST_LOCATION );
END_TEST;
}
//check the size of the off screen rendered image
Wait( application, OFFSCREEN_RENDER_DURATION );
- ImageAttributes attributes( tile.GetImage().GetAttributes() );
- DALI_TEST_EQUALS( static_cast<float>(attributes.GetWidth()), VIEW_AREA_SIZE.x, TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<float>(attributes.GetHeight()), VIEW_AREA_SIZE.y, TEST_LOCATION );
+ DALI_TEST_EQUALS( tile.GetImage().GetWidth(), VIEW_AREA_SIZE.x, TEST_LOCATION );
+ DALI_TEST_EQUALS( tile.GetImage().GetHeight(), VIEW_AREA_SIZE.y, TEST_LOCATION );
END_TEST;
}
tet_infoline(" UtcDaliCubeTransitionWaveEffectStartTransition ");
application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
- ImageActor imageActor = CreateSolidColorImageActor(application, Color::BLUE,30,30);
+ ImageActor imageActor = ImageActor::New(ResourceImage::New("Image.jpg"));
CubeTransitionEffect waveEffect = CubeTransitionWaveEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
waveEffect.SetTransitionDuration( TRANSITION_DURATION );
tet_infoline(" UtcDaliCubeTransitionCrossEffectStartTransition ");
application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
- ImageActor imageActor = CreateSolidColorImageActor(application, Color::BLUE,30,30);
+ ImageActor imageActor = ImageActor::New(ResourceImage::New("Image.jpg"));
CubeTransitionEffect crossEffect = CubeTransitionCrossEffect::New( NUM_ROWS, NUM_COLUMNS, VIEW_AREA_SIZE );
crossEffect.SetTransitionDuration( TRANSITION_DURATION );
Toolkit::DisplacementEffect effect = Toolkit::DisplacementEffect::New(Toolkit::DisplacementEffect::DISPLACED);
DALI_TEST_CHECK( effect );
- ImageActor actor = ImageActor::New( Image::New(TEST_IMAGE_FILE_NAME) );
+ ImageActor actor = ImageActor::New( ResourceImage::New(TEST_IMAGE_FILE_NAME) );
actor.SetSize( 100.0f, 100.0f );
actor.SetShaderEffect( effect );
Stage::GetCurrent().Add( actor );
Toolkit::DisplacementEffect effect2 = Toolkit::DisplacementEffect::New(Toolkit::DisplacementEffect::FIXED);
DALI_TEST_CHECK( effect );
- ImageActor actor2 = ImageActor::New( Image::New(TEST_IMAGE_FILE_NAME) );
+ ImageActor actor2 = ImageActor::New( ResourceImage::New(TEST_IMAGE_FILE_NAME) );
actor2.SetSize( 100.0f, 100.0f );
actor2.SetShaderEffect( effect2 );
Stage::GetCurrent().Add( actor2 );
view.Activate();
FrameBufferImage renderTarget = FrameBufferImage::New( 480.0f, 800.0f, Pixel::RGB888 );
- view.SetUserImageAndOutputRenderTarget(Image::New(TEST_IMAGE_FILE_NAME), renderTarget);
+ view.SetUserImageAndOutputRenderTarget(ResourceImage::New(TEST_IMAGE_FILE_NAME), renderTarget);
DALI_TEST_CHECK( view.GetBlurredRenderTarget() == renderTarget );
END_TEST;
}
virtual Actor NewItem(unsigned int itemId)
{
// Create an image actor for this item
- Image image = Image::New( TEST_IMAGE_FILE_NAME );
+ Image image = ResourceImage::New( TEST_IMAGE_FILE_NAME );
Actor actor = ImageActor::New(image);
return actor;
virtual Actor NewItem(unsigned int itemId)
{
// Create an image actor for this item
- Image image = Image::New( TEST_IMAGE_FILE_NAME );
+ Image image = ResourceImage::New( TEST_IMAGE_FILE_NAME );
Actor actor = ImageActor::New(image);
return actor;
// [0]: testing PageTurnStartedSignal; [1]: testing PageTurnFinishedSignal
// [2]: testing PagePanStartedSignal; [3]: testing PagePanFinishedSignal
- bool signalVerified[4];
+ bool signalVerified[4] = {false, false, false, false};
PageTurnView currentView;
unsigned int pageIndex;
bool isTurningForwards;
// Create render targets
// create off screen buffer of new size to render our child actors to
- mRenderTargetForRenderingChildren = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::Unused );
- mBloomExtractTarget = FrameBufferImage::New( mDownsampledWidth, mDownsampledHeight, mPixelFormat, Dali::Image::Unused );
- mOutputRenderTarget = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::Unused );
+ mRenderTargetForRenderingChildren = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::UNUSED );
+ mBloomExtractTarget = FrameBufferImage::New( mDownsampledWidth, mDownsampledHeight, mPixelFormat, Dali::Image::UNUSED );
+ mOutputRenderTarget = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::UNUSED);
//////////////////////////////////////////////////////
#include <cmath>
#include <dali/public-api/animation/animation.h>
#include <dali/public-api/render-tasks/render-task-list.h>
+#include <dali/public-api/images/resource-image.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/shader-effects/bubble-effect/color-adjuster.h>
mBubbleRoot.SetSize(mMovementArea);
// Prepare the frame buffer to store the color adjusted background image
- mEffectImage = FrameBufferImage::New( mMovementArea.width/4.f, mMovementArea.height/4.f, Pixel::RGBA8888, Dali::Image::Unused );
+ mEffectImage = FrameBufferImage::New( mMovementArea.width/4.f, mMovementArea.height/4.f, Pixel::RGBA8888, Dali::Image::UNUSED );
// Generate the material object, which is used by all meshActors
GenMaterial();
mMeshActor[i] = MeshActor::New( mMesh[i] );
mMeshActor[i].SetAffectedByLighting( false );
mMeshActor[i].SetParentOrigin(ParentOrigin::TOP_LEFT);
- mEffect[i] = BubbleEffect::New( mNumBubblePerShader, mShapeImage.GetFilename() );
+ mEffect[i] = BubbleEffect::New( mNumBubblePerShader );
mEffect[i].SetEffectImage( mEffectImage );
mEffect[i].SetMovementArea( mMovementArea );
mMeshActor[i].SetShaderEffect( mEffect[i] );
mMeshActorForNoise = MeshActor::New( Mesh::New(meshDataForNoise) );
mMeshActorForNoise.SetAffectedByLighting( false );
mMeshActorForNoise.SetParentOrigin(ParentOrigin::TOP_LEFT);
- mEffectForNoise = BubbleEffect::New( mNumBubblePerShader, mShapeImage.GetFilename() );
+ mEffectForNoise = BubbleEffect::New( mNumBubblePerShader );
mEffectForNoise.SetMovementArea( mMovementArea );
mEffectForNoise.SetEffectImage( mEffectImage );
mMeshActorForNoise.SetShaderEffect( mEffectForNoise );
void BubbleEmitter::SetShapeImage( Image shapeImage )
{
mCustomMaterial.SetDiffuseTexture( shapeImage );
-
- //Get pixel width of the shape
- float width = Image::GetImageSize(shapeImage.GetFilename()).width;
-
- for(unsigned int i=0; i < mNumShader; i++ )
- {
- mEffect[i].SetShapeImageWidth(width);
- }
- mEffectForNoise.SetShapeImageWidth(width);
}
void BubbleEmitter::SetBubbleScale( float scale )
// EXTERNAL INCLUDES
#include <dali/public-api/object/type-registry.h>
+#include <dali/public-api/images/resource-image.h>
using namespace Dali;
using namespace Dali::Toolkit::Internal;
RadioButton::RadioButton()
{
- mUnselectedImage = Dali::Image::New( UNSELECTED_BUTTON_IMAGE_DIR );
- mSelectedImage = Dali::Image::New( SELECTED_BUTTON_IMAGE_DIR );
+ mUnselectedImage = Dali::ResourceImage::New( UNSELECTED_BUTTON_IMAGE_DIR );
+ mSelectedImage = Dali::ResourceImage::New( SELECTED_BUTTON_IMAGE_DIR );
mRadioIcon = Dali::ImageActor::New( mUnselectedImage );
SetupCameras();
- mImageForChildren = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::Unused );
+ mImageForChildren = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::UNUSED );
mActorForChildren.SetImage(mImageForChildren);
- mImagePostFilter = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::Unused );
+ mImagePostFilter = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::UNUSED );
mActorPostFilter.SetImage(mImagePostFilter);
SetupFilters();
mRenderFullSizeCamera.SetPosition(0.0f, 0.0f, mTargetSize.height * cameraPosConstraintScale);
// create offscreen buffer of new size to render our child actors to
- mRenderTargetForRenderingChildren = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::Unused );
+ mRenderTargetForRenderingChildren = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::UNUSED );
// Set ImageActor for performing a horizontal blur on the texture
mImageActorHorizBlur.SetImage( mRenderTargetForRenderingChildren );
// Create offscreen buffer for vert blur pass
- mRenderTarget1 = FrameBufferImage::New( mDownsampledWidth, mDownsampledHeight, mPixelFormat, Dali::Image::Unused );
+ mRenderTarget1 = FrameBufferImage::New( mDownsampledWidth, mDownsampledHeight, mPixelFormat, Dali::Image::UNUSED );
// use the completed blur in the first buffer and composite with the original child actors render
mImageActorComposite.SetImage( mRenderTarget1 );
}
// Create offscreen buffer for horiz blur pass
- mRenderTarget2 = FrameBufferImage::New( mDownsampledWidth, mDownsampledHeight, mPixelFormat, Dali::Image::Unused );
+ mRenderTarget2 = FrameBufferImage::New( mDownsampledWidth, mDownsampledHeight, mPixelFormat, Dali::Image::UNUSED );
// size needs to match render target
mImageActorHorizBlur.SetSize(mDownsampledWidth, mDownsampledHeight);
#include <dali/public-api/animation/constraints.h>
#include <dali/public-api/common/stage.h>
#include <dali/public-api/render-tasks/render-task-list.h>
+#include <dali/public-api/images/resource-image.h>
using namespace Dali;
{
Actor self(Self());
- Image image = Image::New( DEFAULT_FRAME_IMAGE_PATH );
+ Image image = ResourceImage::New( DEFAULT_FRAME_IMAGE_PATH );
mFrame = ImageActor::New( image );
mFrame.SetDrawMode(DrawMode::OVERLAY);
mFrame.SetStyle( ImageActor::STYLE_NINE_PATCH );
Self().Add( mPageSourceActor[i] );
mPageSourceActor[i].SetSensitive( false );
- mRenderedPage[i] = FrameBufferImage::New( mControlSize.width, mControlSize.height, Pixel::RGB8888, Image::Unused );
+ mRenderedPage[i] = FrameBufferImage::New( mControlSize.width, mControlSize.height, Pixel::RGB8888, Image::UNUSED );
mOffscreenTask[i] = taskList.CreateTask();
mOffscreenTask[i].SetRefreshRate( RenderTask::REFRESH_ONCE );
mOffscreenTask[i].SetCameraActor(mCameraActor);
#include <dali/public-api/events/touch-event.h>
#include <dali/public-api/object/type-registry.h>
#include <dali/integration-api/debug.h>
+#include <dali/public-api/images/resource-image.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/buttons/button.h>
if(image != "")
{
- Image tail = Image::New( image );
+ Image tail = ResourceImage::New( image );
mTailImage = ImageActor::New(tail);
const Vector3 anchorPoint = AnchorPoint::FRONT_BOTTOM_RIGHT - position;
void Popup::SetDefaultBackgroundImage()
{
- Image bg = Image::New( mPopupStyle->backgroundImage );
+ Image bg = ResourceImage::New( mPopupStyle->backgroundImage );
ImageActor bgImage = ImageActor::New( bg );
bgImage.SetStyle( ImageActor::STYLE_NINE_PATCH );
bgImage.SetNinePatchBorder( mPopupStyle->backgroundScale9Border );
- Image buttonBg = Image::New( mPopupStyle->buttonAreaImage );
+ Image buttonBg = ResourceImage::New( mPopupStyle->buttonAreaImage );
ImageActor buttonBgImage = ImageActor::New( buttonBg );
buttonBgImage.SetStyle( ImageActor::STYLE_NINE_PATCH );
buttonBgImage.SetNinePatchBorder( mPopupStyle->buttonArea9PatchBorder );
// EXTERNAL INCLUDES
#include <dali/public-api/animation/constraints.h>
#include <dali/public-api/object/type-registry.h>
+#include <dali/public-api/images/resource-image.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.h>
{
Actor self = Self();
- Image indicatorImage = Image::New( DEFAULT_INDICATOR_IMAGE_PATH );
+ Image indicatorImage = ResourceImage::New( DEFAULT_INDICATOR_IMAGE_PATH );
mIndicator = ImageActor::New( indicatorImage );
mIndicator.SetNinePatchBorder( DEFAULT_INDICATOR_NINE_PATCH_BORDER );
mIndicator.SetStyle( ImageActor::STYLE_NINE_PATCH );
// EXTERNAL INCLUDES
#include <dali/public-api/object/type-registry.h>
+#include <dali/public-api/images/resource-image.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/enums.h>
mAxisMask(vertical ? Vector3::YAXIS : Vector3::XAXIS),
mDragMode(false)
{
- Image sliderImage = Image::New( BAR_TAB_IMAGE_PATH );
+ Image sliderImage = ResourceImage::New( BAR_TAB_IMAGE_PATH );
mSlider = ImageActor::New( sliderImage );
mSlider.SetParentOrigin( ParentOrigin::TOP_LEFT );
// EXTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control-impl.h>
+#include <dali/public-api/images/resource-image.h>
#include <sstream>
{
if( mBacking && imageName != String::EMPTY )
{
- Image image = Image::New( imageName );
+ Image image = ResourceImage::New( imageName );
mBacking.SetImage( image );
}
}
{
if( mBacking )
{
- return mBacking.GetImage().GetFilename();
+ return ResourceImage::DownCast( mBacking.GetImage() ).GetUrl();
}
return std::string( "" );
{
if( mProgress && imageName != String::EMPTY )
{
- Image image = Image::New( imageName );
+ Image image = ResourceImage::New( imageName );
mProgress.SetImage( image );
}
}
{
if( mProgress )
{
- return mProgress.GetImage().GetFilename();
+ return ResourceImage::DownCast( mProgress.GetImage()).GetUrl();
}
return std::string( "" );
{
if( mPopup && imageName != String::EMPTY )
{
- Image image = Image::New( imageName );
+ Image image = ResourceImage::New( imageName );
mPopup.SetImage( image );
}
}
{
if( mPopupArrow && imageName != String::EMPTY )
{
- Image image = Image::New( imageName );
+ Image image = ResourceImage::New( imageName );
mPopupArrow.SetImage( image );
}
}
{
if( mHandle && imageName != String::EMPTY )
{
- Image image = Image::New( imageName );
+ Image image = ResourceImage::New( imageName );
mHandle.SetImage( image );
}
}
{
if( mHandle )
{
- return mHandle.GetImage().GetFilename();
+ return ResourceImage::DownCast( mHandle.GetImage() ).GetUrl();
}
return std::string( "" );
{
float exponent = static_cast<float>(i+1);
mBlurredImage[i] = FrameBufferImage::New( mTargetSize.width/std::pow(2.f,exponent) , mTargetSize.height/std::pow(2.f,exponent),
- GAUSSIAN_BLUR_RENDER_TARGET_PIXEL_FORMAT, Dali::Image::Never );
+ GAUSSIAN_BLUR_RENDER_TARGET_PIXEL_FORMAT, Dali::Image::NEVER );
}
}
}
#include <dali/public-api/events/pan-gesture.h>
#include <dali/public-api/object/property-notification.h>
#include <dali/integration-api/debug.h>
+#include <dali/public-api/images/resource-image.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/controls/text-input/text-input-handles-impl.h>
}
else
{
- cursor = ImageActor::New( Image::New( DEFAULT_CURSOR ) );
+ cursor = ImageActor::New( ResourceImage::New( DEFAULT_CURSOR ) );
}
cursor.SetStyle(ImageActor::STYLE_NINE_PATCH);
void Decorator::CreateCursors( Actor targetParent )
{
- Image mCursorImage = Image::New( DEFAULT_CURSOR );
+ Image mCursorImage = ResourceImage::New( DEFAULT_CURSOR );
mCursor = CreateCursor (mCursorImage, DEFAULT_CURSOR_IMAGE_9_BORDER , "mainCursor");
mCursorRTL = CreateCursor ( mCursorImage, DEFAULT_CURSOR_IMAGE_9_BORDER, "rtlCursor");
targetParent.Add( mCursor );
#include <algorithm>
#include <dali/public-api/animation/constraints.h>
#include <dali/integration-api/debug.h>
+#include <dali/public-api/images/resource-image.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/controls/text-input/textview-character-positions-impl.h>
{
DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextInputHandles: CreateSelectionHandles\n" );
- mSelectionHandleOneImage = Image::New( DEFAULT_SELECTION_HANDLE_ONE );
- mSelectionHandleOneImagePressed = Image::New( DEFAULT_SELECTION_HANDLE_ONE_PRESSED );
+ mSelectionHandleOneImage = ResourceImage::New( DEFAULT_SELECTION_HANDLE_ONE );
+ mSelectionHandleOneImagePressed = ResourceImage::New( DEFAULT_SELECTION_HANDLE_ONE_PRESSED );
mSelectionHandleOne = CreateHandle( AnchorPoint::TOP_RIGHT, mSelectionHandleOneImage, "SelectionHandleOne" );
mIsSelectionHandleOneFlipped = false;
// mTapDetector.Attach( mHandleOneGrabArea );
- mSelectionHandleTwoImage = Image::New( DEFAULT_SELECTION_HANDLE_TWO );
- mSelectionHandleTwoImagePressed = Image::New( DEFAULT_SELECTION_HANDLE_TWO_PRESSED );
+ mSelectionHandleTwoImage = ResourceImage::New( DEFAULT_SELECTION_HANDLE_TWO );
+ mSelectionHandleTwoImagePressed = ResourceImage::New( DEFAULT_SELECTION_HANDLE_TWO_PRESSED );
mSelectionHandleTwo = CreateHandle( AnchorPoint::TOP_LEFT, mSelectionHandleTwoImage, "SelectionHandleTwo" );
mIsSelectionHandleTwoFlipped = false;
{
if ( !mGrabHandleImage )
{
- mGrabHandleImage = Image::New( DEFAULT_GRAB_HANDLE );
+ mGrabHandleImage = ResourceImage::New( DEFAULT_GRAB_HANDLE );
}
mGrabHandle = CreateHandle( AnchorPoint::TOP_CENTER, mGrabHandleImage, "GrabHandle" );
#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/object/property-notification.h>
#include <dali/integration-api/debug.h>
+#include <dali/public-api/images/resource-image.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/controls/text-view/text-processor.h>
{
if ( !image )
{
- mGrabHandleImage = Image::New(DEFAULT_GRAB_HANDLE);
+ mGrabHandleImage = ResourceImage::New(DEFAULT_GRAB_HANDLE);
}
else
{
if ( !mSelectionHandleOne )
{
// create normal and pressed images
- mSelectionHandleOneImage = Image::New( DEFAULT_SELECTION_HANDLE_ONE );
- mSelectionHandleOneImagePressed = Image::New( DEFAULT_SELECTION_HANDLE_ONE_PRESSED );
+ mSelectionHandleOneImage = ResourceImage::New( DEFAULT_SELECTION_HANDLE_ONE );
+ mSelectionHandleOneImagePressed = ResourceImage::New( DEFAULT_SELECTION_HANDLE_ONE_PRESSED );
mSelectionHandleOne = ImageActor::New( mSelectionHandleOneImage );
mSelectionHandleOne.SetName("SelectionHandleOne");
if ( !mSelectionHandleTwo )
{
// create normal and pressed images
- mSelectionHandleTwoImage = Image::New( DEFAULT_SELECTION_HANDLE_TWO );
- mSelectionHandleTwoImagePressed = Image::New( DEFAULT_SELECTION_HANDLE_TWO_PRESSED );
+ mSelectionHandleTwoImage = ResourceImage::New( DEFAULT_SELECTION_HANDLE_TWO );
+ mSelectionHandleTwoImagePressed = ResourceImage::New( DEFAULT_SELECTION_HANDLE_TWO_PRESSED );
mSelectionHandleTwo = ImageActor::New( mSelectionHandleTwoImage );
mSelectionHandleTwo.SetName("SelectionHandleTwo");
#include <libintl.h>
#include <dali/public-api/animation/constraints.h>
#include <dali/integration-api/debug.h>
+#include <dali/public-api/images/resource-image.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/controls/text-input/text-input-popup-impl.h>
// Create background-panel if not already created (required if we have at least one option)
if ( !mBackground )
{
- Image bgImg = Image::New( POPUP_BACKGROUND );
+ Image bgImg = ResourceImage::New( POPUP_BACKGROUND );
mBackground = ImageActor::New( bgImg );
mBackground.SetAnchorPoint( AnchorPoint::CENTER );
mBackground.SetParentOrigin( ParentOrigin::CENTER );
mBackground.SetName( "text-input-popup-background" );
mBackground.SetColor( mBackgroundColor );
- Image bgEffectImg = Image::New( POPUP_BACKGROUND_EFFECT );
+ Image bgEffectImg = ResourceImage::New( POPUP_BACKGROUND_EFFECT );
mBackgroundEffect = ImageActor::New( bgEffectImg );
mBackgroundEffect.SetAnchorPoint( AnchorPoint::CENTER );
mBackgroundEffect.SetParentOrigin( ParentOrigin::CENTER );
mBackgroundEffect.SetZ( 1.0f );
mBackground.Add( mBackgroundEffect );
- Image bgLine = Image::New( POPUP_BACKGROUND_LINE );
+ Image bgLine = ResourceImage::New( POPUP_BACKGROUND_LINE );
mBackgroundLine = ImageActor::New( bgLine );
mBackgroundLine.SetAnchorPoint( AnchorPoint::CENTER);
mBackgroundLine.SetParentOrigin( ParentOrigin::CENTER );
{
if ( !mTail )
{
- Image tail = Image::New( POPUP_TAIL_BOTTOM );
+ Image tail = ResourceImage::New( POPUP_TAIL_BOTTOM );
mTail = ImageActor::New( tail );
mTail.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
mTail.SetAnchorPoint( AnchorPoint::TOP_CENTER );
mTail.SetPosition( 0.0f, POPUP_TAIL_Y_OFFSET - POPUP_BORDER.w, 1.2f );
mTail.SetColor( mBackgroundColor );
- Image tailEffect = Image::New( POPUP_TAIL_BOTTOM_EFFECT );
+ Image tailEffect = ResourceImage::New( POPUP_TAIL_BOTTOM_EFFECT );
mTailEffect = ImageActor::New( tailEffect );
mTailEffect.SetParentOrigin( ParentOrigin::CENTER );
mTailEffect.SetAnchorPoint( AnchorPoint::CENTER );
mTailEffect.SetZ( 0.1f );
mTail.Add( mTailEffect );
- Image tailLine = Image::New( POPUP_TAIL_BOTTOM_LINE );
+ Image tailLine = ResourceImage::New( POPUP_TAIL_BOTTOM_LINE );
mTailLine = ImageActor::New( tailLine );
mTailLine.SetParentOrigin( ParentOrigin::CENTER );
mTailLine.SetAnchorPoint( AnchorPoint::CENTER );
{
case ButtonsCut:
{
- Image cutIcon = Image::New( OPTION_ICON_CUT );
+ Image cutIcon = ResourceImage::New( OPTION_ICON_CUT );
currentButton = CreateRequiredButton( ButtonsCut, mCutOptionPriority, OPTION_CUT, GET_LOCALE_TEXT("IDS_COM_BODY_CUT"), cutIcon, false );
break;
}
case ButtonsCopy:
{
- Image copyIcon = Image::New( OPTION_ICON_COPY );
+ Image copyIcon = ResourceImage::New( OPTION_ICON_COPY );
currentButton = CreateRequiredButton( ButtonsCopy, mCopyOptionPriority, OPTION_COPY, GET_LOCALE_TEXT("IDS_COM_BODY_COPY"), copyIcon, false );
break;
}
case ButtonsPaste:
{
- Image pasteIcon = Image::New( OPTION_ICON_PASTE );
+ Image pasteIcon = ResourceImage::New( OPTION_ICON_PASTE );
currentButton = CreateRequiredButton( ButtonsPaste, mPasteOptionPriority, OPTION_PASTE, GET_LOCALE_TEXT("IDS_COM_BODY_PASTE"), pasteIcon, false );
break;
}
case ButtonsSelect:
{
- Image selectIcon = Image::New( OPTION_ICON_SELECT );
+ Image selectIcon = ResourceImage::New( OPTION_ICON_SELECT );
currentButton = CreateRequiredButton( ButtonsSelect, mSelectOptionPriority, OPTION_SELECT_WORD, GET_LOCALE_TEXT("IDS_COM_SK_SELECT"), selectIcon, false );
break;
}
case ButtonsSelectAll:
{
- Image selectAllIcon = Image::New( OPTION_ICON_SELECT_ALL );
+ Image selectAllIcon = ResourceImage::New( OPTION_ICON_SELECT_ALL );
currentButton = CreateRequiredButton( ButtonsSelectAll, mSelectAllOptionPriority, OPTION_SELECT_ALL, GET_LOCALE_TEXT("IDS_COM_BODY_SELECT_ALL"), selectAllIcon, false );
break;
}
case ButtonsClipboard:
{
- Image clipboardIcon = Image::New( OPTION_ICON_CLIPBOARD );
+ Image clipboardIcon = ResourceImage::New( OPTION_ICON_CLIPBOARD );
currentButton = CreateRequiredButton( ButtonsClipboard, mClipboardOptionPriority, OPTION_CLIPBOARD, GET_LOCALE_TEXT("IDS_COM_BODY_CLIPBOARD"), clipboardIcon, false );
break;
}
if ( yAxisFlip )
{
- Image tail = Image::New( POPUP_TAIL_TOP );
- Image tailEffect = Image::New( POPUP_TAIL_TOP_EFFECT );
- Image tailLine = Image::New( POPUP_TAIL_TOP_LINE );
+ Image tail = ResourceImage::New( POPUP_TAIL_TOP );
+ Image tailEffect = ResourceImage::New( POPUP_TAIL_TOP_EFFECT );
+ Image tailLine = ResourceImage::New( POPUP_TAIL_TOP_LINE );
mTail.SetImage( tail );
mTailEffect.SetImage( tailEffect );
mActorForInput.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) );
// create internal offscreen for result of horizontal pass
- mImageForHorz = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Image::Unused );
+ mImageForHorz = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Image::UNUSED );
// create an actor to render mImageForHorz for vertical blur pass
mActorForHorz = ImageActor::New( mImageForHorz );
mActorForHorz.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) );
// create internal offscreen for result of the two pass blurred image
- mBlurredImage = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Image::Unused );
+ mBlurredImage = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Image::UNUSED);
// create an actor to blend the blurred image and the input image with the given blur strength
mActorForBlending = ImageActor::New( mBlurredImage );
mCameraActor = CameraActor::New();
mCameraActor.SetParentOrigin(ParentOrigin::CENTER);
- mImageForEmboss1 = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Image::Unused );
- mImageForEmboss2 = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Image::Unused );
+ mImageForEmboss1 = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Image::UNUSED );
+ mImageForEmboss2 = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Image::UNUSED );
// create actor to render input with applied emboss effect
mActorForInput1 = ImageActor::New( mInputImage );
mActorForInput.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) );
// create internal offscreen for result of horizontal pass
- mImageForHorz = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Image::Unused );
+ mImageForHorz = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Image::UNUSED );
// create an actor to render mImageForHorz for vertical blur pass
mActorForHorz = ImageActor::New( mImageForHorz );
#include <dali/public-api/adaptor-framework/tts-player.h>
#include <dali/public-api/animation/constraints.h>
#include <dali/public-api/events/hit-test-algorithm.h>
+#include <dali/public-api/images/resource-image.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
void FocusManager::CreateDefaultFocusIndicatorActor()
{
// Create a focus indicator actor shared by all the focusable actors
- Image borderImage = Image::New(FOCUS_BORDER_IMAGE_PATH);
+ Image borderImage = ResourceImage::New(FOCUS_BORDER_IMAGE_PATH);
ImageActor focusIndicator = ImageActor::New(borderImage);
focusIndicator.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
#include <dali/public-api/common/stage.h>
#include <dali/public-api/events/key-event.h>
#include <dali/public-api/object/type-registry.h>
+#include <dali/public-api/images/resource-image.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
void KeyboardFocusManager::CreateDefaultFocusIndicatorActor()
{
// Create a focus indicator actor shared by all the keyboard focusable actors
- Image borderImage = Image::New(FOCUS_BORDER_IMAGE_PATH);
+ Image borderImage = ResourceImage::New(FOCUS_BORDER_IMAGE_PATH);
ImageActor focusIndicator = ImageActor::New(borderImage);
focusIndicator.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
void CubeTransitionEffect::SetImage( ImageActor imageActor )
{
mCurrentImage = imageActor;
- mIsImageLoading = true;
Image image = imageActor.GetImage();
+ ResourceImage resourceImage = ResourceImage::DownCast( image );
mBufferIndex = mBufferIndex^1;
//must make sure the image is already loaded before using its attributes
- if( image.GetLoadingState() == ResourceLoadingSucceeded )
+ if( resourceImage && resourceImage.GetLoadingState() != ResourceLoadingSucceeded )
{
- OnImageLoaded( image );
+ mIsImageLoading = true;
+ resourceImage.LoadingFinishedSignal().Connect( this, &CubeTransitionEffect::OnImageLoaded );
}
else
{
- image.LoadingFinishedSignal().Connect( this, &CubeTransitionEffect::OnImageLoaded );
+ mIsImageLoading = false;
+ PrepareTiles( image );
}
}
}
}
-void CubeTransitionEffect::OnImageLoaded(Image image)
+void CubeTransitionEffect::OnImageLoaded(ResourceImage image)
+{
+ mIsImageLoading = false;
+ PrepareTiles( image );
+}
+
+/**
+ * Set sub-image to each tile.
+ * @param[in] image The image content of the imageActor for transition
+ */
+void CubeTransitionEffect::PrepareTiles( Image image )
{
// Fit the image to view area, while keeping the aspect; FitKeepAspectRatio(imageSize, viewAreaSize)
- ImageAttributes attributes( image.GetAttributes() );
- float scale = std::min( mViewAreaSize.width / attributes.GetWidth(), mViewAreaSize.height / attributes.GetHeight() );
- Vector2 imageSize(attributes.GetWidth()*scale, attributes.GetHeight()*scale);
+ float scale = std::min( mViewAreaSize.width / image.GetWidth(), mViewAreaSize.height / image.GetHeight() );
+ Vector2 imageSize(image.GetWidth()*scale, image.GetHeight()*scale);
mFullImageCreator.SetEffectImage(image);
mFullImageCreator.SetRegionSize(mViewAreaSize, imageSize);
mTiles[mContainerIndex][idx].SetPixelArea( pixelArea );
}
}
- mIsImageLoading = false;
}
+
void CubeTransitionEffect::OnTransitionFinished(Animation& source)
{
mRoot.SetVisible(false);
#include <dali/public-api/object/base-object.h>
#include <dali/public-api/render-tasks/render-task.h>
#include <dali/public-api/shader-effects/shader-effect.h>
+#include <dali/public-api/images/resource-image.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/transition-effects/cube-transition-effect.h>
* Set image and pixelArea to tiles
* @param[in] image The image content of the imageActor for transition
*/
- void OnImageLoaded(Image image);
+ void OnImageLoaded(ResourceImage image);
+
+ /**
+ * Set sub-image to each tile.
+ * @param[in] image The image content of the imageActor for transition
+ */
+ void PrepareTiles( Image image );
/**
* Callback function of transition animation finished
// EXTERNAL INCLUDES
#include <dali/public-api/actors/image-actor.h>
+#include <dali/public-api/images/resource-image.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/alignment/alignment.h>
Alignment CreateAlignedImage( const std::string& imagePath )
{
- Image image = Image::New( imagePath );
+ Image image = ResourceImage::New( imagePath );
return CreateAlignedImage( ImageActor::New( image ) );
}
// EXTERNAL INCLUDES
#include <dali/public-api/actors/image-actor.h>
+#include <dali/public-api/images/resource-image.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/alignment/alignment.h>
Alignment CreateAlignedImage( const std::string& imagePath )
{
- Image image = Image::New( imagePath );
+ Image image = ResourceImage::New( imagePath );
return CreateAlignedImage( ImageActor::New( image ) );
}
{
}
-BubbleEffect BubbleEffect::New( unsigned int numberOfBubble, const std::string& shapeImagePath)
+BubbleEffect BubbleEffect::New( unsigned int numberOfBubble)
{
std::ostringstream vertexShaderStringStream;
vertexShaderStringStream << "#define NUMBER_OF_BUBBLE "<< numberOfBubble << "\n";
" precision mediump float;\n"
// the gravity applied to the y direction
" uniform float uGravity; \n"
- // Width of the texture in pixels
- " uniform float uShapeWidth; \n"
// xy: the emit position of the bubble; zw: the destinationof the bubble.
// The bubble is moving from (xy) to (zw plus the y drop influenced by gravity).
" uniform vec4 uStartAndEndPos[NUMBER_OF_BUBBLE];\n"
" gl_Position = uMvpMatrix * position;\n"
"\n"
// Add multiple bubble shapes in the effect
- " mediump float texCoordX = floor( mod(startAndEnd.z, uShapeWidth) );\n "
- " mediump float texCoordY = floor( mod(startAndEnd.w, uShapeWidth) );\n "
- " vTexCoord = vec2( (texCoordX + aTexCoord.x)/ uShapeWidth,(texCoordY + aTexCoord.y)/ uShapeWidth );\n"
+ " vTexCoord = aTexCoord;\n"
" vPercentage = percentage;\n"
// Use the emit position color for the bubble
" vEffectTexCoord = startAndEnd.xy * uInvertedMovementArea;\n"
handle.SetUniform( "uMagnification", 1.f );
handle.SetUniform( "uDynamicScale", 1.f );
- //Get pixel width of the shape
- float width = Image::GetImageSize(shapeImagePath).width;
- handle.SetUniform( "uShapeWidth", (width/EACH_WIDTH_PER_SHAPE) );
-
Vector4 zeroVector;
for( unsigned int i=0; i<numberOfBubble; i++ )
{
SetUniform( "uGravity", gravity );
}
-void BubbleEffect::SetShapeImageWidth( float imageWidth )
-{
- SetUniform( "uShapeWidth", (imageWidth/EACH_WIDTH_PER_SHAPE) );
-}
-
void BubbleEffect::SetDynamicScale( float scale )
{
SetUniform( "uDynamicScale", scale );
* Ideally use one group of uniform to control one bubble.
* If the num of patches in the MeshActor is more than groups of uniforms,
* the uniform values will be shared by multiple bubbles. Allow up to 9 times.
- * @param shapeImagePath File path of the image that will be used as a texture for each bubble.
* @return A handle to a newly allocated Dali resource.
*/
- static BubbleEffect New( unsigned int numberOfBubble, const std::string& shapeImagePath);
+ static BubbleEffect New( unsigned int numberOfBubble);
/**
* Set the bubble movement area for the BubbleEffect
*/
void SetGravity( float gravity );
- /*
- * Set the width of shape image
- * If one image has multiple shape, bubble effect will parse one shape from the image randomly.
- * @param[in] imageWidth width of shape image
- */
- void SetShapeImageWidth( float imageWidth );
-
/**
* Set the scale factor applied to the bubbles
* @param[in] scale The scale factor applied on all bubbles.
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
+#include <dali/public-api/images/resource-image.h>
namespace Dali
{
GeometryType( GEOMETRY_TYPE_IMAGE ),
ShaderEffect::GeometryHints( ShaderEffect::HINT_BLENDING ) );
- maskEffect.SetEffectImage( Image::New( maskImage ) );
+ maskEffect.SetEffectImage( ResourceImage::New( maskImage ) );
maskEffect.SetUniform( "uImageSize", Vector2(0,0) /*Constrained to actor size*/ );
maskEffect.ApplyConstraint( Constraint::New<Vector2>( maskEffect.GetPropertyIndex("uImageSize"),
void Apply( ImageActor actor, const std::string& maskImage )
{
- Vector2 maskSize = Image::GetImageSize( maskImage );
+ Vector2 maskSize = ResourceImage::GetImageSize( maskImage );
const float leftRight = (maskSize.width - 1.0f) * 0.5f;
const float topBottom = (maskSize.height - 1.0f) * 0.5f;
void Apply( ImageActor actor, const std::string& maskImage, const Vector4& maskBorder )
{
- Vector2 maskSize = Image::GetImageSize( maskImage );
+ Vector2 maskSize = ResourceImage::GetImageSize( maskImage );
DoApply( actor, maskImage, maskSize, maskBorder );
}
projects / platform / core / uifw / dali-toolkit.git / commitdiff