int count = sscanf( mString.c_str(),"%f,%f",&vec2.x,&vec2.y );
if( count != 2 )
{
- DALI_LOG_ERROR("Bad format");
+ DALI_LOG_ERROR("Bad format\n");
}
return vec2;
}
int count = sscanf( mString.c_str(),"%f,%f,%f",&vec3.x,&vec3.y,&vec3.z );
if( count != 3 )
{
- DALI_LOG_ERROR("Bad format");
+ DALI_LOG_ERROR("Bad format\n");
}
return vec3;
}
int count = sscanf( mString.c_str(),"%f,%f,%f,%f", &vec4.x, &vec4.y, &vec4.z, &vec4.w );
if( count != 4 )
{
- DALI_LOG_ERROR("Bad format");
+ DALI_LOG_ERROR("Bad format\n");
}
return vec4;
}
if( ecore_main_fd_handler_active_get( handler, ECORE_FD_ERROR) )
{
CallbackBase::Execute( *impl->mCallback, FileDescriptorMonitor::FD_ERROR);
- DALI_LOG_ERROR("ECORE_FD_ERROR occurred on %d", impl->mFileDescriptor);
+ DALI_LOG_ERROR("ECORE_FD_ERROR occurred on %d\n", impl->mFileDescriptor);
return ECORE_CALLBACK_CANCEL;
}
if( status < 0)
{
- DALI_LOG_ERROR("LibUV FD_ERROR occurred on %d", impl->mFileDescriptor);
+ DALI_LOG_ERROR("LibUV FD_ERROR occurred on %d\n", impl->mFileDescriptor);
CallbackBase::Execute( *impl->mCallback, FileDescriptorMonitor::FD_ERROR );
return;
}
TimerPtr Timer::New( unsigned int milliSec )
{
- DALI_LOG_ERROR(" new timer");
+ DALI_LOG_ERROR(" new timer\n");
TimerPtr timer( new Timer( milliSec ) );
return timer;
}
}
case EGL_BAD_DISPLAY:
{
- DALI_LOG_ERROR( "EGL_BAD_DISPLAY: Invalid EGLDisplay object" );
+ DALI_LOG_ERROR( "EGL_BAD_DISPLAY: Invalid EGLDisplay object\n" );
break;
}
case EGL_BAD_CONTEXT:
{
- DALI_LOG_ERROR( "EGL_BAD_CONTEXT: Invalid EGLContext object" );
+ DALI_LOG_ERROR( "EGL_BAD_CONTEXT: Invalid EGLContext object\n" );
break;
}
case EGL_BAD_PARAMETER:
{
- DALI_LOG_ERROR( "EGL_BAD_PARAMETER: Invalid target parameter or attribute in attrib_list" );
+ DALI_LOG_ERROR( "EGL_BAD_PARAMETER: Invalid target parameter or attribute in attrib_list\n" );
break;
}
case EGL_BAD_MATCH:
{
- DALI_LOG_ERROR( "EGL_BAD_MATCH: attrib_list does not match target" );
+ DALI_LOG_ERROR( "EGL_BAD_MATCH: attrib_list does not match target\n" );
break;
}
case EGL_BAD_ACCESS:
{
- DALI_LOG_ERROR( "EGL_BAD_ACCESS: Previously bound off-screen, or EGLImage sibling error" );
+ DALI_LOG_ERROR( "EGL_BAD_ACCESS: Previously bound off-screen, or EGLImage sibling error\n" );
break;
}
case EGL_BAD_ALLOC:
{
- DALI_LOG_ERROR( "EGL_BAD_ALLOC: Insufficient memory is available" );
+ DALI_LOG_ERROR( "EGL_BAD_ALLOC: Insufficient memory is available\n" );
break;
}
default:
{
case EGL_BAD_DISPLAY:
{
- DALI_LOG_ERROR( "EGL_BAD_DISPLAY: Invalid EGLDisplay object" );
+ DALI_LOG_ERROR( "EGL_BAD_DISPLAY: Invalid EGLDisplay object\n" );
break;
}
case EGL_BAD_PARAMETER:
{
- DALI_LOG_ERROR( "EGL_BAD_PARAMETER: eglImage is not a valid EGLImageKHR object created with respect to EGLDisplay" );
+ DALI_LOG_ERROR( "EGL_BAD_PARAMETER: eglImage is not a valid EGLImageKHR object created with respect to EGLDisplay\n" );
break;
}
case EGL_BAD_ACCESS:
{
- DALI_LOG_ERROR( "EGL_BAD_ACCESS: EGLImage sibling error" );
+ DALI_LOG_ERROR( "EGL_BAD_ACCESS: EGLImage sibling error\n" );
break;
}
default:
if( !mLoggedError )
{
mLoggedError = true;
- DALI_LOG_ERROR("Failed to open /sys/kernel/debug/tracing/trace_marker for writing please check file permissions.");
+ DALI_LOG_ERROR("Failed to open /sys/kernel/debug/tracing/trace_marker for writing please check file permissions.\n");
}
}
mSocketFileDescriptor = socket( addressFamily,type, netProtocol);
if( mSocketFileDescriptor == -1 )
{
- DALI_LOG_ERROR( "Unable to create socket" );
+ DALI_LOG_ERROR( "Unable to create socket\n" );
}
}
else
if( ret == -1 )
{
- DALI_LOG_ERROR("Socket close failed");
+ DALI_LOG_ERROR("Socket close failed\n");
return false;
}
return true;
{
if( ! SocketIsOpen() || mBound )
{
- DALI_LOG_ERROR("Socket is invalid, or already bound");
+ DALI_LOG_ERROR("Socket is invalid, or already bound\n");
return false;
}
struct sockaddr_in serverAddress;
{
if( ! mBound || mListening )
{
- DALI_LOG_ERROR("socket is not bound, or already opened for listening");
+ DALI_LOG_ERROR("socket is not bound, or already opened for listening\n");
return false;
}
int ret = listen( mSocketFileDescriptor, blacklog);
if( ret == -1 )
{
- DALI_LOG_ERROR("Listen failed");
+ DALI_LOG_ERROR("Listen failed\n");
return false;
}
{
if( !mListening )
{
- DALI_LOG_ERROR("socket is not being listened to");
+ DALI_LOG_ERROR("socket is not being listened to\n");
return NULL;
}
int clientFileDescriptor = accept( mSocketFileDescriptor, &clientAddress, &addressLength);
if( clientFileDescriptor == -1 )
{
- DALI_LOG_ERROR("Accept failed");
+ DALI_LOG_ERROR("Accept failed\n");
return NULL;
}
int ret = pipe( mQuitPipe );
if( ret != 0)
{
- DALI_LOG_ERROR("Pipe creation failed");
+ DALI_LOG_ERROR("Pipe creation failed\n");
return false;
}
mQuitPipeCreated = true;
int ret = select( maxFd+1, &readFileDescriptors, NULL, &exceptFileDescriptors, NULL );
if( ret == -1 )
{
- DALI_LOG_ERROR("select failed");
+ DALI_LOG_ERROR("select failed\n");
return ERROR;
}
else if ( FD_ISSET( mQuitPipe[0] , &readFileDescriptors ))
if( mPlugin == NULL )
{
- DALI_LOG_ERROR( "Can't create the VideoPlayerPlugin object" );
+ DALI_LOG_ERROR( "Can't create the VideoPlayerPlugin object\n" );
return;
}
{
if (filename.length() < 5)
{
- DALI_LOG_WARNING("Invalid (short) filename.");
+ DALI_LOG_WARNING("Invalid (short) filename.\n");
}
FileFormat format(INVALID_FORMAT);
}
default:
{
- DALI_LOG_ERROR("Format not supported for image encoding (supported formats are PNG and JPEG)");
+ DALI_LOG_ERROR("Format not supported for image encoding (supported formats are PNG and JPEG)\n");
break;
}
}
const bool encodeResult = EncodeToFormat( pixelBuffer, pixbufEncoded, format, width, height, pixelFormat );
if(!encodeResult)
{
- DALI_LOG_ERROR("Encoding pixels failed");
+ DALI_LOG_ERROR("Encoding pixels failed\n");
return false;
}
return TizenPlatform::ResourceLoader::SaveFile( filename, pixbufEncoded.Begin(), pixbufEncoded.Count() );
if (msgDataSize != (int)sizeof(IpcIndicatorDataAnimation))
{
- DALI_LOG_ERROR("Message data is incorrect");
+ DALI_LOG_ERROR("Message data is incorrect\n");
break;
}
void InputPanelLanguageChangeCallback( void* data, Ecore_IMF_Context* context, int value )
{
- DALI_LOG_INFO( gLogFilter, Debug::General, "VKB InputPanelLanguageChangeCallback" );
+ DALI_LOG_INFO( gLogFilter, Debug::General, "VKB InputPanelLanguageChangeCallback\n" );
// Emit the signal that the language has changed
gKeyboardLanguageChangedSignal.Emit();
if (!eglImpl.InitializeGles(reinterpret_cast<EGLNativeDisplayType>(mDisplay)))
{
- DALI_LOG_ERROR("Failed to initialize GLES.");
+ DALI_LOG_ERROR("Failed to initialize GLES.\n");
return false;
}
}
else
{
- DALI_LOG_ERROR("Failed to get native window handle");
+ DALI_LOG_ERROR("Failed to get native window handle\n");
}
}
}
{
case EGL_BAD_DISPLAY:
{
- DALI_LOG_ERROR("EGL_BAD_DISPLAY : Display is not an EGL display connection");
+ DALI_LOG_ERROR("EGL_BAD_DISPLAY : Display is not an EGL display connection\n");
break;
}
case EGL_NOT_INITIALIZED:
{
- DALI_LOG_ERROR("EGL_NOT_INITIALIZED : Display has not been initialized");
+ DALI_LOG_ERROR("EGL_NOT_INITIALIZED : Display has not been initialized\n");
break;
}
case EGL_BAD_SURFACE:
{
- DALI_LOG_ERROR("EGL_BAD_SURFACE : Draw or read is not an EGL surface");
+ DALI_LOG_ERROR("EGL_BAD_SURFACE : Draw or read is not an EGL surface\n");
break;
}
case EGL_BAD_CONTEXT:
{
- DALI_LOG_ERROR("EGL_BAD_CONTEXT : Context is not an EGL rendering context");
+ DALI_LOG_ERROR("EGL_BAD_CONTEXT : Context is not an EGL rendering context\n");
break;
}
case EGL_BAD_MATCH:
{
- DALI_LOG_ERROR("EGL_BAD_MATCH : Draw or read are not compatible with context, or if context is set to EGL_NO_CONTEXT and draw or read are not set to EGL_NO_SURFACE, or if draw or read are set to EGL_NO_SURFACE and context is not set to EGL_NO_CONTEXT");
+ DALI_LOG_ERROR("EGL_BAD_MATCH : Draw or read are not compatible with context, or if context is set to EGL_NO_CONTEXT and draw or read are not set to EGL_NO_SURFACE, or if draw or read are set to EGL_NO_SURFACE and context is not set to EGL_NO_CONTEXT\n");
break;
}
case EGL_BAD_ACCESS:
{
- DALI_LOG_ERROR("EGL_BAD_ACCESS : Context is current to some other thread");
+ DALI_LOG_ERROR("EGL_BAD_ACCESS : Context is current to some other thread\n");
break;
}
case EGL_BAD_NATIVE_PIXMAP:
{
- DALI_LOG_ERROR("EGL_BAD_NATIVE_PIXMAP : A native pixmap underlying either draw or read is no longer valid.");
+ DALI_LOG_ERROR("EGL_BAD_NATIVE_PIXMAP : A native pixmap underlying either draw or read is no longer valid.\n");
break;
}
case EGL_BAD_NATIVE_WINDOW:
{
- DALI_LOG_ERROR("EGL_BAD_NATIVE_WINDOW : A native window underlying either draw or read is no longer valid.");
+ DALI_LOG_ERROR("EGL_BAD_NATIVE_WINDOW : A native window underlying either draw or read is no longer valid.\n");
break;
}
case EGL_BAD_CURRENT_SURFACE:
{
- DALI_LOG_ERROR("EGL_BAD_CURRENT_SURFACE : The previous context has unflushed commands and the previous surface is no longer valid.");
+ DALI_LOG_ERROR("EGL_BAD_CURRENT_SURFACE : The previous context has unflushed commands and the previous surface is no longer valid.\n");
break;
}
case EGL_BAD_ALLOC:
{
- DALI_LOG_ERROR("EGL_BAD_ALLOC : Allocation of ancillary buffers for draw or read were delayed until eglMakeCurrent is called, and there are not enough resources to allocate them");
+ DALI_LOG_ERROR("EGL_BAD_ALLOC : Allocation of ancillary buffers for draw or read were delayed until eglMakeCurrent is called, and there are not enough resources to allocate them\n");
break;
}
case EGL_CONTEXT_LOST:
{
- DALI_LOG_ERROR("EGL_CONTEXT_LOST : If a power management event has occurred. The application must destroy all contexts and reinitialise OpenGL ES state and objects to continue rendering");
+ DALI_LOG_ERROR("EGL_CONTEXT_LOST : If a power management event has occurred. The application must destroy all contexts and reinitialise OpenGL ES state and objects to continue rendering\n");
break;
}
default:
{
- DALI_LOG_ERROR("Unknown error");
+ DALI_LOG_ERROR("Unknown error\n");
break;
}
}
{
case EGL_BAD_DISPLAY:
{
- DALI_LOG_ERROR("Display is not an EGL display connection");
+ DALI_LOG_ERROR("Display is not an EGL display connection\n");
break;
}
case EGL_BAD_ATTRIBUTE:
{
- DALI_LOG_ERROR("The parameter confirAttribs contains an invalid frame buffer configuration attribute or an attribute value that is unrecognized or out of range");
+ DALI_LOG_ERROR("The parameter confirAttribs contains an invalid frame buffer configuration attribute or an attribute value that is unrecognized or out of range\n");
break;
}
case EGL_NOT_INITIALIZED:
{
- DALI_LOG_ERROR("Display has not been initialized");
+ DALI_LOG_ERROR("Display has not been initialized\n");
break;
}
case EGL_BAD_PARAMETER:
{
- DALI_LOG_ERROR("The parameter numConfig is NULL");
+ DALI_LOG_ERROR("The parameter numConfig is NULL\n");
break;
}
default:
{
- DALI_LOG_ERROR("Unknown error");
+ DALI_LOG_ERROR("Unknown error\n");
}
}
DALI_ASSERT_ALWAYS(false && "eglChooseConfig failed!");
if ( numConfigs != 1 )
{
- DALI_LOG_ERROR("No configurations found.");
+ DALI_LOG_ERROR("No configurations found.\n");
TEST_EGL_ERROR("eglChooseConfig");
}
}
ret = mImpl->AppMain();
if (ret != APP_ERROR_NONE)
{
- DALI_LOG_ERROR("Framework::Run(), ui_app_main() is failed. err = %d", ret);
+ DALI_LOG_ERROR("Framework::Run(), ui_app_main() is failed. err = %d\n", ret);
}
mRunning = false;
}
}
case EGL_BAD_DISPLAY:
{
- DALI_LOG_ERROR( "EGL_BAD_DISPLAY: Invalid EGLDisplay object" );
+ DALI_LOG_ERROR( "EGL_BAD_DISPLAY: Invalid EGLDisplay object\n" );
break;
}
case EGL_BAD_CONTEXT:
{
- DALI_LOG_ERROR( "EGL_BAD_CONTEXT: Invalid EGLContext object" );
+ DALI_LOG_ERROR( "EGL_BAD_CONTEXT: Invalid EGLContext object\n" );
break;
}
case EGL_BAD_PARAMETER:
{
- DALI_LOG_ERROR( "EGL_BAD_PARAMETER: Invalid target parameter or attribute in attrib_list" );
+ DALI_LOG_ERROR( "EGL_BAD_PARAMETER: Invalid target parameter or attribute in attrib_list\n" );
break;
}
case EGL_BAD_MATCH:
{
- DALI_LOG_ERROR( "EGL_BAD_MATCH: attrib_list does not match target" );
+ DALI_LOG_ERROR( "EGL_BAD_MATCH: attrib_list does not match target\n" );
break;
}
case EGL_BAD_ACCESS:
{
- DALI_LOG_ERROR( "EGL_BAD_ACCESS: Previously bound off-screen, or EGLImage sibling error" );
+ DALI_LOG_ERROR( "EGL_BAD_ACCESS: Previously bound off-screen, or EGLImage sibling error\n" );
break;
}
case EGL_BAD_ALLOC:
{
- DALI_LOG_ERROR( "EGL_BAD_ALLOC: Insufficient memory is available" );
+ DALI_LOG_ERROR( "EGL_BAD_ALLOC: Insufficient memory is available\n" );
break;
}
default:
{
case EGL_BAD_DISPLAY:
{
- DALI_LOG_ERROR( "EGL_BAD_DISPLAY: Invalid EGLDisplay object" );
+ DALI_LOG_ERROR( "EGL_BAD_DISPLAY: Invalid EGLDisplay object\n" );
break;
}
case EGL_BAD_PARAMETER:
{
- DALI_LOG_ERROR( "EGL_BAD_PARAMETER: eglImage is not a valid EGLImageKHR object created with respect to EGLDisplay" );
+ DALI_LOG_ERROR( "EGL_BAD_PARAMETER: eglImage is not a valid EGLImageKHR object created with respect to EGLDisplay\n" );
break;
}
case EGL_BAD_ACCESS:
{
- DALI_LOG_ERROR( "EGL_BAD_ACCESS: EGLImage sibling error" );
+ DALI_LOG_ERROR( "EGL_BAD_ACCESS: EGLImage sibling error\n" );
break;
}
default:
}
default:
{
- DALI_LOG_WARNING( "Wrong color depth." );
+ DALI_LOG_WARNING( "Wrong color depth.\n" );
return;
}
}
{
if( tbm_surface_destroy( mTbmsurface ) != TBM_SURFACE_ERROR_NONE )
{
- DALI_LOG_ERROR( "Failed to destroy tbm_surface" );
+ DALI_LOG_ERROR( "Failed to destroy tbm_surface\n" );
}
}
}
if( tbm_surface_map( mTbmsurface, TBM_SURF_OPTION_READ, &surface_info) != TBM_SURFACE_ERROR_NONE )
{
- DALI_LOG_ERROR( "Fail to map tbm_surface" );
+ DALI_LOG_ERROR( "Fail to map tbm_surface\n" );
width = 0;
height = 0;
}
default:
{
- DALI_LOG_WARNING( "Tbm surface has unsupported pixel format." );
+ DALI_LOG_WARNING( "Tbm surface has unsupported pixel format.\n" );
pixbuf.resize( 0 );
width = 0;
if( tbm_surface_unmap( mTbmsurface ) != TBM_SURFACE_ERROR_NONE )
{
- DALI_LOG_ERROR( "Fail to unmap tbm_surface" );
+ DALI_LOG_ERROR( "Fail to unmap tbm_surface\n" );
}
return true;
}
- DALI_LOG_WARNING( "TBM surface does not exist." );
+ DALI_LOG_WARNING( "TBM surface does not exist.\n" );
width = 0;
height = 0;
{
if( tbm_surface_destroy( mTbmsurface ) != TBM_SURFACE_ERROR_NONE )
{
- DALI_LOG_ERROR( "Failed to destroy tbm_surface" );
+ DALI_LOG_ERROR( "Failed to destroy tbm_surface\n" );
}
mTbmsurface = NULL;
}
else
{
- DALI_LOG_ERROR("Invalid sensor type");
+ DALI_LOG_ERROR("Invalid sensor type\n");
return;
}
TtsPlayer::TtsPlayer(Dali::TtsPlayer::Mode mode)
: mStateChangedSignal()
{
- DALI_LOG_ERROR("TTS is not implemented in UBUNTU profile.");
+ DALI_LOG_ERROR("TTS is not implemented in UBUNTU profile.\n");
}
TtsPlayer::~TtsPlayer()
CompositorOutput* output = static_cast< CompositorOutput* >( data );
output->SetMonitorDimensions( physical_width, physical_height );
- DALI_LOG_INFO( gLogFilter, Debug::General, "Monitor width: %d mm, height: %d mm",physical_width, physical_height );
+ DALI_LOG_INFO( gLogFilter, Debug::General, "Monitor width: %d mm, height: %d mm\n",physical_width, physical_height );
}
void OutputModeCallback( void *data,
CompositorOutput* output = static_cast< CompositorOutput* >( data );
output->SetMonitorResolution( width, height );
- DALI_LOG_INFO( gLogFilter, Debug::General, "Monitor refresh rate: %f Hz, resolution: %d x %d", static_cast<float>(refresh)/ 1000.f, width, height );
+ DALI_LOG_INFO( gLogFilter, Debug::General, "Monitor refresh rate: %f Hz, resolution: %d x %d\n", static_cast<float>(refresh)/ 1000.f, width, height );
}
}
gDpiHorizontal = (static_cast<float>( mXresolution) / mMonitorWidth) + 0.5f;
gDpiVertical = (static_cast<float>( mYresolution )/ mMonitorHeight) +0.5f;
- DALI_LOG_INFO( gLogFilter, Debug::General, "Monitor DPI %d x %d", gDpiHorizontal, gDpiVertical );
+ DALI_LOG_INFO( gLogFilter, Debug::General, "Monitor DPI %d x %d\n", gDpiHorizontal, gDpiVertical );
}
if( !mXkbData.mContext )
{
- DALI_LOG_ERROR("xkb_context_new failed");
+ DALI_LOG_ERROR("xkb_context_new failed\n");
close(fd);
return;
}
if( format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1 )
{
- DALI_LOG_ERROR("expected WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1");
+ DALI_LOG_ERROR("expected WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1\n");
close(fd);
return;
}
char* map = static_cast<char*> (mmap( NULL, size, PROT_READ, MAP_SHARED, fd, 0));
if( map == MAP_FAILED)
{
- DALI_LOG_ERROR("mmap xkb failed");
+ DALI_LOG_ERROR("mmap xkb failed\n");
close(fd);
return;
}
if (! mXkbData.mKeymap )
{
- DALI_LOG_ERROR(" xkb_map_new_from_string failed");
+ DALI_LOG_ERROR(" xkb_map_new_from_string failed\n");
return;
}
}
else
{
- DALI_LOG_ERROR("Failed to get native window handle");
+ DALI_LOG_ERROR("Failed to get native window handle\n");
}
return manager;
}
if (!eglImpl.InitializeGles(static_cast<EGLNativeDisplayType>( mWaylandManager->mDisplay )))
{
- DALI_LOG_ERROR("Failed to initialize GLES.");
+ DALI_LOG_ERROR("Failed to initialize GLES.\n");
}
eglImpl.ChooseConfig( true, mColorDepth );
}
else
{
- DALI_LOG_ERROR("wl_display_read_events error");
+ DALI_LOG_ERROR("wl_display_read_events error\n");
}
}
if (!eglImpl.InitializeGles(reinterpret_cast<EGLNativeDisplayType>(mDisplay)))
{
- DALI_LOG_ERROR("Failed to initialize GLES.");
+ DALI_LOG_ERROR("Failed to initialize GLES.\n");
return false;
}
#ifdef DALI_ELDBUS_AVAILABLE
// Initialize ElDBus.
- DALI_LOG_INFO( gImfLogging, Debug::General, "Starting DBus Initialization" );
+ DALI_LOG_INFO( gImfLogging, Debug::General, "Starting DBus Initialization\n" );
eldbus_init();
mSessionConnection = eldbus_connection_get( ELDBUS_CONNECTION_TYPE_SESSION );
// Pass in handler in the cb_data field so we can access the accessibility adaptor within the callback.
eldbus_proxy_call( elDBusManager, A11Y_GET_ADDRESS, EcoreElDBusInitialisation, handler, -1, "" );
- DALI_LOG_INFO( gImfLogging, Debug::General, "Finished DBus Initialization" );
+ DALI_LOG_INFO( gImfLogging, Debug::General, "Finished DBus Initialization\n" );
#endif // DALI_ELDBUS_AVAILABLE
}
}
else
{
- DALI_LOG_ERROR("Failed to get native window handle");
+ DALI_LOG_ERROR("Failed to get native window handle\n");
}
}
}
DALI_ASSERT_DEBUG(pXImage && "XImage (from pixmap) could not be retrieved from the server");
if(!pXImage)
{
- DALI_LOG_ERROR("Could not retrieve Ximage.");
+ DALI_LOG_ERROR("Could not retrieve Ximage.\n");
}
else
{
}
else
{
- DALI_LOG_ERROR("XImage has null data pointer.");
+ DALI_LOG_ERROR("XImage has null data pointer.\n");
}
break;
}
}
default:
{
- DALI_LOG_WARNING("Pixmap has unsupported bit-depth for getting pixels: %u", pXImage->depth);
+ DALI_LOG_WARNING("Pixmap has unsupported bit-depth for getting pixels: %u\n", pXImage->depth);
}
}
}
if(!success)
{
- DALI_LOG_ERROR("Failed to get pixels from NativeImageSource.");
+ DALI_LOG_ERROR("Failed to get pixels from NativeImageSource.\n");
pixbuf.resize(0);
width = 0;
height = 0;
if( desiredWidth == 0u || desiredHeight == 0u )
{
- DALI_LOG_INFO( gImageOpsLogFilter, Dali::Integration::Log::Verbose, "Downscaling to a zero-area target is pointless." );
+ DALI_LOG_INFO( gImageOpsLogFilter, Dali::Integration::Log::Verbose, "Downscaling to a zero-area target is pointless.\n" );
}
if( inputWidth == 0u || inputHeight == 0u )
{
- DALI_LOG_INFO( gImageOpsLogFilter, Dali::Integration::Log::Verbose, "Zero area images cannot be scaled" );
+ DALI_LOG_INFO( gImageOpsLogFilter, Dali::Integration::Log::Verbose, "Zero area images cannot be scaled\n" );
}
}
if( (runLength + outputIndex) > decodedSize)
{
- DALI_LOG_ERROR( "corrupted RLE data" );
+ DALI_LOG_ERROR( "corrupted RLE data\n" );
// corrupted
return false;
}
}
if( outputIndex != decodedSize)
{
- DALI_LOG_ERROR(" RLE data size missmatch");
+ DALI_LOG_ERROR(" RLE data size missmatch\n");
return false;
}
if(fread(&map[0], 1, fsize, fp) != fsize)
{
- DALI_LOG_WARNING("image file read opeation error!");
+ DALI_LOG_WARNING("image file read opeation error!\n");
return false;
}
}
if (diff_size)
{
- DALI_LOG_WARNING("Broken ICO file!");
+ DALI_LOG_WARNING("Broken ICO file!\n");
}
// Set up the surface as soon as we have the width and height, so we have a black image if there are any further errors.
// Pull the compressed JPEG image bytes out of a file and into memory:
if( fread( jpegBufferPtr, 1, jpegBufferSize, fp ) != jpegBufferSize )
{
- DALI_LOG_WARNING("Error on image file read.");
+ DALI_LOG_WARNING("Error on image file read.\n");
return false;
}
if(preXformImageWidth == 0 || preXformImageHeight == 0)
{
- DALI_LOG_WARNING("Invalid Image!");
+ DALI_LOG_WARNING("Invalid Image!\n");
return false;
}
}
default:
{
- DALI_LOG_ERROR( "Unsupported pixel format for encoding to JPEG." );
+ DALI_LOG_ERROR( "Unsupported pixel format for encoding to JPEG.\n" );
return false;
}
}
default:
{
// Try to keep loading the file, but let app developer know there was something fishy:
- DALI_LOG_WARNING( "Incorrect/Unknown Orientation setting found in EXIF header of JPEG image (%x). Orientation setting will be ignored.", entry );
+ DALI_LOG_WARNING( "Incorrect/Unknown Orientation setting found in EXIF header of JPEG image (%x). Orientation setting will be ignored.\n", entry );
break;
}
}
tjscalingfactor* factors = tjGetScalingFactors( &numFactors );
if( factors == NULL )
{
- DALI_LOG_WARNING("TurboJpeg tjGetScalingFactors error!");
+ DALI_LOG_WARNING("TurboJpeg tjGetScalingFactors error!\n");
success = false;
}
else
}
else
{
- DALI_LOG_ERROR("PNG buffer for write to memory was passed from libpng as null.");
+ DALI_LOG_ERROR("PNG buffer for write to memory was passed from libpng as null.\n");
}
}
catch(...)
{
- DALI_LOG_ERROR("C++ Exception caught");
+ DALI_LOG_ERROR("C++ Exception caught\n");
}
}
}
default:
{
- DALI_LOG_ERROR( "Unsupported pixel format for encoding to PNG." );
+ DALI_LOG_ERROR( "Unsupported pixel format for encoding to PNG.\n" );
return false;
}
}
if ((buf & 0x80) == 0)
{
- DALI_LOG_INFO(gLogFilter, Debug::Verbose, "position: %d, readBufCount: %d", *position, readBufCount);
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "position: %d, readBufCount: %d\n", *position, readBufCount);
break;
}
}
if(fread(&map[0], 1, fsize, fp) != fsize)
{
- DALI_LOG_WARNING("image file read opeation error!");
+ DALI_LOG_WARNING("image file read opeation error!\n");
return false;
}
map.Resize(headerSize);
if(fread(&map[0], 1, headerSize, fp) != headerSize)
{
- DALI_LOG_WARNING("image file read opeation error!");
+ DALI_LOG_WARNING("image file read opeation error!\n");
return false;
}
if (extractMultiByteInteger(&type, &map[0], headerSize, &position) < 0)
{
- DALI_LOG_ERROR("Error: unable to read type!");
+ DALI_LOG_ERROR("Error: unable to read type!\n");
return false;
}
position++; /* skipping one byte */
void ResourceThreadBase::Download(const Integration::ResourceRequest& request)
{
DALI_LOG_TRACE_METHOD(mLogFilter);
- DALI_LOG_WARNING("Resource Downloading from a remote server not supported for this type.");
+ DALI_LOG_WARNING("Resource Downloading from a remote server not supported for this type.\n");
///! If you need this for a subclassed thread, look to ResourceThreadImage::Download() for an example implementation.
}
void ResourceThreadBase::Decode(const Integration::ResourceRequest& request)
{
DALI_LOG_TRACE_METHOD(mLogFilter);
- DALI_LOG_WARNING("Resource Decoding from a memory buffer not supported for this type.");
+ DALI_LOG_WARNING("Resource Decoding from a memory buffer not supported for this type.\n");
///! If you need this for a subclassed thread, look to ResourceThreadImage::Decode() for an example implementation.
}
if( player == NULL )
{
- DALI_LOG_ERROR( "Decoded callback got Null pointer as user_data." );
+ DALI_LOG_ERROR( "Decoded callback got Null pointer as user_data.\n" );
return;
}
static void EmitPlaybackFinishedSignal( void* user_data )
{
TizenVideoPlayer* player = static_cast< TizenVideoPlayer* >( user_data );
- DALI_LOG_ERROR( "EmitPlaybackFinishedSignal.0" );
+ DALI_LOG_ERROR( "EmitPlaybackFinishedSignal.\n" );
if( player == NULL )
{
- DALI_LOG_ERROR( "Decoded callback got Null pointer as user_data." );
+ DALI_LOG_ERROR( "Decoded callback got Null pointer as user_data.\n" );
return;
}
- DALI_LOG_ERROR( "EmitPlaybackFinishedSignal." );
+ DALI_LOG_ERROR( "EmitPlaybackFinishedSignal.\n" );
if( !player->mFinishedSignal.Empty() )
{
- DALI_LOG_ERROR( "EmitPlaybackFinishedSignal.3" );
+ DALI_LOG_ERROR( "EmitPlaybackFinishedSignal.3\n" );
player->mFinishedSignal.Emit();
}
}
else
{
- DALI_LOG_ERROR( "Video rendering target is unknown" );
+ DALI_LOG_ERROR( "Video rendering target is unknown\n" );
}
}
projects / platform / core / uifw / dali-adaptor.git / commitdiff