#include <vsync-monitor.h>
#include <object-profiler.h>
-#include <slp-logging.h>
+#include <tizen-logging.h>
unsigned int logPanGesture = GetIntegerEnvironmentVariable( DALI_ENV_LOG_PAN_GESTURE, 0 );
- // all threads here (event, update, and render) will send their logs to SLP Platform's LogMessage handler.
- Dali::Integration::Log::LogFunction logFunction(Dali::SlpPlatform::LogMessage);
+ // all threads here (event, update, and render) will send their logs to TIZEN Platform's LogMessage handler.
+ Dali::Integration::Log::LogFunction logFunction(Dali::TizenPlatform::LogMessage);
mEnvironmentOptions.SetLogOptions( logFunction, logFrameRateFrequency, logupdateStatusFrequency, logPerformanceStats, logPerformanceStatsFrequency, performanceTimeStampOutput, logPanGesture );
{
ParseEnvironmentOptions();
- mPlatformAbstraction = new SlpPlatform::SlpPlatformAbstraction;
+ mPlatformAbstraction = new TizenPlatform::TizenPlatformAbstraction;
std::string path;
GetDataStoragePath( path );
#include <device-layout.h>
#include <clipboard.h>
-#include <slp-platform-abstraction.h>
+#include <tizen-platform-abstraction.h>
#include <base/interfaces/adaptor-internal-services.h>
#include <base/environment-options.h>
#include <base/core-event-interface.h>
EglFactory* mEglFactory; ///< EGL Factory
RenderSurface* mSurface; ///< Current surface
- SlpPlatform::SlpPlatformAbstraction* mPlatformAbstraction; ///< Platform abstraction
+ TizenPlatform::TizenPlatformAbstraction* mPlatformAbstraction; ///< Platform abstraction
EventHandler* mEventHandler; ///< event handler
CallbackManager* mCallbackManager; ///< Used to install callbacks
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
-class SlpPlatformAbstraction;
+class TizenPlatformAbstraction;
}
namespace Integration
{
ImageAttributes attributes;
Integration::BitmapResourceType bitmapResourceType( attributes );
- Integration::ResourcePointer resource = SlpPlatform::ImageLoader::LoadResourceSynchronously( bitmapResourceType, filename );
+ Integration::ResourcePointer resource = TizenPlatform::ImageLoader::LoadResourceSynchronously( bitmapResourceType, filename );
mBitmap = static_cast<Integration::Bitmap*>(resource.Get());
}
{
/**
- * The Framework class is used to register callbacks with the SLP platform so that
+ * The Framework class is used to register callbacks with the TIZEN platform so that
* we know when any of the application lifecycle events occur. This includes events
* like when our application is to be initialised, terminated, paused, resumed etc.
*/
// INTERNAL INCLUDES
#if defined(DEBUG_ENABLED)
-#include <slp-logging.h>
+#include <tizen-logging.h>
Debug::Filter* gSingletonServiceLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_SINGLETON_SERVICE" );
// Need to define own macro as the log function is not installed when this object is created so no logging is shown with DALI_LOG_INFO at construction and destruction
#define DALI_LOG_SINGLETON_SERVICE_DIRECT(level, message) \
- if(gSingletonServiceLogFilter && gSingletonServiceLogFilter->IsEnabledFor(level)) { std::string string(message); Dali::SlpPlatform::LogMessage( Debug::DebugInfo, string ); }
+ if(gSingletonServiceLogFilter && gSingletonServiceLogFilter->IsEnabledFor(level)) { std::string string(message); Dali::TizenPlatform::LogMessage( Debug::DebugInfo, string ); }
#define DALI_LOG_SINGLETON_SERVICE(level, format, args...) DALI_LOG_INFO(gSingletonServiceLogFilter, level, format, ## args )
#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
-#include <platform-abstractions/slp/resource-loader/resource-loader.h>
-#include <platform-abstractions/slp/image-loaders/loader-jpeg.h>
-#include <platform-abstractions/slp/image-loaders/loader-png.h>
+#include <platform-abstractions/tizen/resource-loader/resource-loader.h>
+#include <platform-abstractions/tizen/image-loaders/loader-jpeg.h>
+#include <platform-abstractions/tizen/image-loaders/loader-png.h>
#include <image-encoder.h>
namespace Dali
{
case JPG_FORMAT:
{
- return SlpPlatform::EncodeToJpeg( pixelBuffer, encodedPixels, width, height, pixelFormat );
+ return TizenPlatform::EncodeToJpeg( pixelBuffer, encodedPixels, width, height, pixelFormat );
break;
}
case PNG_FORMAT:
{
- return SlpPlatform::EncodeToPng( pixelBuffer, encodedPixels, width, height, pixelFormat );
+ return TizenPlatform::EncodeToPng( pixelBuffer, encodedPixels, width, height, pixelFormat );
break;
}
default:
DALI_LOG_ERROR("Encoding pixels failed");
return false;
}
- return SlpPlatform::ResourceLoader::SaveFile( filename, pixbufEncoded );
+ return TizenPlatform::ResourceLoader::SaveFile( filename, pixbufEncoded );
}
} // namespace Dali
#include <render-surface.h>
// Allow this to be encoded and saved:
-#include <platform-abstractions/slp/resource-loader/resource-loader.h>
+#include <platform-abstractions/tizen/resource-loader/resource-loader.h>
#include <bitmap-saver.h>
namespace Dali
#include <dali-test-suite-utils.h>
-class StubImageLoaderClient : public Dali::SlpPlatform::ResourceLoadingClient
+class StubImageLoaderClient : public Dali::TizenPlatform::ResourceLoadingClient
{
public:
StubImageLoaderClient() {}
#include <dali/dali.h>
#include <dali/integration-api/bitmap.h>
-#include "platform-abstractions/slp/resource-loader/resource-loading-client.h"
+#include "platform-abstractions/tizen/resource-loader/resource-loading-client.h"
// Simple structure to close the file when finished with it.
struct AutoCloseFile
*/
struct LoadFunctions
{
- typedef bool (*LoadBitmapFunction)(FILE*, Dali::Integration::Bitmap&, Dali::ImageAttributes&, const Dali::SlpPlatform::ResourceLoadingClient& client);
+ typedef bool (*LoadBitmapFunction)(FILE*, Dali::Integration::Bitmap&, Dali::ImageAttributes&, const Dali::TizenPlatform::ResourceLoadingClient& client);
typedef bool (*LoadBitmapHeaderFunction)(FILE*, const Dali::ImageAttributes& attrs, unsigned int& width, unsigned int& height );
LoadFunctions( LoadBitmapHeaderFunction _header, LoadBitmapFunction _loader );
#include <stdlib.h>
#include <dali-test-suite-utils.h>
-#include "platform-abstractions/slp/image-loaders/loader-gif.h"
+#include "platform-abstractions/tizen/image-loaders/loader-gif.h"
#include "image-loaders.h"
using namespace Dali;
namespace {
-static const LoadFunctions GifLoaders( SlpPlatform::LoadGifHeader, SlpPlatform::LoadBitmapFromGif );
+static const LoadFunctions GifLoaders( TizenPlatform::LoadGifHeader, TizenPlatform::LoadBitmapFromGif );
}
${${CAPI_LIB}_INCLUDE_DIRS}
../dali-adaptor/dali-test-suite-utils
../../../adaptors/tizen
- ../../../platform-abstractions/slp
+ ../../../platform-abstractions/tizen
../../../
/usr/include/freetype2
)
*/
#include "resource-collector.h"
-#include "slp-platform-abstraction.h"
+#include "tizen-platform-abstraction.h"
#include <dali/integration-api/debug.h>
namespace Dali
#include <stdlib.h>
#include <dali/dali.h>
#include <dali-test-suite-utils.h>
-#include "slp-platform-abstraction.h"
+#include "tizen-platform-abstraction.h"
#include "resource-collector.h"
using namespace Dali;
include ../../../adaptors/base/file.list
# Platform Abstraction
-slp_platform_abstraction_src_dir = ../../../platform-abstractions/slp
+tizen_platform_abstraction_src_dir = ../../../platform-abstractions/tizen
portable_platform_abstraction_src_dir = ../../../platform-abstractions/portable
-include ../../../platform-abstractions/slp/file.list
+include ../../../platform-abstractions/tizen/file.list
# Internal Common
adaptor_common_dir = ../../../adaptors/common
############# source files #############
if ASSIMP_ENABLED
-slp_platform_abstraction_src_files += $(slp_assimp_src_files)
+tizen_platform_abstraction_src_files += $(tizen_assimp_src_files)
else
-slp_platform_abstraction_src_files += $(slp_assimp_stubs_src_files)
+tizen_platform_abstraction_src_files += $(tizen_assimp_stubs_src_files)
endif # ASSIMP_ENABLED
# COMMON
endif
if TURBO_JPEG_IS_ON
- slp_platform_abstraction_src_files += $(slp_turbo_jpeg_loader)
+ tizen_platform_abstraction_src_files += $(tizen_turbo_jpeg_loader)
else
- slp_platform_abstraction_src_files += $(slp_jpeg_loader)
+ tizen_platform_abstraction_src_files += $(tizen_jpeg_loader)
endif
lib_LTLIBRARIES = libdali-adaptor.la
libdali_adaptor_la_SOURCES = \
$(base_adaptor_src_files) \
- $(slp_platform_abstraction_src_files) \
+ $(tizen_platform_abstraction_src_files) \
$(public_api_src_files) \
$(adaptor_internal_src_files)
libdali_adaptor_la_DEPENDENCIES =
-# List include directories with more platform-specific (slp) before portable root:
+# List include directories with more platform-specific (tizen) before portable root:
libdali_adaptor_la_includes = \
-I../../.. \
- -I../../../platform-abstractions/slp \
- -I../../../platform-abstractions/slp/resource-loader \
+ -I../../../platform-abstractions/tizen \
+ -I../../../platform-abstractions/tizen/resource-loader \
-I../../../platform-abstractions/portable \
-I../../../platform-abstractions/ \
-I../../../adaptors/public-api \
AM_CONDITIONAL([USE_BULLET], [test x$BULLET = xyes && test x$enable_bullet = xyes])
AM_CONDITIONAL([USE_FEEDBACK], [test x$enable_feedback = xyes])
-DALI_ADAPTOR_CFLAGS=-DPLATFORM_SLP
+DALI_ADAPTOR_CFLAGS=-DPLATFORM_TIZEN
AC_ARG_ENABLE(exportall,
[AC_HELP_STRING([--enable-exportall],
+++ /dev/null
-# Add local source files here:
-
-slp_platform_abstraction_src_files = \
- $(slp_platform_abstraction_src_dir)/slp-platform-abstraction.cpp \
- $(slp_platform_abstraction_src_dir)/slp-logging.cpp \
- $(slp_platform_abstraction_src_dir)/slp-font-configuration-parser.cpp \
- $(slp_platform_abstraction_src_dir)/font-platform/font-controller-impl.cpp \
- $(slp_platform_abstraction_src_dir)/data-cache/data-cache-io.cpp \
- $(slp_platform_abstraction_src_dir)/data-cache/data-cache-impl.cpp \
- $(slp_platform_abstraction_src_dir)/data-cache/tests/data-cache-debug.cpp \
- $(slp_platform_abstraction_src_dir)/data-cache/data-compression.cpp \
- $(slp_platform_abstraction_src_dir)/data-cache/metrics-cache.cpp \
- $(slp_platform_abstraction_src_dir)/dynamics/dynamics-factory.cpp \
- \
- $(slp_platform_abstraction_src_dir)/resource-loader/loader-font.cpp \
- $(slp_platform_abstraction_src_dir)/resource-loader/resource-loader.cpp \
- $(slp_platform_abstraction_src_dir)/resource-loader/resource-requester-base.cpp \
- $(slp_platform_abstraction_src_dir)/resource-loader/resource-bitmap-requester.cpp \
- $(slp_platform_abstraction_src_dir)/resource-loader/resource-shader-requester.cpp \
- $(slp_platform_abstraction_src_dir)/resource-loader/resource-text-requester.cpp \
- \
- $(slp_platform_abstraction_src_dir)/resource-loader/resource-thread-base.cpp \
- $(slp_platform_abstraction_src_dir)/resource-loader/resource-thread-image.cpp \
- $(slp_platform_abstraction_src_dir)/resource-loader/resource-thread-shader.cpp \
- $(slp_platform_abstraction_src_dir)/resource-loader/resource-thread-text.cpp \
- \
- \
- $(slp_platform_abstraction_src_dir)/resource-loader/debug/resource-loader-debug.cpp \
- \
- $(slp_platform_abstraction_src_dir)/image-loaders/loader-bmp.cpp \
- $(slp_platform_abstraction_src_dir)/image-loaders/loader-gif.cpp \
- $(slp_platform_abstraction_src_dir)/image-loaders/loader-png.cpp \
- $(slp_platform_abstraction_src_dir)/image-loaders/loader-ico.cpp \
- $(slp_platform_abstraction_src_dir)/image-loaders/loader-ktx.cpp \
- $(slp_platform_abstraction_src_dir)/image-loaders/loader-wbmp.cpp \
- $(slp_platform_abstraction_src_dir)/image-loaders/image-loader.cpp \
- $(portable_platform_abstraction_src_dir)/image-operations.cpp
-
-slp_turbo_jpeg_loader = \
- $(slp_platform_abstraction_src_dir)/image-loaders/loader-jpeg-turbo.cpp
-
-slp_jpeg_loader = \
- $(slp_platform_abstraction_src_dir)/image-loaders/loader-jpeg.cpp
-
-# Add public headers here:
-
-# platform_abstraction_header_files =
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace
}
}
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
unsigned int maxDataSize,
unsigned int maxNumberEntries)
{
- return new Dali::SlpPlatform::DataCache( mode, compressionMode, fileName, maxDataSize, maxNumberEntries );
+ return new Dali::TizenPlatform::DataCache( mode, compressionMode, fileName, maxDataSize, maxNumberEntries );
}
-#ifndef __DALI_SLP_PLATFORM_DATA_CACHE_H__
-#define __DALI_SLP_PLATFORM_DATA_CACHE_H__
+#ifndef __DALI_TIZEN_PLATFORM_DATA_CACHE_H__
+#define __DALI_TIZEN_PLATFORM_DATA_CACHE_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
/**
};
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLP_PLATFORM_DATA_CACHE_H__
+#endif // __DALI_TIZEN_PLATFORM_DATA_CACHE_H__
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace DataCacheIo
}
} // namespace DataCacheIO
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#ifndef __DALI_SLP_PLATFORM_DATA_CACHE_IO_H__
-#define __DALI_SLP_PLATFORM_DATA_CACHE_IO_H__
+#ifndef __DALI_TIZEN_PLATFORM_DATA_CACHE_IO_H__
+#define __DALI_TIZEN_PLATFORM_DATA_CACHE_IO_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
/**
} // namespace DataCacheIO
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLP_PLATFORM_DATA_CACHE_IO_H__
+#endif // __DALI_TIZEN_PLATFORM_DATA_CACHE_IO_H__
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace DataCompression
{
} // DataCompression
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#ifndef __DALI_SLP_PLATFORM_DATA_COMPRESSION_H__
-#define __DALI_SLP_PLATFORM_DATA_COMPRESSION_H__
+#ifndef __DALI_TIZEN_PLATFORM_DATA_COMPRESSION_H__
+#define __DALI_TIZEN_PLATFORM_DATA_COMPRESSION_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace DataCompression
{
} // namespace DataCompression
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLP_PLATFORM_DATA_COMPRESSION_H__
+#endif // __DALI_TIZEN_PLATFORM_DATA_COMPRESSION_H__
} // Anonymous namespace
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace MetricsCache
{
} // MetricsCache
-} // SlpPlatform
+} // TizenPlatform
} // Dali
-#ifndef DALI_SLP_PLATFORM_METRICS_CACHE_H
-#define DALI_SLP_PLATFORM_METRICS_CACHE_H
+#ifndef DALI_TIZEN_PLATFORM_METRICS_CACHE_H
+#define DALI_TIZEN_PLATFORM_METRICS_CACHE_H
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace MetricsCache
{
void Write( const std::string& fontFamily, const std::string& fontStyle, const Integration::GlyphSet& glyphSet );
} // MetricsCache
-} // SlpPlatform
+} // TizenPlatform
} // Dali
#endif //DALI_INTEGRATION_METRICS_CACHE_H
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace DataCacheIo
} // namespace DataCacheIO
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
#endif // #ifdef DATA_CACHE_DEBUG
-#ifndef __DALI_SLP_PLATFORM_DATA_CACHE_DEBUG_H__
-#define __DALI_SLP_PLATFORM_DATA_CACHE_DEBUG_H__
+#ifndef __DALI_TIZEN_PLATFORM_DATA_CACHE_DEBUG_H__
+#define __DALI_TIZEN_PLATFORM_DATA_CACHE_DEBUG_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace DataCacheIo
{
} // namespace DataCacheIO
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLP_PLATFORM_DATA_CACHE_DEBUG_H__
+#endif // __DALI_TIZEN_PLATFORM_DATA_CACHE_DEBUG_H__
#endif // #ifdef DATA_CACHE_DEBUG
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace
return dynamicsShape;
}
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
/**
}; // class DynamicsFactory
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
--- /dev/null
+# Add local source files here:
+
+tizen_platform_abstraction_src_files = \
+ $(tizen_platform_abstraction_src_dir)/tizen-platform-abstraction.cpp \
+ $(tizen_platform_abstraction_src_dir)/tizen-logging.cpp \
+ $(tizen_platform_abstraction_src_dir)/tizen-font-configuration-parser.cpp \
+ $(tizen_platform_abstraction_src_dir)/font-platform/font-controller-impl.cpp \
+ $(tizen_platform_abstraction_src_dir)/data-cache/data-cache-io.cpp \
+ $(tizen_platform_abstraction_src_dir)/data-cache/data-cache-impl.cpp \
+ $(tizen_platform_abstraction_src_dir)/data-cache/tests/data-cache-debug.cpp \
+ $(tizen_platform_abstraction_src_dir)/data-cache/data-compression.cpp \
+ $(tizen_platform_abstraction_src_dir)/data-cache/metrics-cache.cpp \
+ $(tizen_platform_abstraction_src_dir)/dynamics/dynamics-factory.cpp \
+ \
+ $(tizen_platform_abstraction_src_dir)/resource-loader/loader-font.cpp \
+ $(tizen_platform_abstraction_src_dir)/resource-loader/resource-loader.cpp \
+ $(tizen_platform_abstraction_src_dir)/resource-loader/resource-requester-base.cpp \
+ $(tizen_platform_abstraction_src_dir)/resource-loader/resource-bitmap-requester.cpp \
+ $(tizen_platform_abstraction_src_dir)/resource-loader/resource-shader-requester.cpp \
+ $(tizen_platform_abstraction_src_dir)/resource-loader/resource-text-requester.cpp \
+ \
+ $(tizen_platform_abstraction_src_dir)/resource-loader/resource-thread-base.cpp \
+ $(tizen_platform_abstraction_src_dir)/resource-loader/resource-thread-image.cpp \
+ $(tizen_platform_abstraction_src_dir)/resource-loader/resource-thread-shader.cpp \
+ $(tizen_platform_abstraction_src_dir)/resource-loader/resource-thread-text.cpp \
+ \
+ \
+ $(tizen_platform_abstraction_src_dir)/resource-loader/debug/resource-loader-debug.cpp \
+ \
+ $(tizen_platform_abstraction_src_dir)/image-loaders/loader-bmp.cpp \
+ $(tizen_platform_abstraction_src_dir)/image-loaders/loader-gif.cpp \
+ $(tizen_platform_abstraction_src_dir)/image-loaders/loader-png.cpp \
+ $(tizen_platform_abstraction_src_dir)/image-loaders/loader-ico.cpp \
+ $(tizen_platform_abstraction_src_dir)/image-loaders/loader-ktx.cpp \
+ $(tizen_platform_abstraction_src_dir)/image-loaders/loader-wbmp.cpp \
+ $(tizen_platform_abstraction_src_dir)/image-loaders/image-loader.cpp \
+ $(portable_platform_abstraction_src_dir)/image-operations.cpp
+
+tizen_turbo_jpeg_loader = \
+ $(tizen_platform_abstraction_src_dir)/image-loaders/loader-jpeg-turbo.cpp
+
+tizen_jpeg_loader = \
+ $(tizen_platform_abstraction_src_dir)/image-loaders/loader-jpeg.cpp
+
+# Add public headers here:
+
+# platform_abstraction_header_files =
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
#if defined(DEBUG_ENABLED)
mPreferredFonts.Clear();
}
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
// Implementation of Dali::Platform::FontController::New()
Dali::Platform::FontController* Dali::Platform::FontController::New()
{
- return new Dali::SlpPlatform::FontController();
+ return new Dali::TizenPlatform::FontController();
}
-#ifndef __DALI_SLP_PLATFORM_FONT_CONTROLLER_H__
-#define __DALI_SLP_PLATFORM_FONT_CONTROLLER_H__
+#ifndef __DALI_TIZEN_PLATFORM_FONT_CONTROLLER_H__
+#define __DALI_TIZEN_PLATFORM_FONT_CONTROLLER_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
typedef Dali::Platform::FontController::FontList FontList;
/**
- * concrete interface for the SLP font controller.
+ * concrete interface for the TIZEN font controller.
*
* Font controller currently caches the following:
* - List of fonts on the system, if the user calls GetFontList()
};
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLP_PLATFORM_FONT_CONTROLLER_H__
+#endif // __DALI_TIZEN_PLATFORM_FONT_CONTROLLER_H__
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace
}
} // ImageLoader
-} // SlpPlatform
+} // TizenPlatform
} // Dali
-#ifndef __DALI_SLP_PLATFORM_IMAGE_LOADER_H__
-#define __DALI_SLP_PLATFORM_IMAGE_LOADER_H__
+#ifndef __DALI_TIZEN_PLATFORM_IMAGE_LOADER_H__
+#define __DALI_TIZEN_PLATFORM_IMAGE_LOADER_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace ImageLoader
{
Vector2 &closestSize );
} // ImageLoader
-} // SlpPlatform
+} // TizenPlatform
} // Dali
-#endif // __DALI_SLP_PLATFORM_IMAGE_LOADER_H__
+#endif // __DALI_TIZEN_PLATFORM_IMAGE_LOADER_H__
{
using Integration::Bitmap;
using Dali::Integration::PixelBuffer;
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace
return true;
}
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#ifndef __DALI_SLP_PLATFORM_LOADER_BMP_H__
-#define __DALI_SLP_PLATFORM_LOADER_BMP_H__
+#ifndef __DALI_TIZEN_PLATFORM_LOADER_BMP_H__
+#define __DALI_TIZEN_PLATFORM_LOADER_BMP_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
struct ImageAttributes;
-namespace SlpPlatform
+namespace TizenPlatform
{
class ResourceLoadingClient;
*/
bool LoadBmpHeader(FILE *fp, const ImageAttributes& attributes, unsigned int &width, unsigned int &height);
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLP_PLATFORM_LOADER_BMP_H__
+#endif // __DALI_TIZEN_PLATFORM_LOADER_BMP_H__
using Integration::Bitmap;
using Dali::Integration::PixelBuffer;
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace
return true;
}
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#ifndef __DALI_SLP_PLATFORM_LOADER_GIF_H__
-#define __DALI_SLP_PLATFORM_LOADER_GIF_H__
+#ifndef __DALI_TIZEN_PLATFORM_LOADER_GIF_H__
+#define __DALI_TIZEN_PLATFORM_LOADER_GIF_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
struct ImageAttributes;
-namespace SlpPlatform
+namespace TizenPlatform
{
class ResourceLoadingClient;
*/
bool LoadGifHeader(FILE *fp, const ImageAttributes& attributes, unsigned int &width, unsigned int &height );
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLP_PLATFORM_LOADER_GIF_H__
+#endif // __DALI_TIZEN_PLATFORM_LOADER_GIF_H__
using Integration::Bitmap;
using Dali::Integration::PixelBuffer;
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace
-#ifndef __DALI_SLP_PLATFORM_LOADER_ICO_H__
-#define __DALI_SLP_PLATFORM_LOADER_ICO_H__
+#ifndef __DALI_TIZEN_PLATFORM_LOADER_ICO_H__
+#define __DALI_TIZEN_PLATFORM_LOADER_ICO_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
}
struct ImageAttributes;
-namespace SlpPlatform
+namespace TizenPlatform
{
class ResourceLoadingClient;
{
using Integration::Bitmap;
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace
}
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
{
using Integration::Bitmap;
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace
return true;
}
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#ifndef __DALI_SLP_PLATFORM_LOADER_JPEG_H__
-#define __DALI_SLP_PLATFORM_LOADER_JPEG_H__
+#ifndef __DALI_TIZEN_PLATFORM_LOADER_JPEG_H__
+#define __DALI_TIZEN_PLATFORM_LOADER_JPEG_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
struct ImageAttributes;
-namespace SlpPlatform
+namespace TizenPlatform
{
class ResourceLoadingClient;
*/
bool EncodeToJpeg(const unsigned char* pixelBuffer, std::vector< unsigned char >& encodedPixels, std::size_t width, std::size_t height, Pixel::Format pixelFormat, unsigned quality = 80);
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLP_PLATFORM_LOADER_JPEG_H__
+#endif // __DALI_TIZEN_PLATFORM_LOADER_JPEG_H__
using Integration::Bitmap;
using Dali::Integration::PixelBuffer;
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace
return true;
}
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#ifndef __DALI_SLP_PLATFORM_LOADER_KTX_H__
-#define __DALI_SLP_PLATFORM_LOADER_KTX_H__
+#ifndef __DALI_TIZEN_PLATFORM_LOADER_KTX_H__
+#define __DALI_TIZEN_PLATFORM_LOADER_KTX_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
struct ImageAttributes;
-namespace SlpPlatform
+namespace TizenPlatform
{
class ResourceLoadingClient;
*/
bool LoadKtxHeader(FILE * const fp, const ImageAttributes& attributes, unsigned int &width, unsigned int &height);
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLP_PLATFORM_LOADER_KTX_H__
+#endif // __DALI_TIZEN_PLATFORM_LOADER_KTX_H__
using Integration::Bitmap;
using Dali::Integration::PixelBuffer;
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace
* */
extern "C" void WriteData(png_structp png_ptr, png_bytep data, png_size_t length)
{
- using Dali::SlpPlatform::PngBuffer;
+ using Dali::TizenPlatform::PngBuffer;
DALI_ASSERT_DEBUG(png_ptr && data);
if(!png_ptr || !data)
{
return true;
}
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#ifndef __DALI_SLP_PLATFORM_LOADER_PNG_H__
-#define __DALI_SLP_PLATFORM_LOADER_PNG_H__
+#ifndef __DALI_TIZEN_PLATFORM_LOADER_PNG_H__
+#define __DALI_TIZEN_PLATFORM_LOADER_PNG_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
}
struct ImageAttributes;
-namespace SlpPlatform
+namespace TizenPlatform
{
class ResourceLoadingClient;
*/
bool EncodeToPng( const unsigned char* pixelBuffer, PngBuffer& encodedPixels, std::size_t width, std::size_t height, Pixel::Format pixelFormat );
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLP_PLATFORM_LOADER_PNG_H__
+#endif // __DALI_TIZEN_PLATFORM_LOADER_PNG_H__
{
using Integration::Bitmap;
using Dali::Integration::PixelBuffer;
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace
-#ifndef __DALI_SLP_PLATFORM_LOADER_WBMP_H__
-#define __DALI_SLP_PLATFORM_LOADER_WBMP_H__
+#ifndef __DALI_TIZEN_PLATFORM_LOADER_WBMP_H__
+#define __DALI_TIZEN_PLATFORM_LOADER_WBMP_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
}
struct ImageAttributes;
-namespace SlpPlatform
+namespace TizenPlatform
{
class ResourceLoadingClient;
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
using namespace Dali::Integration;
return textString;
}
-} //SlpPlatform
+} //TizenPlatform
} //Dali
#endif
-#ifndef __DALI_SLP_PLATFORM_RESOURCE_LOADER_DEBUG_H__
-#define __DALI_SLP_PLATFORM_RESOURCE_LOADER_DEBUG_H__
+#ifndef __DALI_TIZEN_PLATFORM_RESOURCE_LOADER_DEBUG_H__
+#define __DALI_TIZEN_PLATFORM_RESOURCE_LOADER_DEBUG_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
#include <dali/integration-api/debug.h>
#if defined(DEBUG_ENABLED)
-#include <platform-abstractions/slp/resource-loader/resource-loader.h>
+#include <platform-abstractions/tizen/resource-loader/resource-loader.h>
#include <dali/integration-api/resource-cache.h>
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
extern Debug::Filter* gLoaderFilter;
std::string DebugRequestList(Integration::TextResourceType::CharacterList& chars);
std::string DebugResourceList(LoadedResource& partialResource);
-} // SlpPlatform
+} // TizenPlatform
} // Dali
#endif // defined(DEBUG_ENABLED)
-#endif //__DALI_SLP_PLATFORM_RESOURCE_LOADER_DEBUG_H__
+#endif //__DALI_TIZEN_PLATFORM_RESOURCE_LOADER_DEBUG_H__
-#ifndef __DALI_SLP_PLATFORM_IMAGE_ENCODER_H__
-#define __DALI_SLP_PLATFORM_IMAGE_ENCODER_H__
+#ifndef __DALI_TIZEN_PLATFORM_IMAGE_ENCODER_H__
+#define __DALI_TIZEN_PLATFORM_IMAGE_ENCODER_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
} // namespace Dali
-#endif //__DALI_SLP_PLATFORM_IMAGE_ENCODER_H__
+#endif //__DALI_TIZEN_PLATFORM_IMAGE_ENCODER_H__
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
using namespace Dali::Integration;
} // unnamed namespace
#endif
-static SlpFace* LoadFontFile(const std::string &fileName, FT_Library freeType)
+static TizenFace* LoadFontFile(const std::string &fileName, FT_Library freeType)
{
- SlpFace* slpFace = NULL;
+ TizenFace* tizenFace = NULL;
// Open freetype font file
FILE* fontFile = fopen(fileName.c_str(), "rb");
}
// allocate a buffer for the file (throws a memory exception on failure)
- slpFace = new SlpFace;
- slpFace->buffer = new FT_Byte[fileSize];
+ tizenFace = new TizenFace;
+ tizenFace->buffer = new FT_Byte[fileSize];
// read the file
- unsigned int bytes = fread(slpFace->buffer, 1, fileSize, fontFile);
+ unsigned int bytes = fread(tizenFace->buffer, 1, fileSize, fontFile);
if (bytes != fileSize)
{
DALI_LOG_WARNING("Number of bytes read (%d) does not match the file's size (%d)\n", bytes, fileSize);
}
// create a freetype face from the memory buffer
- FT_Error retVal = FT_New_Memory_Face(freeType, slpFace->buffer, fileSize, 0, &slpFace->face);
+ FT_Error retVal = FT_New_Memory_Face(freeType, tizenFace->buffer, fileSize, 0, &tizenFace->face);
if (retVal != FT_Err_Ok)
{
DALI_LOG_WARNING("FT_New_Face failed on %s\n", fileName.c_str());
- delete slpFace;
- slpFace = NULL;
+ delete tizenFace;
+ tizenFace = NULL;
}
}
fclose(fontFile);
}
- return slpFace;
+ return tizenFace;
}
-SlpFace* LoadFontFace(const std::string &fileName,
+TizenFace* LoadFontFace(const std::string &fileName,
const PointSize pointSize,
const unsigned int dpiHor, const unsigned int dpiVer,
FT_Library freeType)
{
- SlpFace* slpFace = LoadFontFile(fileName, freeType);
+ TizenFace* tizenFace = LoadFontFile(fileName, freeType);
- if (NULL != slpFace)
+ if (NULL != tizenFace)
{
- FT_Face face = slpFace->face;
+ FT_Face face = tizenFace->face;
// set the char size for glyph scaling
FT_Error retVal = FT_Set_Char_Size(face, 0, static_cast<unsigned int>(roundf(pointSize.value))<<6, dpiHor, dpiVer);
if (retVal != FT_Err_Ok)
{
DALI_LOG_WARNING("FT_Set_Char_Size failed on %s\n", fileName.c_str());
- delete slpFace;
- slpFace = NULL;
+ delete tizenFace;
+ tizenFace = NULL;
}
else
{
}
}
- return slpFace;
+ return tizenFace;
}
-SlpFace* LoadFontFace(const std::string &fileName,
+TizenFace* LoadFontFace(const std::string &fileName,
const PixelSize pixelSize,
FT_Library freeType)
{
- SlpFace* slpFace = LoadFontFile(fileName, freeType);
+ TizenFace* tizenFace = LoadFontFile(fileName, freeType);
- if (NULL != slpFace)
+ if (NULL != tizenFace)
{
- FT_Face face = slpFace->face;
+ FT_Face face = tizenFace->face;
// set the pixel size for glyph scaling
FT_Error retVal = FT_Set_Pixel_Sizes(face, pixelSize, pixelSize);
if (retVal != FT_Err_Ok)
{
DALI_LOG_WARNING("FT_Set_Pixel_Sizes failed on %s\n", fileName.c_str());
- delete slpFace;
- slpFace = NULL;
+ delete tizenFace;
+ tizenFace = NULL;
}
else
{
}
}
- return slpFace;
+ return tizenFace;
}
// charcode must be UTF-32 representation
return image;
}
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#ifndef __DALI_SLP_PLATFORM_LOADER_FONT_H__
-#define __DALI_SLP_PLATFORM_LOADER_FONT_H__
+#ifndef __DALI_TIZEN_PLATFORM_LOADER_FONT_H__
+#define __DALI_TIZEN_PLATFORM_LOADER_FONT_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
class GlyphSet;
}
-namespace SlpPlatform
+namespace TizenPlatform
{
-struct SlpFace
+struct TizenFace
{
- SlpFace()
+ TizenFace()
{
face = NULL;
buffer = NULL;
}
- ~SlpFace()
+ ~TizenFace()
{
if (face)
{
* @param [in] dpiHor Horizontal dpi
* @param [in] dpiVer Vertical dpi
* @param [inout] freeType A handle to the FreeType library resource
- * @return A SlpFace pointer on success, NULL on failure
+ * @return A TizenFace pointer on success, NULL on failure
*/
-SlpFace* LoadFontFace(const std::string &fileName,
+TizenFace* LoadFontFace(const std::string &fileName,
const PointSize pointSize,
const unsigned int dpiHor, const unsigned int dpiVer,
FT_Library freeType);
* @param [in] fileName Font file name
* @param [in] pixelSize Pixel size for freetype source glyph scaling
* @param [inout] freeType A handle to the FreeType library resource
- * @return A SlpFace pointer on success, NULL on failure
+ * @return A TizenFace pointer on success, NULL on failure
*/
-SlpFace* LoadFontFace(const std::string &fileName,
+TizenFace* LoadFontFace(const std::string &fileName,
const PixelSize pixelSize,
FT_Library freeType);
*/
Integration::BitmapPtr GetGlyphBitmap( FT_Face face, FT_ULong charCode );
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLP_PLATFORM_LOADER_FONT_H__
+#endif // __DALI_TIZEN_PLATFORM_LOADER_FONT_H__
-#ifndef __DALI_SLP_PLATFORM_CAPABILITIES_H__
-#define __DALI_SLP_PLATFORM_CAPABILITIES_H__
+#ifndef __DALI_TIZEN_PLATFORM_CAPABILITIES_H__
+#define __DALI_TIZEN_PLATFORM_CAPABILITIES_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
/**
#endif
}
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLP_PLATFORM_CAPABILITIES_H__
+#endif // __DALI_TIZEN_PLATFORM_CAPABILITIES_H__
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
ResourceBitmapRequester::ResourceBitmapRequester( ResourceLoader& resourceLoader )
mThreadImageRemote->CancelRequest(id);
}
-} // SlpPlatform
+} // TizenPlatform
} // Dali
-#ifndef __DALI_SLP_PLATFORM_RESOURCE_BITMAP_REQUESTER_H__
-#define __DALI_SLP_PLATFORM_RESOURCE_BITMAP_REQUESTER_H__
+#ifndef __DALI_TIZEN_PLATFORM_RESOURCE_BITMAP_REQUESTER_H__
+#define __DALI_TIZEN_PLATFORM_RESOURCE_BITMAP_REQUESTER_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
/**
ResourceThreadImage* mThreadImageRemote; ///< Image loader thread object to download images in remote http server
};
-} // SlpPlatform
+} // TizenPlatform
} // Dali
-#endif // __DALI_SLP_PLATFORM_RESOURCE_BITMAP_REQUESTER_H__
+#endif // __DALI_TIZEN_PLATFORM_RESOURCE_BITMAP_REQUESTER_H__
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace
if (!fontFamily.empty())
{
const std::string& fontFileName = GetFontPath( fontFamily, fontStyle );
- SlpFace* slpFace = LoadFontFace(fontFileName, PixelSize(capsHeight), freeType);
+ TizenFace* tizenFace = LoadFontFace(fontFileName, PixelSize(capsHeight), freeType);
- if (slpFace)
+ if (tizenFace)
{
- const float scale = static_cast<float>(capsHeight.value) / ((slpFace->face->ascender / 64.0f) * 0.95f);
+ const float scale = static_cast<float>(capsHeight.value) / ((tizenFace->face->ascender / 64.0f) * 0.95f);
- result.value = static_cast<unsigned int>(roundf(scale * (slpFace->face->height / 64.0f)));
+ result.value = static_cast<unsigned int>(roundf(scale * (tizenFace->face->height / 64.0f)));
- delete slpFace;
- slpFace = NULL;
+ delete tizenFace;
+ tizenFace = NULL;
}
}
const bool highQuality(textRequest.mQuality == TextResourceType::TextQualityHigh);
const unsigned int glyphQuality( highQuality ? GlyphMetrics::HIGH_QUALITY : GlyphMetrics::LOW_QUALITY );
- SlpFace* slpFace = LoadFontFace( fontFileName, PixelSize( HIGH_QUALITY_PIXEL_SIZE), freeType );
- if (slpFace)
+ TizenFace* tizenFace = LoadFontFace( fontFileName, PixelSize( HIGH_QUALITY_PIXEL_SIZE), freeType );
+ if (tizenFace)
{
glyphSet = new GlyphSet();
glyphSet->mFontHash = fontHash;
then = GetTimeMicroseconds();
}
#endif
- ScopedPointer< GlyphSet::Character > character( GetCharacter(slpFace->face, charCode,
+ ScopedPointer< GlyphSet::Character > character( GetCharacter(tizenFace->face, charCode,
DISTANCE_FIELD_SIZE, DISTANCE_FIELD_PADDING, textRequest.mMaxGlyphSize,
getBitmap, highQuality ) );
}
}
- delete slpFace;
+ delete tizenFace;
}
}
{
const std::string& fontFileName = GetFontPath( fontFamily, fontStyle );
- SlpFace* slpFace = LoadFontFace( fontFileName, PixelSize( HIGH_QUALITY_PIXEL_SIZE), freeType );
- if( slpFace )
+ TizenFace* tizenFace = LoadFontFace( fontFileName, PixelSize( HIGH_QUALITY_PIXEL_SIZE), freeType );
+ if( tizenFace )
{
// scale factor for unit scaled glyphs
- const float xScale = 1.0f / (slpFace->face->size->metrics.x_scale / 65536.0f);
- const float yScale = 1.0f / (slpFace->face->size->metrics.y_scale / 65536.0f);
+ const float xScale = 1.0f / (tizenFace->face->size->metrics.x_scale / 65536.0f);
+ const float yScale = 1.0f / (tizenFace->face->size->metrics.y_scale / 65536.0f);
- globalMetrics.lineHeight = slpFace->face->height * ONE_OVER_64;
- globalMetrics.ascender = slpFace->face->ascender * ONE_OVER_64;
- globalMetrics.unitsPerEM = slpFace->face->units_per_EM * ONE_OVER_64;
+ globalMetrics.lineHeight = tizenFace->face->height * ONE_OVER_64;
+ globalMetrics.ascender = tizenFace->face->ascender * ONE_OVER_64;
+ globalMetrics.unitsPerEM = tizenFace->face->units_per_EM * ONE_OVER_64;
globalMetrics.underlinePosition = -4.f;
globalMetrics.underlineThickness = 5.f * yScale;
globalMetrics.padAdjustX = DISTANCE_FIELD_PADDING * xScale;
globalMetrics.padAdjustY = DISTANCE_FIELD_PADDING * yScale;
- delete slpFace;
+ delete tizenFace;
}
}
}
Integration::BitmapPtr image;
const std::string& fontFileName = GetFontPath( fontFamily, fontStyle );
- SlpFace* slpFace = LoadFontFace( fontFileName, PixelSize( Font::PointsToPixels( fontSize ) ), freeType );
+ TizenFace* tizenFace = LoadFontFace( fontFileName, PixelSize( Font::PointsToPixels( fontSize ) ), freeType );
- if( NULL != slpFace )
+ if( NULL != tizenFace )
{
- image = GetGlyphBitmap( slpFace->face, character );
- delete slpFace;
+ image = GetGlyphBitmap( tizenFace->face, character );
+ delete tizenFace;
}
return image;
return mImpl->mFontController->GetFontPath(std::make_pair(fontFamily,fontStyle));
}
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#ifndef __DALI_SLP_PLATFORM_RESOURCE_LOADER_H__
-#define __DALI_SLP_PLATFORM_RESOURCE_LOADER_H__
+#ifndef __DALI_TIZEN_PLATFORM_RESOURCE_LOADER_H__
+#define __DALI_TIZEN_PLATFORM_RESOURCE_LOADER_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
class FontController;
}
-namespace SlpPlatform
+namespace TizenPlatform
{
/**
std::string& closestFontStyleMatch );
/**
- * @copydoc SlpPlatformAbstraction::GetFontLineHeightFromCapsHeight
+ * @copydoc TizenPlatformAbstraction::GetFontLineHeightFromCapsHeight
*/
PixelSize GetFontLineHeightFromCapsHeight(const std::string& fontFamily, const std::string& fontStyle, CapsHeight capsHeight, FT_Library freeType);
/**
- * @copydoc SlpPlatformAbstraction::GetFontList
+ * @copydoc TizenPlatformAbstraction::GetFontList
*/
void GetFontList( Dali::Integration::PlatformAbstraction::FontListMode mode, std::vector<std::string>& fontList );
/**
- * @copydoc SlpPlatformAbstraction::LoadFile()
+ * @copydoc TizenPlatformAbstraction::LoadFile()
*/
bool LoadFile( const std::string& filename, std::vector< unsigned char >& buffer ) const;
/**
- * @copydoc SlpPlatformAbstraction::LoadFile()
+ * @copydoc TizenPlatformAbstraction::LoadFile()
*/
std::string LoadFile(const std::string& filename) const;
/**
- * @copydoc SlpPlatformAbstraction::SaveFile()
+ * @copydoc TizenPlatformAbstraction::SaveFile()
*/
static bool SaveFile(const std::string& filename, std::vector< unsigned char >& buffer);
};
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLPPLATFORM_RESOURCE_LOADER_H_
+#endif // __DALI_TIZEN_PLATFORM_RESOURCE_LOADER_H_
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
/**
StubbedResourceLoadingClient& operator =( StubbedResourceLoadingClient& rhs );
};
-} /* namespace SlpPlatform */
+} /* namespace TizenPlatform */
} /* namespace Dali */
#endif /* _DALI_PLATFORM_RESOURCE_LOADING_CLIENT_H_ */
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
ResourceRequesterBase::ResourceRequesterBase( ResourceLoader& resourceLoader )
{
}
-} // Namespace SlpPlatform
+} // Namespace TizenPlatform
} // Namespace Dali
-#ifndef __DALI_SLP_PLATFORM_RESOURCE_REQUESTER_BASE_H__
-#define __DALI_SLP_PLATFORM_RESOURCE_REQUESTER_BASE_H__
+#ifndef __DALI_TIZEN_PLATFORM_RESOURCE_REQUESTER_BASE_H__
+#define __DALI_TIZEN_PLATFORM_RESOURCE_REQUESTER_BASE_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
*
*/
-#include <platform-abstractions/slp/resource-loader/resource-loader.h>
+#include <platform-abstractions/tizen/resource-loader/resource-loader.h>
#include <dali/integration-api/resource-request.h>
#include <dali/integration-api/resource-cache.h>
class ResourceRequest;
}
-namespace SlpPlatform
+namespace TizenPlatform
{
/**
ResourceRequesterBase& operator=(const ResourceRequesterBase& rhs );
};
-} // SlpPlatform
+} // TizenPlatform
} // Dali
-#endif // __DALI_SLP_PLATFORM_RESOURCE_REQUESTER_BASE_H__
+#endif // __DALI_TIZEN_PLATFORM_RESOURCE_REQUESTER_BASE_H__
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
ResourceShaderRequester::ResourceShaderRequester( ResourceLoader& resourceLoader )
mThreadShader->CancelRequest(id);
}
-} // SlpPlatform
+} // TizenPlatform
} // Dali
-#ifndef __DALI_SLP_PLATFORM_RESOURCE_SHADER_REQUESTER_H__
-#define __DALI_SLP_PLATFORM_RESOURCE_SHADER_REQUESTER_H__
+#ifndef __DALI_TIZEN_PLATFORM_RESOURCE_SHADER_REQUESTER_H__
+#define __DALI_TIZEN_PLATFORM_RESOURCE_SHADER_REQUESTER_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
/**
ResourceThreadShader* mThreadShader; ///< Thread to load requests
};
-} // SlpPlatform
+} // TizenPlatform
} // Dali
-#endif // __DALI_SLP_PLATFORM_RESOURCE_SHADER_REQUESTER_H__
+#endif // __DALI_TIZEN_PLATFORM_RESOURCE_SHADER_REQUESTER_H__
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace
}
}
-} // SlpPlatform
+} // TizenPlatform
} // Dali
-#ifndef __DALI_SLP_PLATFORM_RESOURCE_TEXT_REQUESTER_H__
-#define __DALI_SLP_PLATFORM_RESOURCE_TEXT_REQUESTER_H__
+#ifndef __DALI_TIZEN_PLATFORM_RESOURCE_TEXT_REQUESTER_H__
+#define __DALI_TIZEN_PLATFORM_RESOURCE_TEXT_REQUESTER_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
*
*/
-#include <platform-abstractions/slp/resource-loader/resource-requester-base.h>
+#include <platform-abstractions/tizen/resource-loader/resource-requester-base.h>
#include "resource-thread-text.h"
namespace Dali
class ResourceRequest;
}
-namespace SlpPlatform
+namespace TizenPlatform
{
class ResourceTextRequester : public ResourceRequesterBase
ResourceThreadText* mThreadText; ///< Loader thread
};
-} // SlpPlatform
+} // TizenPlatform
} // Dali
-#endif // __DALI_SLP_PLATFORM_RESOURCE_TEXT_REQUESTER_H__
+#endif // __DALI_TIZEN_PLATFORM_RESOURCE_TEXT_REQUESTER_H__
#include <dali/integration-api/debug.h>
#include "resource-thread-base.h"
-#include "slp-logging.h"
+#include "tizen-logging.h"
#include "atomics.h"
using namespace Dali::Integration;
const Integration::ResourceId NO_REQUEST_IN_FLIGHT = Integration::ResourceId(0) - 1;
const Integration::ResourceId NO_REQUEST_CANCELLED = Integration::ResourceId(0) - 2;
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace
void ResourceThreadBase::InstallLogging()
{
- // resource loading thread will send its logs to SLP Platform's LogMessage handler.
- Dali::Integration::Log::InstallLogFunction(Dali::SlpPlatform::LogMessage);
+ // resource loading thread will send its logs to TIZEN Platform's LogMessage handler.
+ Dali::Integration::Log::InstallLogFunction(Dali::TizenPlatform::LogMessage);
}
void ResourceThreadBase::UninstallLogging()
///! If you need this for a subclassed thread, look to ResourceThreadImage::Decode() for an example implementation.
}
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#ifndef __DALI_SLP_PLATFORM_RESOURCE_THREAD_BASE_H__
-#define __DALI_SLP_PLATFORM_RESOURCE_THREAD_BASE_H__
+#ifndef __DALI_TIZEN_PLATFORM_RESOURCE_THREAD_BASE_H__
+#define __DALI_TIZEN_PLATFORM_RESOURCE_THREAD_BASE_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
/**
#endif
}; // class ResourceThreadBase
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLPPLATFORM_RESOURCE_THREAD_BASE_H__
+#endif // __DALI_TIZEN_PLATFORM_RESOURCE_THREAD_BASE_H__
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
ResourceThreadImage::ResourceThreadImage(ResourceLoader& resourceLoader, bool forRemoteImage)
}
}
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#ifndef __DALI_SLP_PLATFORM_RESOURCE_THREAD_IMAGE_H__
-#define __DALI_SLP_PLATFORM_RESOURCE_THREAD_IMAGE_H__
+#ifndef __DALI_TIZEN_PLATFORM_RESOURCE_THREAD_IMAGE_H__
+#define __DALI_TIZEN_PLATFORM_RESOURCE_THREAD_IMAGE_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
class ResourceThreadImage : public ResourceThreadBase
void DecodeImageFromMemory(void* blobBytes, size_t blobSize, const Integration::ResourceRequest& request);
}; // class ResourceThreadImage
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLP_PLATFORM_RESOURCE_THREAD_IMAGE_H__
+#endif // __DALI_TIZEN_PLATFORM_RESOURCE_THREAD_IMAGE_H__
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
ResourceThreadShader::ResourceThreadShader(ResourceLoader& resourceLoader)
}
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#ifndef __DALI_SLP_PLATFORM_RESOURCE_THREAD_SHADER_H__
-#define __DALI_SLP_PLATFORM_RESOURCE_THREAD_SHADER_H__
+#ifndef __DALI_TIZEN_PLATFORM_RESOURCE_THREAD_SHADER_H__
+#define __DALI_TIZEN_PLATFORM_RESOURCE_THREAD_SHADER_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
}
}
-namespace SlpPlatform
+namespace TizenPlatform
{
class ResourceThreadShader : public ResourceThreadBase
}; // class ResourceThreadShader
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLP_PLATFORM_RESOURCE_THREAD_SHADER_H__
+#endif // __DALI_TIZEN_PLATFORM_RESOURCE_THREAD_SHADER_H__
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace
mDataCaches.clear();
}
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#ifndef __DALI_SLP_PLATFORM_RESOURCE_THREAD_TEXT_H__
-#define __DALI_SLP_PLATFORM_RESOURCE_THREAD_TEXT_H__
+#ifndef __DALI_TIZEN_PLATFORM_RESOURCE_THREAD_TEXT_H__
+#define __DALI_TIZEN_PLATFORM_RESOURCE_THREAD_TEXT_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
class DataCache;
}
-namespace SlpPlatform
+namespace TizenPlatform
{
/**
* Resource loader for glyph distance fields.
}; // class ResourceThreadText
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLP_PLATFORM_RESOURCE_THREAD_TEXT_H__
+#endif // __DALI_TIZEN_PLATFORM_RESOURCE_THREAD_TEXT_H__
*
*/
-#include "slp-font-configuration-parser.h"
+#include "tizen-font-configuration-parser.h"
#include <sstream>
#include <libxml/xmlmemory.h>
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace FontConfigurationParser
#if defined(DEBUG_ENABLED)
namespace
{
-Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_SLP_FONT_CONFIGURATION_PARSER");
+Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_TIZEN_FONT_CONFIGURATION_PARSER");
}
#endif
} // namespace FontConfParser
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#ifndef __DALI_SLP_PLATFORM_FONT_CONFIGURATION_PARSER_H__
-#define __DALI_SLP_PLATFORM_FONT_CONFIGURATION_PARSER_H__
+#ifndef __DALI_TIZEN_PLATFORM_FONT_CONFIGURATION_PARSER_H__
+#define __DALI_TIZEN_PLATFORM_FONT_CONFIGURATION_PARSER_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace FontConfigurationParser
} // namespace FontConfParser
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLP_PLATFORM_FONT_CONFIGURATION_PARSER_H__
+#endif // __DALI_TIZEN_PLATFORM_FONT_CONFIGURATION_PARSER_H__
*/
// FUNCTION HEADER
-#include "slp-logging.h"
+#include "tizen-logging.h"
// EXTERNAL INCLUDES
#ifndef DALI_PROFILE_UBUNTU
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
void LogMessage(Dali::Integration::Log::DebugPriority level, std::string& message)
#endif // DALI_PROFILE_UBUNTU
}
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#ifndef __DALI_SLP_LOGGING_H__
-#define __DALI_SLP_LOGGING_H__
+#ifndef __DALI_TIZEN_LOGGING_H__
+#define __DALI_TIZEN_LOGGING_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
namespace Dali
{
-namespace SlpPlatform
+namespace TizenPlatform
{
/**
*/
void LogMessage(Dali::Integration::Log::DebugPriority level, std::string& message);
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLP_LOGGING_H__
+#endif // __DALI_TIZEN_LOGGING_H__
*
*/
-#include "slp-platform-abstraction.h"
+#include "tizen-platform-abstraction.h"
#ifndef DALI_PROFILE_UBUNTU
#include <vconf.h>
#include "resource-loader/resource-loader.h"
#include "dynamics/dynamics-factory.h"
-#include "slp-font-configuration-parser.h"
+#include "tizen-font-configuration-parser.h"
#include "data-cache/metrics-cache.h"
#include "image-loaders/image-loader.h"
Integration::PlatformAbstraction* CreatePlatformAbstraction()
{
- return new SlpPlatform::SlpPlatformAbstraction();
+ return new TizenPlatform::TizenPlatformAbstraction();
}
-namespace SlpPlatform
+namespace TizenPlatform
{
namespace
};
}
-SlpPlatformAbstraction::SlpPlatformAbstraction()
+TizenPlatformAbstraction::TizenPlatformAbstraction()
: mResourceLoader(new ResourceLoader),
mDynamicsFactory(NULL),
mDataStoragePath( "" ),
UpdateDefaultsFromDevice();
}
-SlpPlatformAbstraction::~SlpPlatformAbstraction()
+TizenPlatformAbstraction::~TizenPlatformAbstraction()
{
delete mResourceLoader;
delete mDynamicsFactory;
}
}
-void SlpPlatformAbstraction::GetTimeMicroseconds(unsigned int &seconds, unsigned int µSeconds)
+void TizenPlatformAbstraction::GetTimeMicroseconds(unsigned int &seconds, unsigned int µSeconds)
{
timespec time;
clock_gettime(CLOCK_MONOTONIC, &time);
microSeconds = time.tv_nsec / NANOSECS_TO_MICROSECS;
}
-void SlpPlatformAbstraction::Suspend()
+void TizenPlatformAbstraction::Suspend()
{
if (mResourceLoader)
{
}
}
-void SlpPlatformAbstraction::Resume()
+void TizenPlatformAbstraction::Resume()
{
if (mResourceLoader)
{
}
}
-const std::string& SlpPlatformAbstraction::GetDefaultFontFamily() const
+const std::string& TizenPlatformAbstraction::GetDefaultFontFamily() const
{
// VCC TODO: return default font style as well.
return mDefaultFontFamily;
}
-float SlpPlatformAbstraction::GetDefaultFontSize() const
+float TizenPlatformAbstraction::GetDefaultFontSize() const
{
return mDefaultFontSize;
}
-PixelSize SlpPlatformAbstraction::GetFontLineHeightFromCapsHeight(const std::string& fontFamily, const std::string& fontStyle, CapsHeight capsHeight) const
+PixelSize TizenPlatformAbstraction::GetFontLineHeightFromCapsHeight(const std::string& fontFamily, const std::string& fontStyle, CapsHeight capsHeight) const
{
PixelSize result(0);
return result;
}
-Integration::GlyphSet* SlpPlatformAbstraction::GetGlyphData ( const Dali::Integration::TextResourceType& textRequest,
+Integration::GlyphSet* TizenPlatformAbstraction::GetGlyphData ( const Dali::Integration::TextResourceType& textRequest,
const std::string& fontFamily,
bool getBitmap) const
{
return NULL;
}
-Integration::GlyphSet* SlpPlatformAbstraction::GetCachedGlyphData( const Integration::TextResourceType& textRequest,
+Integration::GlyphSet* TizenPlatformAbstraction::GetCachedGlyphData( const Integration::TextResourceType& textRequest,
const std::string& fontFamily ) const
{
if (mResourceLoader)
}
-void SlpPlatformAbstraction::GetGlobalMetrics( const std::string& fontFamily, const std::string& fontStyle, Integration::GlobalMetrics& globalMetrics ) const
+void TizenPlatformAbstraction::GetGlobalMetrics( const std::string& fontFamily, const std::string& fontStyle, Integration::GlobalMetrics& globalMetrics ) const
{
if( mResourceLoader )
{
}
}
-void SlpPlatformAbstraction::GetClosestImageSize( const std::string& filename,
+void TizenPlatformAbstraction::GetClosestImageSize( const std::string& filename,
const ImageAttributes& attributes,
Vector2& closestSize )
{
ImageLoader::GetClosestImageSize(filename, attributes, closestSize );
}
-void SlpPlatformAbstraction::GetClosestImageSize( Integration::ResourcePointer resourceBuffer,
+void TizenPlatformAbstraction::GetClosestImageSize( Integration::ResourcePointer resourceBuffer,
const ImageAttributes& attributes,
Vector2& closestSize )
{
}
-void SlpPlatformAbstraction::LoadResource(const Integration::ResourceRequest& request)
+void TizenPlatformAbstraction::LoadResource(const Integration::ResourceRequest& request)
{
if (mResourceLoader)
{
}
}
-Integration::ResourcePointer SlpPlatformAbstraction::LoadResourceSynchronously(const Integration::ResourceType& resourceType, const std::string& resourcePath)
+Integration::ResourcePointer TizenPlatformAbstraction::LoadResourceSynchronously(const Integration::ResourceType& resourceType, const std::string& resourcePath)
{
return ImageLoader::LoadResourceSynchronously( resourceType, resourcePath );
}
-void SlpPlatformAbstraction::SaveResource(const Integration::ResourceRequest& request)
+void TizenPlatformAbstraction::SaveResource(const Integration::ResourceRequest& request)
{
if (mResourceLoader)
{
}
}
-void SlpPlatformAbstraction::CancelLoad(Integration::ResourceId id, Integration::ResourceTypeId typeId)
+void TizenPlatformAbstraction::CancelLoad(Integration::ResourceId id, Integration::ResourceTypeId typeId)
{
if (mResourceLoader)
{
}
}
-bool SlpPlatformAbstraction::IsLoading()
+bool TizenPlatformAbstraction::IsLoading()
{
if (mResourceLoader)
{
return false;
}
-void SlpPlatformAbstraction::GetResources(Integration::ResourceCache& cache)
+void TizenPlatformAbstraction::GetResources(Integration::ResourceCache& cache)
{
if (mResourceLoader)
{
}
}
-void SlpPlatformAbstraction::SetDpi(unsigned int dpiHor, unsigned int dpiVer)
+void TizenPlatformAbstraction::SetDpi(unsigned int dpiHor, unsigned int dpiVer)
{
if (mResourceLoader)
{
}
}
-const std::string& SlpPlatformAbstraction::GetFontFamilyForChars(const Integration::TextArray& charsRequested) const
+const std::string& TizenPlatformAbstraction::GetFontFamilyForChars(const Integration::TextArray& charsRequested) const
{
if( mResourceLoader )
{
return NULL_FONT_FAMILY_NAME;
}
-bool SlpPlatformAbstraction::AllGlyphsSupported(const std::string &fontFamily, const std::string& fontStyle, const Integration::TextArray& charsRequested) const
+bool TizenPlatformAbstraction::AllGlyphsSupported(const std::string &fontFamily, const std::string& fontStyle, const Integration::TextArray& charsRequested) const
{
bool ret = false;
if (mResourceLoader)
return ret;
}
-bool SlpPlatformAbstraction::ValidateFontFamilyName(const std::string& fontFamily, const std::string& fontStyle, bool& isDefaultSystemFont, std::string& closestMatch, std::string& closestStyleMatch) const
+bool TizenPlatformAbstraction::ValidateFontFamilyName(const std::string& fontFamily, const std::string& fontStyle, bool& isDefaultSystemFont, std::string& closestMatch, std::string& closestStyleMatch) const
{
bool ret = false;
if( mResourceLoader )
return ret;
}
-void SlpPlatformAbstraction::GetFontList( Dali::Integration::PlatformAbstraction::FontListMode mode, std::vector<std::string>& fontList ) const
+void TizenPlatformAbstraction::GetFontList( Dali::Integration::PlatformAbstraction::FontListMode mode, std::vector<std::string>& fontList ) const
{
if( mResourceLoader )
{
}
}
-bool SlpPlatformAbstraction::LoadFile( const std::string& filename, std::vector< unsigned char >& buffer ) const
+bool TizenPlatformAbstraction::LoadFile( const std::string& filename, std::vector< unsigned char >& buffer ) const
{
bool result = false;
return result;
}
-std::string SlpPlatformAbstraction::LoadFile( const std::string& filename )
+std::string TizenPlatformAbstraction::LoadFile( const std::string& filename )
{
std::string result;
if (mResourceLoader)
return result;
}
-bool SlpPlatformAbstraction::SaveFile(const std::string& filename, std::vector< unsigned char >& buffer) const
+bool TizenPlatformAbstraction::SaveFile(const std::string& filename, std::vector< unsigned char >& buffer) const
{
bool result = false;
return result;
}
-void SlpPlatformAbstraction::JoinLoaderThreads()
+void TizenPlatformAbstraction::JoinLoaderThreads()
{
delete mResourceLoader;
mResourceLoader = NULL;
}
-void SlpPlatformAbstraction::UpdateDefaultsFromDevice()
+void TizenPlatformAbstraction::UpdateDefaultsFromDevice()
{
// FontConfigurationParser::Parse sets the default font family and the default font style.
// If the isn't a configuration file or is invalid, or it doesn't have any tag with the default
mDefaultFontSize = FONT_SIZE_TABLE[fontSize];
}
-Integration::DynamicsFactory* SlpPlatformAbstraction::GetDynamicsFactory()
+Integration::DynamicsFactory* TizenPlatformAbstraction::GetDynamicsFactory()
{
if( NULL == mDynamicsFactory )
{
return mDynamicsFactory;
}
-bool SlpPlatformAbstraction::ReadGlobalMetricsFromCache( const std::string& fontFamily,
+bool TizenPlatformAbstraction::ReadGlobalMetricsFromCache( const std::string& fontFamily,
const std::string& fontStyle,
Integration::GlobalMetrics& globalMetrics )
{
return MetricsCache::ReadGlobal( fontFamily, fontStyle, globalMetrics );
}
-void SlpPlatformAbstraction::WriteGlobalMetricsToCache( const std::string& fontFamily,
+void TizenPlatformAbstraction::WriteGlobalMetricsToCache( const std::string& fontFamily,
const std::string& fontStyle,
const Integration::GlobalMetrics& globalMetrics )
{
MetricsCache::WriteGlobal( fontFamily, fontStyle, globalMetrics);
}
-bool SlpPlatformAbstraction::ReadMetricsFromCache( const std::string& fontFamily,
+bool TizenPlatformAbstraction::ReadMetricsFromCache( const std::string& fontFamily,
const std::string& fontStyle,
std::vector<Integration::GlyphMetrics>& glyphMetricsContainer )
{
return MetricsCache::Read( fontFamily, fontStyle, glyphMetricsContainer );
}
-void SlpPlatformAbstraction::WriteMetricsToCache( const std::string& fontFamily,
+void TizenPlatformAbstraction::WriteMetricsToCache( const std::string& fontFamily,
const std::string& fontStyle,
const Integration::GlyphSet& glyphSet )
{
MetricsCache::Write( fontFamily, fontStyle, glyphSet );
}
-void SlpPlatformAbstraction::GetFileNamesFromDirectory( const std::string& directoryName,
+void TizenPlatformAbstraction::GetFileNamesFromDirectory( const std::string& directoryName,
std::vector<std::string>& fileNames )
{
dirent* de = NULL;
}
}
-Integration::BitmapPtr SlpPlatformAbstraction::GetGlyphImage( const std::string& fontFamily, const std::string& fontStyle, const float fontSize, const uint32_t character ) const
+Integration::BitmapPtr TizenPlatformAbstraction::GetGlyphImage( const std::string& fontFamily, const std::string& fontStyle, const float fontSize, const uint32_t character ) const
{
Integration::BitmapPtr glyphImage;
return glyphImage;
}
-bool SlpPlatformAbstraction::LoadShaderBinFile( const std::string& filename, std::vector< unsigned char >& buffer ) const
+bool TizenPlatformAbstraction::LoadShaderBinFile( const std::string& filename, std::vector< unsigned char >& buffer ) const
{
bool result = false;
return result;
}
-void SlpPlatformAbstraction::SetDataStoragePath( const std::string& path )
+void TizenPlatformAbstraction::SetDataStoragePath( const std::string& path )
{
mDataStoragePath = path;
}
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#ifndef __DALI_SLP_PLATFORM_ABSTRACTION_H__
-#define __DALI_SLP_PLATFORM_ABSTRACTION_H__
+#ifndef __DALI_TIZEN_PLATFORM_ABSTRACTION_H__
+#define __DALI_TIZEN_PLATFORM_ABSTRACTION_H__
/*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
*/
Integration::PlatformAbstraction* CreatePlatformAbstraction();
-namespace SlpPlatform
+namespace TizenPlatform
{
class DynamicsFactory;
/**
* Concrete implementation of the platform abstraction class.
*/
-class SlpPlatformAbstraction : public Integration::PlatformAbstraction
+class TizenPlatformAbstraction : public Integration::PlatformAbstraction
{
public: // Construction & Destruction
/**
* Constructor
*/
- SlpPlatformAbstraction();
+ TizenPlatformAbstraction();
/**
* Destructor
*/
- virtual ~SlpPlatformAbstraction();
+ virtual ~TizenPlatformAbstraction();
public: // PlatformAbstraction overrides
float mDefaultFontSize;
};
-} // namespace SlpPlatform
+} // namespace TizenPlatform
} // namespace Dali
-#endif // __DALI_SLP_PLATFORM_ABSTRACTION_H__
+#endif // __DALI_TIZEN_PLATFORM_ABSTRACTION_H__
projects / platform / core / uifw / dali-adaptor.git / commitdiff