apply FSL(Flora Software License)

9 files changed, 1868 insertions, 0 deletions

diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
new file mode 100755
index 0000000..fca8475
--- /dev/null
+++ b/common/CMakeLists.txt
@@ -0,0 +1,40 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+PROJECT(ivug_common C CXX)
+
+SET(PREFIX ${CMAKE_INSTALL_PREFIX})
+SET(VERSION 0.1.0)
+
+SET(SRCS
+	src/ivug-mouse-event.c
+	src/debug.c
+	src/statistics.c
+)
+
+INCLUDE_DIRECTORIES(
+	${CMAKE_CURRENT_SOURCE_DIR}
+	${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+
+INCLUDE(FindPkgConfig)
+pkg_check_modules(commonpkgs REQUIRED
+	elementary
+	evas
+	ui-gadget
+	dlog
+)
+
+FOREACH(flag ${commonpkgs_CFLAGS})
+	SET(EXTRA_CXXFLAGS "${EXTRA_CXXFLAGS} ${flag}")
+ENDFOREACH(flag)
+
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXXFLAGS} -Wall")
+SET(CMAKE_C_FLAGS ${CMAKE_CXX_FLAGS})
+
+ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"")
+
+ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS})
+SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES SOVERSION ${VERSION} )
+TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${commonpkgs_LDFLAGS} -lm )
+
+INSTALL(TARGETS ${PROJECT_NAME} DESTINATION lib)
+
diff --git a/common/NOTICE b/common/NOTICE
new file mode 100755
index 0000000..ded3804
--- /dev/null
+++ b/common/NOTICE
@@ -0,0 +1 @@
+Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
\ No newline at end of file
diff --git a/common/include/debug.h b/common/include/debug.h
new file mode 100755
index 0000000..4f6bf64
--- /dev/null
+++ b/common/include/debug.h
@@ -0,0 +1,240 @@
+/*
+ * Copyright 2012  Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	  http://www.tizenopensource.org/license
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#ifndef __ELM_MYPHOTOCAM_DEBUG_H__
+#define __ELM_MYPHOTOCAM_DEBUG_H__
+
+#include <assert.h>
+
+
+/*
+	Category :
+		FATAL
+		ERROR
+		WARN
+		HIGH
+		MED
+		LOW
+		DEBUG
+*/
+
+
+enum
+{
+	DBG_MSG_LOW    	= 0,
+	DBG_MSG_MED 		= 1,
+	DBG_MSG_HIGH		= 2,
+
+	DBG_MSG_WARN		= 3,
+	DBG_MSG_ERROR		= 4,
+	DBG_MSG_FATAL		= 5,
+
+	DBG_MSG_CUST5		= 6,
+	DBG_MSG_CUST6		= 7,
+	DBG_MSG_CUST7		= 8,
+	DBG_MSG_CUST8		= 9,
+	DBG_MSG_CUST9		= 10,
+	DBG_MSG_CUST10	= 11,
+	DBG_MSG_CUST11	= 12,
+	DBG_MSG_CUST12	= 13,
+	DBG_MSG_CUST13	= 14,
+};
+
+
+// level
+enum
+{
+	DBG_MSG_BIT_LOW 		= (1<<DBG_MSG_LOW),
+	DBG_MSG_BIT_MED 		= (1<<DBG_MSG_MED),
+	DBG_MSG_BIT_HIGH		= (1<<DBG_MSG_HIGH),
+	DBG_MSG_BIT_WARN		= (1<<DBG_MSG_WARN),
+	DBG_MSG_BIT_ERROR		= (1<<DBG_MSG_ERROR),
+	DBG_MSG_BIT_FATAL		= (1<<DBG_MSG_FATAL),
+
+	DBG_MSG_BIT_CUST5		= (1<<DBG_MSG_CUST5),
+	DBG_MSG_BIT_CUST6		= (1<<DBG_MSG_CUST6),
+	DBG_MSG_BIT_CUST7		= (1<<DBG_MSG_CUST7),
+	DBG_MSG_BIT_CUST8		= (1<<DBG_MSG_CUST8),
+	DBG_MSG_BIT_CUST9		= (1<<DBG_MSG_CUST9),
+	DBG_MSG_BIT_CUST10	= (1<<DBG_MSG_CUST10),
+	DBG_MSG_BIT_CUST11	= (1<<DBG_MSG_CUST11),
+	DBG_MSG_BIT_CUST12	= (1<<DBG_MSG_CUST12),
+	DBG_MSG_BIT_CUST13	= (1<<DBG_MSG_CUST13),
+};
+
+#define DBG_MSG_LVL_DEBUG 		(DBG_MSG_BIT_CUST13)
+
+#define DBG_MSG_LVL_ALL			(DBG_MSG_LVL_LOW)
+
+#define DBG_MSG_LVL_FATAL		(DBG_MSG_BIT_FATAL)
+#define DBG_MSG_LVL_ERROR		(DBG_MSG_LVL_FATAL	| DBG_MSG_BIT_ERROR)
+#define DBG_MSG_LVL_WARN		(DBG_MSG_LVL_ERROR	| DBG_MSG_BIT_WARN)
+#define DBG_MSG_LVL_HIGH		(DBG_MSG_LVL_WARN	| DBG_MSG_BIT_HIGH)
+#define DBG_MSG_LVL_MED		(DBG_MSG_LVL_HIGH	| DBG_MSG_BIT_MED)
+#define DBG_MSG_LVL_LOW		(DBG_MSG_LVL_MED	| DBG_MSG_BIT_LOW)
+#define DBG_MSG_LVL_NONE		(0)
+
+
+// Get time of day
+#include <sys/time.h>
+#include <unistd.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Time analyzer
+#define DEFINE_PERFORM_TIME(aa) long aa = 0; struct timeval tv
+
+#define BEGIN_PERFORM_TIME(aa) \
+	{ \
+		gettimeofday(&tv, NULL); \
+		aa = tv.tv_sec * 1000 + tv.tv_usec / 1000; \
+	} while(0)
+
+#define END_PERFORM_TIME(aa) \
+	{  \
+		gettimeofday(&tv, NULL);  \
+		aa = ( tv.tv_sec * 1000 + tv.tv_usec / 1000 ) - aa; \
+	} while(0)
+
+// TODO : Need align(1)
+typedef struct {
+	const char *fname;
+	int nline;
+	const char *szcategory;
+	int msg_level;
+	const char *szlevel;
+	unsigned long time;
+} debug_msg_type;
+
+void _custom_debug_msg(debug_msg_type *debug_msg, const char *msg, ...);
+
+/* coverity[+kill] */
+#define __MSG_FATAL(level, szCat,  ...)	\
+	do { \
+		if ((level) & DBG_MSG_BIT_FATAL) \
+		{ \
+			static debug_msg_type msg______unique______name___ = {		\
+				__FILE__,							\
+				__LINE__,							\
+				szCat,								\
+				DBG_MSG_FATAL,					\
+				"FATAL", \
+			};									\
+			_custom_debug_msg(&msg______unique______name___, ##__VA_ARGS__); \
+		} \
+	} while(0)
+
+#define __MSG_ERROR(level, szCat,  ...)	\
+	do { \
+		if ((level) & DBG_MSG_BIT_ERROR)  \
+		{ \
+			static debug_msg_type msg______unique______name___ = {		\
+				__FILE__,							\
+				__LINE__,							\
+				szCat,								\
+				DBG_MSG_ERROR,					\
+				"ERROR", \
+			};									\
+			_custom_debug_msg(&msg______unique______name___, ##__VA_ARGS__); \
+		} \
+	} while(0)
+
+
+#define __MSG_WARN(level, szCat, ...)	\
+	do { \
+		if ((level) & DBG_MSG_BIT_WARN)  \
+		{ \
+			static debug_msg_type msg______unique______name___ = {		\
+				__FILE__,							\
+				__LINE__,							\
+				szCat,							\
+				DBG_MSG_WARN,					\
+				"WARN", \
+			};									\
+			_custom_debug_msg(&msg______unique______name___, ##__VA_ARGS__); \
+		} \
+	} while(0)
+
+#define __MSG_HIGH(level, szCat, ...)	\
+	do { \
+		if ((level) & DBG_MSG_BIT_HIGH) \
+		{ \
+			static debug_msg_type msg______unique______name___ = {		\
+				__FILE__,							\
+				__LINE__,							\
+				szCat,							\
+				DBG_MSG_HIGH,					\
+				"HIGH", \
+			};									\
+			_custom_debug_msg(&msg______unique______name___, ##__VA_ARGS__); \
+		} \
+	} while(0)
+
+#define __MSG_MED(level, szCat,  ...)	\
+	do { \
+		if ((level) & DBG_MSG_BIT_MED) \
+		{ \
+			static debug_msg_type msg______unique______name___ = {		\
+				__FILE__,							\
+				__LINE__,							\
+				szCat,							\
+				DBG_MSG_MED,					\
+				"MED", \
+			};									\
+			_custom_debug_msg(&msg______unique______name___, ##__VA_ARGS__); \
+		} \
+	} while(0)
+
+
+#define __MSG_LOW(level, szCat,  ...)	\
+	do { \
+		if ((level) & DBG_MSG_BIT_LOW) \
+		{ \
+			static debug_msg_type msg______unique______name___ = {		\
+				__FILE__,							\
+				__LINE__,							\
+				szCat,								\
+				DBG_MSG_LOW,					\
+				"LOW", \
+			};									\
+			_custom_debug_msg(&msg______unique______name___, ##__VA_ARGS__); \
+		} \
+	} while(0)
+
+
+#define ASSERT(level, szCat, expr) \
+	do { \
+		if( !(expr) )					\
+		{							\
+			__MSG_FATAL(level, szCat, "[%s] ASSERT : " #expr , __func__ );	\
+		} \
+	} while(0)
+
+#define NEVER_GET_HERE(level, szCat) \
+	do { \
+		__MSG_FATAL(level, szCat, "NeverGetHere : %s(%d)", __func__, __LINE__);	\
+	} while(0)
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif 		// __ELM_MYPHOTOCAM_DEBUG_H__
+
diff --git a/common/include/ivug-debug.h b/common/include/ivug-debug.h
new file mode 100755
index 0000000..fae7537
--- /dev/null
+++ b/common/include/ivug-debug.h
@@ -0,0 +1,251 @@
+/*
+ * Copyright 2012  Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	  http://www.tizenopensource.org/license
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#ifndef _IVUG_DEBUG_H_
+#define _IVUG_DEBUG_H_
+
+#include <dlog.h>
+
+#define IVUG_LOG_OUTPUT_DLOG
+
+enum {
+	IVUG_MSG_COLOR_DEFAULT	= 0,
+	IVUG_MSG_COLOR_BLACK	= 30,
+	IVUG_MSG_COLOR_RED		= 31,
+	IVUG_MSG_COLOR_GREEN	= 32,
+	IVUG_MSG_COLOR_YELLOW	= 33,
+	IVUG_MSG_COLOR_BLUE		= 34,
+	IVUG_MSG_COLOR_MAGENTA	= 35,
+	IVUG_MSG_COLOR_CYAN		= 36,
+	IVUG_MSG_COLOR_WHITE		= 37,
+};
+
+#ifdef IVUG_LOG_OUTPUT_DLOG
+
+#undef LOG_TAG
+#define LOG_TAG "IV-COMMON"
+
+#define IVUG_DEBUG_MSG(fmt, arg...)			LOGD("[%s : %05d]" fmt "\n", __func__, __LINE__, ##arg)
+#define IVUG_DEBUG_WARNING(fmt, arg...)		LOGW("[%s : %05d]" fmt "\n", __func__, __LINE__, ##arg)
+#define IVUG_DEBUG_ERROR(fmt, arg...)		LOGE("[%s : %05d]" fmt "\n", __func__, __LINE__ , ##arg)
+#define IVUG_DEBUG_CRITICAL(fmt, arg...)	LOGE("[%s : %05d]" fmt "\n", __func__, __LINE__ , ##arg)
+
+#else	//USE_DLOG
+#define IVUG_DEBUG_MSG(fmt, arg...)			fprintf(stdout, "[D: %s : %05d]" fmt "\n", __func__, __LINE__, ##arg)
+#define IVUG_DEBUG_WARNING(fmt, arg...)		fprintf(stdout, "[W: %s : %05d]" fmt "\n", __func__, __LINE__, ##arg)
+#define IVUG_DEBUG_ERROR(fmt, arg...)		fprintf(stdout, "[E: %s : %05d]" fmt "\n", __func__, __LINE__ , ##arg)
+#define IVUG_DEBUG_CRITICAL(fmt, arg...)		fprintf(stdout, "[E: %s : %05d]" fmt "\n", __func__, __LINE__ , ##arg)
+#define IVUG_DEBUG_PRINT(fmt,arg...)			fprintf(stdout, "[%s : %05d] >>> leave \n", __func__, __LINE__ , ##arg)
+
+#endif //IVUG_LOG_OUTPUT_DLOG
+
+/*
+	How to add new Category..
+
+	TODO:
+*/
+
+#define MSG_MOUSE_SZCAT "IV-MOUSE"
+#define LVL_MOUSE DBG_MSG_LVL_HIGH
+
+#define MSG_MOUSE_FATAL(...) 	__MSG_FATAL(LVL_MOUSE, MSG_MOUSE_SZCAT, ##__VA_ARGS__)
+#define MSG_MOUSE_ERROR(...)	__MSG_ERROR(LVL_MOUSE, MSG_MOUSE_SZCAT, ##__VA_ARGS__)
+#define MSG_MOUSE_WARN(...)		__MSG_WARN(LVL_MOUSE, MSG_MOUSE_SZCAT, ##__VA_ARGS__)
+#define MSG_MOUSE_HIGH(...)		__MSG_HIGH(LVL_MOUSE, MSG_MOUSE_SZCAT, ##__VA_ARGS__)
+#define MSG_MOUSE_MED(...)		__MSG_MED(LVL_MOUSE, MSG_MOUSE_SZCAT, ##__VA_ARGS__)
+#define MSG_MOUSE_LOW(...)		__MSG_LOW(LVL_MOUSE, MSG_MOUSE_SZCAT, ##__VA_ARGS__)
+
+
+#define SLIDER_ITEM_SZ "IV-SITEM"
+#define LVL_SLIDER_ITEM DBG_MSG_LVL_HIGH
+
+
+#define MSG_SITEM_FATAL(...) 		__MSG_FATAL(LVL_SLIDER_ITEM, SLIDER_ITEM_SZ, ##__VA_ARGS__)
+#define MSG_SITEM_ERROR(...)		__MSG_ERROR(LVL_SLIDER_ITEM, SLIDER_ITEM_SZ, ##__VA_ARGS__)
+#define MSG_SITEM_WARN(...)		__MSG_WARN(LVL_SLIDER_ITEM, SLIDER_ITEM_SZ, ##__VA_ARGS__)
+#define MSG_SITEM_HIGH(...)		__MSG_HIGH(LVL_SLIDER_ITEM, SLIDER_ITEM_SZ, ##__VA_ARGS__)
+#define MSG_SITEM_MED(...)		__MSG_MED(LVL_SLIDER_ITEM, SLIDER_ITEM_SZ, ##__VA_ARGS__)
+#define MSG_SITEM_LOW(...)		__MSG_LOW(LVL_SLIDER_ITEM, SLIDER_ITEM_SZ, ##__VA_ARGS__)
+
+
+#define SLIDER_SZ "IV-SLIDER"
+#define LVL_SLIDER DBG_MSG_LVL_HIGH
+
+#define MSG_SLIDER_FATAL(...) 		__MSG_FATAL(LVL_SLIDER, SLIDER_SZ, ##__VA_ARGS__)
+#define MSG_SLIDER_ERROR(...)		__MSG_ERROR(LVL_SLIDER, SLIDER_SZ, ##__VA_ARGS__)
+#define MSG_SLIDER_WARN(...)		__MSG_WARN(LVL_SLIDER, SLIDER_SZ, ##__VA_ARGS__)
+#define MSG_SLIDER_HIGH(...)		__MSG_HIGH(LVL_SLIDER, SLIDER_SZ, ##__VA_ARGS__)
+#define MSG_SLIDER_MED(...)		__MSG_MED(LVL_SLIDER, SLIDER_SZ, ##__VA_ARGS__)
+#define MSG_SLIDER_LOW(...)		__MSG_LOW(LVL_SLIDER, SLIDER_SZ, ##__VA_ARGS__)
+
+#define SETAS_SZ "IV-SETAS"
+#define LVL_SETAS DBG_MSG_LVL_HIGH
+
+#define MSG_SETAS_FATAL(...) 		__MSG_FATAL(LVL_SETAS, SETAS_SZ, ##__VA_ARGS__)
+#define MSG_SETAS_ERROR(...)		__MSG_ERROR(LVL_SETAS, SETAS_SZ, ##__VA_ARGS__)
+#define MSG_SETAS_WARN(...)			__MSG_WARN(LVL_SETAS, SETAS_SZ, ##__VA_ARGS__)
+#define MSG_SETAS_HIGH(...)			__MSG_HIGH(LVL_SETAS, SETAS_SZ, ##__VA_ARGS__)
+#define MSG_SETAS_MED(...)			__MSG_MED(LVL_SETAS, SETAS_SZ, ##__VA_ARGS__)
+#define MSG_SETAS_LOW(...)			__MSG_LOW(LVL_SETAS, SETAS_SZ, ##__VA_ARGS__)
+
+#define DETAIL_SZ "IV-DETAIL"
+#define LVL_DETAIL DBG_MSG_LVL_MED
+
+#define MSG_DETAIL_FATAL(...) 		__MSG_FATAL(LVL_DETAIL, DETAIL_SZ, ##__VA_ARGS__)
+#define MSG_DETAIL_ERROR(...)		__MSG_ERROR(LVL_DETAIL, DETAIL_SZ, ##__VA_ARGS__)
+#define MSG_DETAIL_WARN(...)		__MSG_WARN(LVL_DETAIL, DETAIL_SZ, ##__VA_ARGS__)
+#define MSG_DETAIL_HIGH(...)		__MSG_HIGH(LVL_DETAIL, DETAIL_SZ, ##__VA_ARGS__)
+#define MSG_DETAIL_MED(...)			__MSG_MED(LVL_DETAIL, DETAIL_SZ, ##__VA_ARGS__)
+#define MSG_DETAIL_LOW(...)			__MSG_LOW(LVL_DETAIL, DETAIL_SZ, ##__VA_ARGS__)
+
+#define SDATA_SZ "IV-SDATA"
+#define LVL_SDATA DBG_MSG_LVL_HIGH
+
+#define MSG_SDATA_FATAL(...) 		__MSG_FATAL(LVL_SDATA, SDATA_SZ, ##__VA_ARGS__)
+#define MSG_SDATA_ERROR(...)		__MSG_ERROR(LVL_SDATA, SDATA_SZ, ##__VA_ARGS__)
+#define MSG_SDATA_WARN(...)			__MSG_WARN(LVL_SDATA, SDATA_SZ, ##__VA_ARGS__)
+#define MSG_SDATA_HIGH(...)			__MSG_HIGH(LVL_SDATA, SDATA_SZ, ##__VA_ARGS__)
+#define MSG_SDATA_MED(...)			__MSG_MED(LVL_SDATA, SDATA_SZ, ##__VA_ARGS__)
+#define MSG_SDATA_LOW(...)			__MSG_LOW(LVL_SDATA, SDATA_SZ, ##__VA_ARGS__)
+
+
+#define IVCOMMON_SZ "IV-COMMON"
+#define LVL_IVCOMMON DBG_MSG_LVL_HIGH
+
+#define MSG_IMAGEVIEW_FATAL(...) 		__MSG_FATAL(LVL_IVCOMMON, IVCOMMON_SZ, ##__VA_ARGS__)
+#define MSG_IMAGEVIEW_ERROR(...)		__MSG_ERROR(LVL_IVCOMMON, IVCOMMON_SZ, ##__VA_ARGS__)
+#define MSG_IMAGEVIEW_WARN(...)			__MSG_WARN(LVL_IVCOMMON, IVCOMMON_SZ, ##__VA_ARGS__)
+#define MSG_IMAGEVIEW_HIGH(...)			__MSG_HIGH(LVL_IVCOMMON, IVCOMMON_SZ, ##__VA_ARGS__)
+#define MSG_IMAGEVIEW_MED(...)			__MSG_MED(LVL_IVCOMMON, IVCOMMON_SZ, ##__VA_ARGS__)
+#define MSG_IMAGEVIEW_LOW(...)			__MSG_LOW(LVL_IVCOMMON, IVCOMMON_SZ, ##__VA_ARGS__)
+
+#define MAINVIEW_SZ "IV-MAIN"
+#define LVL_MAINVIEW DBG_MSG_LVL_HIGH
+
+#define MSG_MAIN_FATAL(...) 		__MSG_FATAL(LVL_MAINVIEW, MAINVIEW_SZ, ##__VA_ARGS__)
+#define MSG_MAIN_ERROR(...)		__MSG_ERROR(LVL_MAINVIEW, MAINVIEW_SZ, ##__VA_ARGS__)
+#define MSG_MAIN_WARN(...)			__MSG_WARN(LVL_MAINVIEW, MAINVIEW_SZ, ##__VA_ARGS__)
+#define MSG_MAIN_HIGH(...)			__MSG_HIGH(LVL_MAINVIEW, MAINVIEW_SZ, ##__VA_ARGS__)
+#define MSG_MAIN_MED(...)			__MSG_MED(LVL_MAINVIEW, MAINVIEW_SZ, ##__VA_ARGS__)
+#define MSG_MAIN_LOW(...)			__MSG_LOW(LVL_MAINVIEW, MAINVIEW_SZ, ##__VA_ARGS__)
+
+#define UTIL_SZ "IV-UTIL"
+#define LVL_UTIL DBG_MSG_LVL_HIGH
+
+#define MSG_UTIL_FATAL(...) 		__MSG_FATAL(LVL_UTIL, UTIL_SZ, ##__VA_ARGS__)
+#define MSG_UTIL_ERROR(...)		__MSG_ERROR(LVL_UTIL, UTIL_SZ, ##__VA_ARGS__)
+#define MSG_UTIL_WARN(...)			__MSG_WARN(LVL_UTIL, UTIL_SZ, ##__VA_ARGS__)
+#define MSG_UTIL_HIGH(...)			__MSG_HIGH(LVL_UTIL, UTIL_SZ, ##__VA_ARGS__)
+#define MSG_UTIL_MED(...)			__MSG_MED(LVL_UTIL, UTIL_SZ, ##__VA_ARGS__)
+#define MSG_UTIL_LOW(...)			__MSG_LOW(LVL_UTIL, UTIL_SZ, ##__VA_ARGS__)
+
+#define IVUG_SZ "IV-COMMON"
+#define LVL_IVUG DBG_MSG_LVL_HIGH
+
+#define MSG_IVUG_FATAL(...) 				__MSG_FATAL(LVL_IVUG, IVUG_SZ, ##__VA_ARGS__)
+#define MSG_IVUG_ERROR(...)		__MSG_ERROR(LVL_IVUG, IVUG_SZ, ##__VA_ARGS__)
+#define MSG_IVUG_WARN(...)			__MSG_WARN(LVL_IVUG, IVUG_SZ, ##__VA_ARGS__)
+#define MSG_IVUG_HIGH(...)			__MSG_HIGH(LVL_IVUG, IVUG_SZ, ##__VA_ARGS__)
+#define MSG_IVUG_MED(...)			__MSG_MED(LVL_IVUG, IVUG_SZ, ##__VA_ARGS__)
+#define MSG_IVUG_LOW(...)			__MSG_LOW(LVL_IVUG, IVUG_SZ, ##__VA_ARGS__)
+
+#define NOTI_SZ "IV-NOTI"
+#define LVL_NOTI DBG_MSG_LVL_LOW
+
+#define MSG_NOTI_FATAL(...) 				__MSG_FATAL(LVL_NOTI, NOTI_SZ, ##__VA_ARGS__)
+#define MSG_NOTI_ERROR(...)		__MSG_ERROR(LVL_NOTI, NOTI_SZ, ##__VA_ARGS__)
+#define MSG_NOTI_WARN(...)			__MSG_WARN(LVL_NOTI, NOTI_SZ, ##__VA_ARGS__)
+#define MSG_NOTI_HIGH(...)			__MSG_HIGH(LVL_NOTI, NOTI_SZ, ##__VA_ARGS__)
+#define MSG_NOTI_MED(...)			__MSG_MED(LVL_NOTI, NOTI_SZ, ##__VA_ARGS__)
+#define MSG_NOTI_LOW(...)			__MSG_LOW(LVL_NOTI, NOTI_SZ, ##__VA_ARGS__)
+
+#define PHOTO_SZ "IV-PHOTO"
+#define LVL_PHOTO DBG_MSG_LVL_HIGH
+
+#define MSG_PHOTO_FATAL(...) 				__MSG_FATAL(LVL_PHOTO, PHOTO_SZ, ##__VA_ARGS__)
+#define MSG_PHOTO_ERROR(...)		__MSG_ERROR(LVL_PHOTO, PHOTO_SZ, ##__VA_ARGS__)
+#define MSG_PHOTO_WARN(...)			__MSG_WARN(LVL_PHOTO, PHOTO_SZ, ##__VA_ARGS__)
+#define MSG_PHOTO_HIGH(...)			__MSG_HIGH(LVL_PHOTO, PHOTO_SZ, ##__VA_ARGS__)
+#define MSG_PHOTO_MED(...)			__MSG_MED(LVL_PHOTO, PHOTO_SZ, ##__VA_ARGS__)
+#define MSG_PHOTO_LOW(...)			__MSG_LOW(LVL_PHOTO, PHOTO_SZ, ##__VA_ARGS__)
+
+#define EFFECT_SZ "IV-EFFECT"
+#define LVL_EFFECT DBG_MSG_LVL_HIGH
+
+#define MSG_EFFECT_FATAL(...) 				__MSG_FATAL(LVL_EFFECT, EFFECT_SZ, ##__VA_ARGS__)
+#define MSG_EFFECT_ERROR(...)		__MSG_ERROR(LVL_EFFECT, EFFECT_SZ, ##__VA_ARGS__)
+#define MSG_EFFECT_WARN(...)			__MSG_WARN(LVL_EFFECT, EFFECT_SZ, ##__VA_ARGS__)
+#define MSG_EFFECT_HIGH(...)			__MSG_HIGH(LVL_EFFECT, EFFECT_SZ, ##__VA_ARGS__)
+#define MSG_EFFECT_MED(...)			__MSG_MED(LVL_EFFECT, EFFECT_SZ, ##__VA_ARGS__)
+#define MSG_EFFECT_LOW(...)			__MSG_LOW(LVL_EFFECT, EFFECT_SZ, ##__VA_ARGS__)
+
+
+#define SLIST_ITEM_SZ "IV-SLIST"
+#define LVL_SLIST_ITEM DBG_MSG_LVL_HIGH
+
+#define MSG_SLIST_FATAL(...) 		__MSG_FATAL(LVL_SLIST_ITEM, SLIST_ITEM_SZ, ##__VA_ARGS__)
+#define MSG_SLIST_ERROR(...)		__MSG_ERROR(LVL_SLIST_ITEM, SLIST_ITEM_SZ, ##__VA_ARGS__)
+#define MSG_SLIST_WARN(...)		__MSG_WARN(LVL_SLIST_ITEM, SLIST_ITEM_SZ, ##__VA_ARGS__)
+#define MSG_SLIST_HIGH(...)		__MSG_HIGH(LVL_SLIST_ITEM, SLIST_ITEM_SZ, ##__VA_ARGS__)
+#define MSG_SLIST_MED(...)		__MSG_MED(LVL_SLIST_ITEM, SLIST_ITEM_SZ, ##__VA_ARGS__)
+#define MSG_SLIST_LOW(...)		__MSG_LOW(LVL_SLIST_ITEM, SLIST_ITEM_SZ, ##__VA_ARGS__)
+
+
+#define IV_ASSERT(expr) ASSERT(DBG_MSG_LVL_ALL, "IV-COMMON", expr)
+
+
+#define IVUG_FUNC_ENTER()					MSG_IVUG_HIGH("ENTER %s(L%d)", __func__, __LINE__)
+#define IVUG_FUNC_LEAVE()					MSG_IVUG_HIGH("LEAVE %s(L%d)", __func__, __LINE__)
+
+//expr check statements
+#define ivug_ret_if(expr) \
+	do { \
+		if(expr) { \
+			MSG_IMAGEVIEW_WARN("[%s] Return", #expr );\
+			return; \
+		} \
+	} while (0)
+
+#define ivug_retv_if(expr, val) \
+	do { \
+		if(expr) { \
+			MSG_IMAGEVIEW_WARN("[%s] Return value %d", #expr, val );\
+			return (val); \
+		} \
+	} while (0)
+
+#define ivug_retm_if(expr, fmt, args...) \
+	do { \
+		if(expr) { \
+			MSG_IMAGEVIEW_WARN("[%s] Return, message "fmt, #expr, ##args );\
+			return; \
+		} \
+	} while (0)
+
+#define ivug_retvm_if(expr, val, fmt, args...) \
+	do { \
+		if(expr) { \
+			MSG_IMAGEVIEW_WARN("[%s] Return value, message "fmt, #expr, ##args );\
+			return (val); \
+		} \
+	} while (0)
+
+
+#include "debug.h"
+
+
+#endif //_IVUG_DEBUG_H_
diff --git a/common/include/ivug-mouse-event.h b/common/include/ivug-mouse-event.h
new file mode 100755
index 0000000..40ecc5a
--- /dev/null
+++ b/common/include/ivug-mouse-event.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2012  Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	  http://www.tizenopensource.org/license
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#pragma once
+
+typedef struct  {
+	int x, y;
+
+	unsigned int timestamp;
+
+	int button_flags;
+
+	int event_flags;
+	int device;
+} MouseEvent;
+
+
+// TODO : Review below APIs
+typedef struct {
+	void (*onMouseDown)(Evas_Object *obj, MouseEvent *down, void *data);
+	void (*onMouseDlbClick)(Evas_Object *obj, MouseEvent *click, void *data);
+	void (*onMouseUp)(Evas_Object *obj, MouseEvent *up, void *data);
+	void (*onMouseMove)(Evas_Object *obj, MouseEvent *prev, MouseEvent *cur, void *data);
+
+} mouse_callback_t;
+
+typedef void *Ivug_Event_Handle;
+
+Ivug_Event_Handle
+ivug_mouse_event_add(Evas_Object *obj, mouse_callback_t *pCallback, void *client_data, const char *alias /* for debugging*/);
+
+void ivug_mouse_event_del(Ivug_Event_Handle handle);
+
+
diff --git a/common/include/statistics.h b/common/include/statistics.h
new file mode 100755
index 0000000..3ef8df9
--- /dev/null
+++ b/common/include/statistics.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2012  Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	  http://www.tizenopensource.org/license
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#ifndef __ELM_MYPHOTOCAM_STATISTICS_H__
+#define __ELM_MYPHOTOCAM_STATISTICS_H__
+
+#include <stdbool.h>
+#include <stdio.h>
+
+#define PERF_TIME
+
+#define LVL1 "  "
+#define LVL2 "    "
+#define LVL3 "      "
+#define LVL4 "        "
+#define LVL5 "          "
+#define LVL6 "            "
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int mm_ta_accum_item_begin(const char* name, bool show, const char* filename, int line);
+int mm_ta_accum_item_end(const char* name, bool show, const char* filename, int line);
+void mm_ta_accum_show_result_fp(FILE *fp);
+
+int PERF_INIT();
+int PERF_DEINIT();
+
+#ifdef PERF_TIME
+
+// accum item handling
+#define PERF_CHECK_BEGIN(name)		mm_ta_accum_item_begin(name,false,__FILE__,__LINE__)
+#define PERF_CHECK_END(name)			mm_ta_accum_item_end(name,false,__FILE__,__LINE__)
+
+// Print out
+#define PERF_SHOW_RESULT(fp)		mm_ta_accum_show_result_fp(fp)
+
+#else
+
+#define PERF_CHECK_BEGIN(name)
+#define PERF_CHECK_END(name)
+
+// Print out
+#define PERF_SHOW_RESULT(fp)
+
+
+#endif		// PERF_TIME
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __ELM_MYPHOTOCAM_STATISTICS_H__ */
+
diff --git a/common/src/debug.c b/common/src/debug.c
new file mode 100755
index 0000000..800d69a
--- /dev/null
+++ b/common/src/debug.c
@@ -0,0 +1,399 @@
+/*
+ * Copyright 2012  Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	  http://www.tizenopensource.org/license
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <time.h>		// localtime_r
+#include <sys/time.h>	// gettimeofday
+#include <unistd.h>
+#include <string.h>		// strrchr
+
+#ifndef __G_LIB_H__
+	#define G_UNLIKELY(x) x
+#endif
+
+
+#include "debug.h"
+
+enum {
+	_DEBUG_OUTPUT_DIRECTION_CONSOLE = (1 << 0),
+	_DEBUG_OUTPUT_DIRECTION_SYSLOG = (1 << 1),
+	_DEBUG_OUTPUT_DIRECTION_FILE = (1 << 2),
+	_DEBUG_OUTPUT_DIRECTION_DLOG = (1 << 3),
+};
+
+// Configuration for output
+// console message slower than dlog about 30~40 ms
+#define _DEBUG_OUTPUT_DIRECTION (_DEBUG_OUTPUT_DIRECTION_DLOG)
+
+#include <dlog.h>
+
+#ifndef INI_PATH
+#define INI_PATH "/var/log"
+#endif
+
+#ifndef _DEBUG_MODULE
+#define _DEBUG_MODULE "IVUG"
+#endif
+
+#define _DEBUG_ERR_TRACE_FILE_NAME	INI_PATH"/"_DEBUG_MODULE"_FATAL.txt"
+#define _DEBUG_PREFIX "["_DEBUG_MODULE"]"
+
+static bool bInit = false;
+
+static char *get_time_string(unsigned long dwmSec)
+{
+	static char buffer[30];
+
+	unsigned long msec=0;
+	unsigned long sec=0;
+	unsigned long min=0;
+	unsigned long hour=0;
+
+// Don't forget turn on compiler optimization options.
+	sec = ( dwmSec / 1000 );
+	msec = ( dwmSec % 1000 );
+
+	min = (sec / 60 );
+	sec = (sec % 60 );
+
+	hour = (min / 60 );
+	min = (min % 60 );
+
+	snprintf(buffer, (size_t)sizeof(buffer), "%1d:%02d:%02d.%03d",	(int)hour,(int)min,(int)sec,(int)msec);
+
+	return buffer;
+}
+
+
+/*Retrieves the number of milliseconds that have elapsed since the system was started*/
+static unsigned long get_sys_elapsed_time(void)
+{
+	static struct timeval init_time = { 0 , 0 };
+	static bool bFirst = false;
+	struct timeval current_time;
+
+	if ( bFirst == false )
+	{
+		bFirst = true;
+		gettimeofday(&init_time, NULL);
+	}
+
+	gettimeofday(&current_time, NULL);
+
+	// 	return 	(current_time.tv_sec - init_time.tv_sec) * 1000UL + 	(UINT32)((current_time.tv_usec - init_time.tv_usec) / 1000.0)	;
+	return 	((current_time.tv_sec * 1E3 + current_time.tv_usec / 1E3) - (init_time.tv_sec * 1E3 + init_time.tv_usec / 1E3));
+}
+
+char *get_fmt_string__inline (const char *msg, va_list va)
+{
+#define MAX_CHAR_PER_LINE ( 1024 )
+
+	static char szPrint[MAX_CHAR_PER_LINE];
+
+	vsnprintf(szPrint, 1024, msg, va);
+
+	return szPrint;
+}
+
+
+void _custom_debug_init()
+{
+	get_sys_elapsed_time();
+}
+
+
+void _custom_debug_deinit()
+{
+
+}
+
+
+void
+_custom_err_trace_write( const char *func_name, int line_num, const char *fmt, ... )
+{
+	FILE *f    = NULL;
+	va_list ap = {0};
+	char buf[128];
+
+	time_t current_time;
+	struct tm new_time;
+
+	current_time = time( NULL );
+	localtime_r( &current_time, &new_time );
+
+	f = fopen( _DEBUG_ERR_TRACE_FILE_NAME, "a" );
+	if( f == NULL )
+	{
+		printf( "Failed to open file.[%s]\n", _DEBUG_ERR_TRACE_FILE_NAME );
+		return;
+	}
+
+	fprintf( f, "[%.19s][%05d][%s]", asctime_r( &new_time, buf ), line_num, func_name );
+
+	va_start( ap, fmt );
+	vfprintf( f, fmt, ap );
+	va_end( ap );
+
+	fprintf( f, "\n" );
+
+	fclose( f );
+}
+
+void
+_custom_err_trace_fvprintf( const char *func_name, int line_num, const char *fmt, va_list ap )
+{
+	FILE *f    = NULL;
+
+	time_t current_time;
+	struct tm new_time;
+	char buf[128];
+
+	current_time = time( NULL );
+	localtime_r( &current_time, &new_time );
+
+	f = fopen( _DEBUG_ERR_TRACE_FILE_NAME, "a" );
+	if( f == NULL )
+	{
+		printf( "Failed to open file.[%s]\n", _DEBUG_ERR_TRACE_FILE_NAME );
+		return;
+	}
+
+	fprintf( f, "[%.19s][[F:%-16.16s L:%5d] ", asctime_r( &new_time, buf ), func_name, line_num );
+	vfprintf( f, fmt, ap );
+	fprintf( f, "\n" );
+
+	fclose( f );
+}
+
+/*
+typedef enum log_priority {
+        DLOG_UNKNOWN = 0,
+        DLOG_DEFAULT,
+        DLOG_VERBOSE,
+        DLOG_DEBUG,
+        DLOG_INFO,
+        DLOG_WARN,
+        DLOG_ERROR,
+        DLOG_FATAL,
+        DLOG_SILENT,
+} log_priority;
+
+#define LOG(priority, tag, ...) \
+#define LOG_VA(priority, tag, fmt, args) \
+*/
+
+inline log_priority convert_to_dlog_priority(int msg_level)
+{
+/*
+DBG_MSG_LOW 	= 0,
+DBG_MSG_MED 		= 1,
+DBG_MSG_HIGH		= 2,
+
+DBG_MSG_WARN		= 3,
+DBG_MSG_ERROR		= 4,
+DBG_MSG_FATAL		= 5,
+
+DBG_MSG_CUST5		= 6,
+DBG_MSG_CUST6		= 7,
+DBG_MSG_CUST7		= 8,
+DBG_MSG_CUST8		= 9,
+DBG_MSG_CUST9		= 10,
+DBG_MSG_CUST10	= 11,
+DBG_MSG_CUST11	= 12,
+DBG_MSG_CUST12	= 13,
+DBG_MSG_CUST13	= 14,
+*/
+
+	static log_priority priority[] = {
+		DLOG_VERBOSE,
+		DLOG_VERBOSE,
+		DLOG_WARN, 		// MSG HIGH
+		DLOG_WARN,
+		DLOG_ERROR,
+		DLOG_FATAL,		// 5
+	};
+
+	if ( msg_level <= DBG_MSG_FATAL)
+		return priority[msg_level];
+
+	return DLOG_DEBUG;
+
+}
+
+
+
+void _custom_debug_msg(debug_msg_type *debug_msg, const char *msg, ...)
+{
+	va_list va;
+
+	static const char *level ;
+
+	if ( G_UNLIKELY(bInit == false) )
+	{
+		_custom_debug_init();
+		bInit = true;
+	}
+
+#define DIRECORY_SPLITTER '/'
+	const char*pFileName = NULL;
+
+	debug_msg->time = get_sys_elapsed_time();
+
+	pFileName  =   strrchr(debug_msg->fname, DIRECORY_SPLITTER);
+	pFileName = (NULL == pFileName)?debug_msg->fname:(pFileName+1);
+
+	level = debug_msg->szlevel;
+
+	// File
+	char *time_string = get_time_string(debug_msg->time);
+
+	va_start(va, msg);
+
+	if ( _DEBUG_OUTPUT_DIRECTION & _DEBUG_OUTPUT_DIRECTION_CONSOLE )
+	{
+
+		printf(_DEBUG_PREFIX"%s[F:%-16.16s L:%5d][%s:%s] ",time_string , pFileName, debug_msg->nline , debug_msg->szcategory, level );
+		vprintf(msg, va);
+		printf("\n");
+	}
+
+	if ( _DEBUG_OUTPUT_DIRECTION & _DEBUG_OUTPUT_DIRECTION_DLOG )
+	{
+		static char buf[2048];
+
+		int i ;
+
+		i = snprintf(buf, 2048, "%s[F:%-16.16s L:%5d][%s] ",time_string , pFileName, debug_msg->nline , level);
+
+		vsnprintf( buf + i, 2048 - i, msg, va);
+
+// Prevent Format string attack
+		print_log(convert_to_dlog_priority(debug_msg->msg_level), debug_msg->szcategory, "%s", buf);
+//		print_log(prio, _DEBUG_MODULE, "%s[F:%-16.16s L:%5d][%s:%s] ",time_string , pFileName, debug_msg->nline , szCategory[debug_msg->category], level );
+//		vprint_log(prio,_DEBUG_MODULE, msg, va);
+	}
+
+	va_end(va);
+
+
	if ( G_UNLIKELY(debug_msg->msg_level == DBG_MSG_FATAL) )
+	{
+		fflush (stdout);
+		va_start(va, msg);
+		_custom_err_trace_fvprintf(pFileName, debug_msg->nline, msg, va);		// Save to file.
+		va_end(va);
+		assert(0);
+	}
+
+}
+
+
+#ifdef FMRADIO_FEATURE_ENABLE_GSTREAMER_LOGGING
+
+enum {
+	DEBUG_COLOR_DEFAULT 	= 0,
+	DEBUG_COLOR_BLACK		= 30,
+	DEBUG_COLOR_RED 		= 31,
+	DEBUG_COLOR_GREEN		= 32,
+	DEBUG_COLOR_YELLOW		= 33,
+	DEBUG_COLOR_BLUE		= 34,
+	DEBUG_COLOR_MAGENTA 	= 35,
+	DEBUG_COLOR_CYAN		= 36,
+	DEBUG_COLOR_WHITE		= 37,
+};
+
+static gchar *custom_print_object(GObject *object)
+{
+	if (object == NULL)
+	{
+		return g_strdup("Unknown");
+	}
+/*
+	if (*(GType *) ptr == GST_TYPE_CAPS)
+	{
+		return gst_caps_to_string((GstCaps *) ptr);
+	}
+
+	if (*(GType *) ptr == GST_TYPE_STRUCTURE)
+	{
+		return gst_structure_to_string((GstStructure *) ptr);
+	}
+*/
+	if (GST_IS_PAD(object))
+	{
+		return g_strdup_printf("%s:%s", GST_STR_NULL( GST_OBJECT_NAME( GST_PAD_PARENT(object))) , GST_STR_NULL( GST_PAD_NAME(object) ));
+	}
+
+	if (GST_IS_ELEMENT(object))
+	{
+		return g_strdup_printf("%s", GST_STR_NULL(GST_ELEMENT_NAME(object)));
+	}
+
+	if (G_IS_OBJECT(object))
+	{
+		return g_strdup_printf("%s(0x%0x)", G_OBJECT_TYPE_NAME(object), object);
+	}
+
+	return g_strdup_printf("0x%08x", object);
+}
+
+void custom_log_func(GstDebugCategory *category, GstDebugLevel level,
+		const gchar *file, const gchar *function, gint line,
+		GObject *object, GstDebugMessage *message, gpointer unused)
+{
+	static const char *szLevel[] = {"LOW", "MED", "HIGH", "WARN", "ERROR", "FATAL"};
+
+	static const gint levelcolor[] = {
+		DEBUG_COLOR_DEFAULT,		/* GST_LEVEL_NONE */
+		DEBUG_COLOR_RED,			/* GST_LEVEL_ERROR */
+		DEBUG_COLOR_YELLOW, 		/* GST_LEVEL_WARNING */
+		DEBUG_COLOR_GREEN,			/* GST_LEVEL_INFO */
+		DEBUG_COLOR_CYAN,			/* GST_LEVEL_DEBUG */
+		DEBUG_COLOR_WHITE,			/* GST_LEVEL_LOG */
+	};
+
+	if (level > gst_debug_category_get_threshold(category))
+		return;
+
+	gchar *obj = custom_print_object(object);
+
+#define DIRECORY_SPLITTER '/'
+
+	const char*pFileName = NULL;
+
+	pFileName  =   strrchr(file, DIRECORY_SPLITTER);
+	pFileName = (NULL == pFileName) ? file:(pFileName+1);
+
+// File
+	char *time_string = get_time_string(get_sys_elapsed_time());
+
+	log_print_rel(LOG_CAMCORDER,LOG_CLASS_ERR,
+		_DEBUG_PREFIX "%s[F:%-16.16s L:%5d][%s][%s][%s] %s\n", time_string, pFileName, line,
+				gst_debug_category_get_name(category), gst_debug_level_get_name(level),obj,
+				gst_debug_message_get(message));
+
+	g_free(obj);
+}
+
+
+#endif // FMRADIO_FEATURE_ENABLE_GSTREAMER_LOGGING
+
+
+
diff --git a/common/src/ivug-mouse-event.c b/common/src/ivug-mouse-event.c
new file mode 100755
index 0000000..db3e52c
--- /dev/null
+++ b/common/src/ivug-mouse-event.c
@@ -0,0 +1,376 @@
+/*
+ * Copyright 2012  Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	  http://www.tizenopensource.org/license
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include <Elementary.h>
+#include <stdbool.h>
+#include "ivug-debug.h"
+#include "ivug-mouse-event.h"
+
+
+// Click condition.
+// Down Up duration under 300ms & Down pos, Up pos under 3 pixel
+
+
+// Long pressed condition
+// Down Up duration upper 1s & Down pos, Up pos under 5 pixel
+
+typedef enum {
+	MOUSE_DOWN_UNKNWON,
+	MOUSE_DOWN_NONE,
+	MOUSE_DOWN_1,
+	MOUSE_DOWN_ERROR,	// Error
+} MouseState;
+
+
+#define INVALID_DEVICE_ID (-1)
+#define NUM_MAX_BUTTON (1)
+
+typedef struct _mouse_data_t{
+	void *pClientData;
+	Evas_Object *obj;
+
+	mouse_callback_t cb;
+
+	MouseState m_state;
+
+	bool bDown[NUM_MAX_BUTTON];		// For Mose down check before mouse move
+	bool bHold[NUM_MAX_BUTTON];
+
+	MouseEvent event[NUM_MAX_BUTTON];
+	MouseEvent down[NUM_MAX_BUTTON];
+	MouseEvent prve_up[NUM_MAX_BUTTON];
+
+	unsigned int prev_dist;
+
+	MouseEvent center;
+
+// For debugging purpose, later will be removed.
+	char alias[100];		//
+} mouse_data_t;
+
+
+#ifndef __UNUSED__
+#define __UNUSED__ __attribute__((unused))
+#endif
+
+static void _on_mouse_down(void *data, Evas *evas __UNUSED__, Evas_Object *obj, void *event_info)
+{
+	if ( data == NULL )
+	{
+		MSG_MOUSE_ERROR("Debug me!!!!");
+		return;
+	}
+
+	mouse_data_t *pData = (mouse_data_t *)data;
+	MouseEvent *ev = event_info;
+
+	if ( ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
+	{
+		MSG_MOUSE_HIGH("[%s] %s On Hold. Dev=%d", pData->alias, __func__, ev->device);
+	}
+
+	int pressed = ev->device;
+
+	if(pressed >= NUM_MAX_BUTTON)
+	{
+		MSG_MOUSE_FATAL("Invalid Pressed(%d)", pressed);
+		return;
+	}
+
+	if ( pData->m_state == MOUSE_DOWN_UNKNWON )
+	{
+		MSG_MOUSE_ERROR("[%s] Something wrong", pData->alias);
+	}
+
+	if 
( pData->bDown[pressed] == true )
+	{
+		MSG_MOUSE_WARN("Mouse down is detected. but already pressed button. ignore");
+		return;
+	}
+
+	pData->m_state++;
+	pData->bDown[pressed] = true;		// TODO : probably, can make memory overwritten issues.
+
+	if ( pData->m_state == MOUSE_DOWN_1 )
+	{
+		MSG_MOUSE_HIGH("[%s] Callback Mouse Down : Dev=%d (%d,%d)", pData->alias, ev->device, ev->x, ev->y);
+
+		if ( pData->cb.onMouseDown )
+		{
+			(pData->cb.onMouseDown)(pData->obj, ev, pData->pClientData);
+		}
+
+		MSG_MOUSE_MED("Func:%s Device=%d XY(%d,%d)", "_on_mouse_down", pressed, ev->x , ev->y );
+	}
+	else
+	{
+		MSG_MOUSE_WARN("[%s] Ignore third finger! State=%d Dev=%d bPressed(%d,%d,%d)", pData->alias, pData->m_state, ev->device,
+			pData->bDown[0],
+			pData->bDown[1],
+			pData->bDown[2]);
+
+		return ;
+	}
+
+	pData->event[pressed] = *ev;
+	pData->down[pressed] = *ev;
+
+	return ;
+}
+
+
+static void _on_mouse_up(void *data, Evas *evas __UNUSED__, Evas_Object *obj, void *event_info)
+{
+
+	if ( data == NULL )
+	{
+		MSG_MOUSE_ERROR("Debug me!!!!");
+		return;
+	}
+
+	mouse_data_t *pData = (mouse_data_t *)data;
+	MouseEvent *ev = event_info;
+
+	int pressed = ev->device;
+
+	if(pressed >= NUM_MAX_BUTTON)
+	{
+		MSG_MOUSE_FATAL("Invalid Pressed(%d)", pressed);
+		return;
+	}
+
+	if ( pData->m_state == MOUSE_DOWN_UNKNWON )
+	{
+		MSG_MOUSE_ERROR("[%s] Something wrong. Dev=%d",  pData->alias, ev->device);
+		MSG_MOUSE_ERROR("[%s] Error! State=%d Dev=%d bPressed(%d,%d,%d)", pData->alias, pData->m_state, ev->device,
+			pData->bDown[0],
+			pData->bDown[1],
+			pData->bDown[2]);
+
+	}
+
+	if ( pData->m_state == MOUSE_DOWN_NONE )
+	{
+		MSG_MOUSE_WARN("[%s] Mouse up is detected. but state is NONE.", pData->alias);
+		pData->bDown[0] = pData->bDown[1] = pData->bDown[2] = 0;
+		return;
+	}
+
+	pData->m_state--;
+
+	if 
( pData->bDown[pressed] == false )
+	{
+		MSG_MOUSE_ERROR("[%s] Something wrong", pData->alias);
+		MSG_MOUSE_ERROR("[%s] Error! State=%d Dev=%d bPressed(%d,%d,%d)", pData->alias, pData->m_state, ev->device,
+			pData->bDown[0],
+			pData->bDown[1],
+			pData->bDown[2]);
+	}
+
+	if ( ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
+	{
+		MSG_MOUSE_HIGH("[%s] %s On Hold. Dev=%d", pData->alias, __func__, ev->device);
+		pData->bHold[pressed] = true;
+	}
+
+	pData->bDown[pressed] = false;
+
+	if ( pData->m_state == MOUSE_DOWN_NONE )
+	{
+		MSG_MOUSE_HIGH("[%s] Callback Mouse Up : Dev=%d (%d,%d)", pData->alias, ev->device, ev->x, ev->y);
+
+		if ( ev->button_flags & EVAS_BUTTON_DOUBLE_CLICK)
+		{
+			if ( pData->cb.onMouseDlbClick )
+			{
+				(pData->cb.onMouseDlbClick)(pData->obj, ev, pData->pClientData);
+			}
+			MSG_MOUSE_HIGH("[%s] %s Double click detected. Dev=%d (%d,%d)", pData->alias, __func__, ev->device, ev->x, ev->y);
+		}
+		if ( pData->cb.onMouseUp )
+		{
+			(pData->cb.onMouseUp)(pData->obj, ev, pData->pClientData);
+		}
+
+		pData->prve_up[pressed] = *ev;
+
+		MSG_MOUSE_MED("Func:%s State=%d Device=%d XY(%d,%d)", "_on_mouse_up", pData->m_state, pressed, ev->x , ev->y);
+	}
+
+	return ;
+
+}
+
+static void _on_mouse_move(void *data, Evas *evas __UNUSED__, Evas_Object *obj, void *event_info)
+{
+	if ( data == NULL )
+	{
+		MSG_MOUSE_ERROR("Debug me!!!!");
+		return;
+	}
+
+	mouse_data_t *pData = (mouse_data_t *)data;
+	MouseEvent *ev = event_info;
+
+	int pressed = ev->device;
+
+	if ( ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
+	{
+		MSG_MOUSE_HIGH("[%s] %s On Hold. Dev=%d", pData->alias, __func__, ev->device);
+	}
+
+	if(pressed >= NUM_MAX_BUTTON)
+	{
+		MSG_MOUSE_FATAL("Invalid Pressed(%d)", pressed);
+		return;
+	}
+
+	if ( pData->bDown[pressed] == false)
+	{
+		// Move event prior down should be ignored
+		MSG_MOUSE_MED("Ignore move event before click");
+		return ;
+	}
+
+	switch ( pData->m_state )
+	{
+		case MOUSE_DOWN_1:
+		{
+			MSG_MOUSE_MED("Func:%s. Device=%d Old(%d,%d) Cur(%d,%d)", __FUNCTION__, pressed,
+					pData->event[pressed].x, pData->event[pressed].y,
+					ev->x , ev->y);
+
+			if ( pData->cb.onMouseMove )
+			{
+				MSG_MOUSE_MED("[%s] Callback Mouse Move : (%d,%d)",  pData->alias, ev->x, ev->y);
+				(pData->cb.onMouseMove)(pData->obj, &pData->event[pressed], ev, pData->pClientData);
+			}
+
+			pData->event[pressed] = *ev;
+
+			break;
+		}
+		default:
+			MSG_MOUSE_ERROR("[%s] Something wrong. state=%d", pData->alias, pData->m_state);
+			break;
+
+	}
+
+	return ;
+}
+
+
+
+static void _proxy_on_mouse_down(void *data, Evas *evas __UNUSED__, Evas_Object *obj, void *event_info)
+{
+	Evas_Event_Mouse_Down *ev = event_info;
+
+	MouseEvent event;
+
+	event.device = 0;
+	event.timestamp = ev->timestamp;
+	event.x = ev->canvas.x;
+	event.y = ev->canvas.y;
+	event.button_flags = ev->flags;
+	event.event_flags = ev->event_flags;
+
+	MSG_MOUSE_MED("%s Dev=%d Button=%d Flags=%d Event=%d", __func__, (int)ev->dev, ev->button, ev->flags, ev->event_flags);
+
+	_on_mouse_down(data, NULL, obj, (void *)&event);
+}
+
+static void _proxy_on_mouse_up(void *data, Evas *evas __UNUSED__, Evas_Object *obj, void *event_info)
+{
+	Evas_Event_Mouse_Up *ev = event_info;
+
+	MouseEvent event;
+
+	event.device = 0;
+	event.timestamp = ev->timestamp;
+	event.x = ev->canvas.x;
+	event.y = ev->canvas.y;
+	event.button_flags = ev->flags;
+	event.event_flags = ev->event_flags;
+
+
+	MSG_MOUSE_MED("%s Dev=%d Button=%d Flags=%d Event=%d", __func__, (int)ev->dev, ev->button, ev->flags, ev->event_flags);
+
+
+	_on_mouse_up(data, NULL, obj, (void *)&event);
+}
+
+static void _proxy_on_mouse_move(void *data, Evas *evas __UNUSED__, Evas_Object *obj, void *event_info)
+{
+	Evas_Event_Mouse_Move *ev = event_info;
+
+	MouseEvent event;
+
+	event.device = 0;
+	event.timestamp = ev->timestamp;
+	event.x = ev->cur.canvas.x;
+	event.y = ev->cur.canvas.y;
+	event.button_flags = 0;
+	event.event_flags = ev->event_flags;
+
+	MSG_MOUSE_MED("%s Dev=%d Button=%d Event=%d Prev(%d,%d) Cur(%d,%d)", __func__, (int)ev->dev, ev->buttons, ev->event_flags,
+				ev->prev.canvas.x, ev->prev.canvas.y, ev->cur.canvas.x, ev->cur.canvas.y);
+
+	_on_mouse_move(data, NULL, obj, (void *)&event);
+
+}
+
+
+Ivug_Event_Handle
+ivug_mouse_event_add(Evas_Object *obj, mouse_callback_t *pCallback, void *client_data, const char *alias)
+{
+	mouse_data_t *pData = NULL;
+//TODO : Should check parameters
+
+	pData = calloc(1, sizeof(mouse_data_t));
+
+	pData->obj = obj;
+	pData->pClientData = client_data;
+	pData->m_state = MOUSE_DOWN_NONE;
+	strncpy(pData->alias, alias, sizeof(pData->alias));
+
+	memcpy(&pData->cb, pCallback, sizeof(mouse_callback_t));
+
+	evas_object_event_callback_add(pData->obj, EVAS_CALLBACK_MOUSE_DOWN, _proxy_on_mouse_down, pData);
+	evas_object_event_callback_add(pData->obj, EVAS_CALLBACK_MOUSE_UP, _proxy_on_mouse_up,  pData);
+	evas_object_event_callback_add(pData->obj, EVAS_CALLBACK_MOUSE_MOVE, _proxy_on_mouse_move, pData);
+
+	MSG_MOUSE_HIGH("Mouse Event Handler Add : Alias(%s) 0x%08x for Object(0x%08x)", alias, pData, obj);
+
+	return (Ivug_Event_Handle *)pData;
+}
+
+
+void ivug_mouse_event_del(Ivug_Event_Handle handle)
+{
+	mouse_data_t *pData = handle;
+
+	evas_object_event_callback_del(pData->obj, EVAS_CALLBACK_MOUSE_DOWN, _proxy_on_mouse_down);
+	evas_object_event_callback_del(pData->obj, EVAS_CALLBACK_MOUSE_UP, _proxy_on_mouse_up);
+	evas_object_event_callback_del(pData->obj, EVAS_CALLBACK_MOUSE_MOVE, _proxy_on_mouse_move);
+
+	MSG_MOUSE_HIGH("Mouse Event Handler Remove : 0x%08x", pData);
+
+	free(handle);
+}
+
+
+
diff --git a/common/src/statistics.c b/common/src/statistics.c
new file mode 100755
index 0000000..5eaa56e
--- /dev/null
+++ b/common/src/statistics.c
@@ -0,0 +1,442 @@
+/*
+ * Copyright 2012  Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *	  http://www.tizenopensource.org/license
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include <sys/time.h>	// gettimeofday
+
+#include <stdio.h>
+#include <malloc.h>
+#include <string.h>
+#include <assert.h>
+#include <time.h>
+
+#include "statistics.h"
+#include "debug.h"
+
+
+#ifdef STANDALONE
+#define EXPORT_API
+#endif
+
+#include <sys/time.h>
+#include <sys/utsname.h>
+#include <sys/resource.h>
+#include <unistd.h>
+
+#include <stdarg.h>
+#include "statistics.h"
+
+#define MAX_UINT32 (0xFFFFFFFFL)
+#define MAX_UINT64 (0xFFFFFFFFFFFFFFFFLL)
+
+// defs.
+#define MM_TA_MAX_ACCUM			100
+
+
+typedef struct _mm_ta_accum_item
+{
+	unsigned long long elapsed_accum;
+	unsigned long num_calls;
+	unsigned long long elapsed_min;
+	unsigned long long elapsed_max;
+	unsigned long long first_start;
+	unsigned long long last_end;
+
+	char* name;
+
+	unsigned long long timestamp;
+	int on_estimate;
+	int num_unpair;
+} mm_ta_accum_item;
+
+
+static void PrintLog(const char *file, int line, const char *msg, ...)
+{
+	va_list va;
+
+	va_start(va, msg);
+	fprintf(stderr ,"[STAT] %s:%d:",file, line);
+	vfprintf(stderr ,msg, va);
+	fprintf(stderr, "\n");
+	va_end(va);
+}
+
+#define MyPrintf(...)  PrintLog(__FILE__, __LINE__, ##__VA_ARGS__ )
+
+
+// internal func.
+static void __free_accums(void);
+static int __get_accum_index(const char* name);
+
+
+// global var.
+static mm_ta_accum_item ** g_accums = NULL;
+static int g_accum_index = 0;
+static int g_accum_longest_name = 0;
+static unsigned long long g_accum_first_time = MAX_UINT64;	// jmlee
+
+
+int PERF_INIT(void)
+{
+	if (g_accums)
+	{
+		return 0;
+	}
+
+	g_accums = (mm_ta_accum_item **) malloc ( MM_TA_MAX_ACCUM * sizeof(mm_ta_accum_item *) );
+	if(!g_accums)
+	{
+		assert(0);
+		return -1;
+	}
+
+	g_accum_first_time = MAX_UINT64;
+
+	return 0;
+}
+
+int PERF_DEINIT(void)
+{
+	if ( ! g_accums )
+	{
+		return 0;
+	}
+
+	__free_accums();
+
+	g_accum_first_time = MAX_UINT64;
+
+	return 0;
+}
+
+
+static int __get_accum_index(const char* name)
+{
+	int i;
+
+	assert(name);
+
+	// find index
+	for ( i = 0; i < g_accum_index; i++ )
+	{
+		if ( strcmp( name, g_accums[i]->name ) == 0 )
+			return i;
+	}
+
+	return -1;
+}
+
+static void __free_accums(void)
+{
+	int i = 0;
+
+	if ( ! g_accums )
+		return;
+
+	for ( i = 0; i < g_accum_index; i++ )
+	{
+		if ( g_accums[i] )
+		{
+			if ( g_accums[i]->name )
+				free ( g_accums[i]->name );
+
+			free ( g_accums[i] );
+
+			g_accums[i] = NULL;
+		}
+	}
+
+	g_accum_index = 0;
+	g_accum_longest_name = 0;
+
+	free ( g_accums );
+	g_accums = NULL;
+}
+
+
+
+int mm_ta_accum_item_begin(const char* name, bool show, const char* filename, int line)
+{
+	mm_ta_accum_item * accum = NULL;
+	int index = 0;
+	int name_len = 0;
+	struct timeval t;
+
+	if (!g_accums)
+		return 0;
+
+	if ( g_accum_index == MM_TA_MAX_ACCUM )
+		return -1;
+
+	if ( !name )
+		return -1;
+
+	name_len = strlen(name);
+	if( name_len == 0 )
+		return -1;
+
+	// if 'name' is new one. create new item.
+	if ( (index = __get_accum_index(name)) == -1 )
+	{
+		accum = ( mm_ta_accum_item * ) malloc( sizeof( mm_ta_accum_item ) );
+		if ( !accum )
+		{
+			assert(0);
+			return -1;
+		}
+
+		// clear first.
+		memset( accum, 0, sizeof (mm_ta_accum_item) );
+		accum->elapsed_min = MAX_UINT64;
+
+		accum->name = strdup(name);
+		// add it to list.
+		g_accums[g_accum_index] = accum;
+		g_accum_index++;
+
+		if ( g_accum_longest_name < name_len )
+			g_accum_longest_name = name_len;
+
+	}
+	else
+	{
+		accum = g_accums[index];
+	}
+
+	// verify pairs of begin, end.
+	if (accum->on_estimate)
+	{
+		MyPrintf("[%s] is not 'end'ed!\n", accum->name);
+		accum->num_unpair ++;
+		return -1;
+	}
+
+	accum->on_estimate = 1;
+
+	// get timestamp
+	gettimeofday( &t, NULL );
+	accum->timestamp = t.tv_sec * 1000000UL + t.tv_usec;
+
+	if ( accum->first_start == 0 )
+	{	// assum that timestamp never could be zero.
+		accum->first_start = accum->timestamp;
+
+		if ( g_accum_first_time > accum->first_start )
+		{
+			g_accum_first_time = accum->first_start ;
+		}
+	}
+
+	if ( show )
+		MyPrintf("[ACCUM BEGIN] %s : %ld ---(%s:%d)\n", name, accum->timestamp, filename, line );
+
+	accum->num_calls++;
+
+	return 0;
+}
+
+int mm_ta_accum_item_end(const char* name, bool show, const char* filename, int line)
+{
+	mm_ta_accum_item * accum = NULL;
+	unsigned long long tval = 0LL;
+	int index = 0;
+	struct timeval	t;
+
+	if (!g_accums)
+		return 0;
+
+	if ( g_accum_index == MM_TA_MAX_ACCUM )
+		return -1;
+
+	if ( !name )
+		return -1;
+
+	if( strlen ( name ) == 0 )
+		return -1;
+
+	// varify the 'name' is already exist.
+	if ( (index = __get_accum_index(name)) == -1 )
+	{
+		MyPrintf("[%s] is not added before!\n", name);
+		return -1;
+	}
+
+	accum = g_accums[index];
+
+	// verify pairs of begin, end.
+	if (!accum->on_estimate)
+	{
+		MyPrintf("[%s] is not 'begin' yet!\n", accum->name);
+		accum->num_unpair ++;
+		return -1;
+	}
+
+	// get time first for more accuracy.
+	gettimeofday( &t, NULL );
+	tval = t.tv_sec*1000000UL + t.tv_usec;
+
+	// update last_end
+	accum->last_end = tval;
+
+	// make get elapsed time.
+	tval = tval - accum->timestamp;
+
+	// update min/max
+	accum->elapsed_max = tval > accum->elapsed_max ? tval : accum->elapsed_max;
+	accum->elapsed_min = tval < accum->elapsed_min ? tval : accum->elapsed_min;
+
+	if ( show )
+		MyPrintf("[ACCUM END] %s : %llu + %llu ---(%s:%d)\n", name, accum->elapsed_accum, tval, filename, line );
+
+	// add elapsed time
+	accum->elapsed_accum = accum->elapsed_accum + tval;
+	accum->on_estimate = 0;
+
+	return 0;
+}
+
+void __print_some_info(FILE* fp)
+{
+	if (!fp)
+		return;
+
+	// General infomation
+	{
+		time_t t_val;
+		char hostname[256] = {'\0',};
+#ifdef LINUX
+		struct utsname uts;
+		struct rusage r_usage;
+#endif
+		fprintf(fp, "\n[[ General info ]]\n");
+
+		// time and date
+		time(&t_val);
+		fprintf(fp, "Date : %s", ctime(&t_val) );
+
+		// system
+		if ( gethostname(hostname, 255) == 0 )
+		{
+			fprintf(fp, "Hostname : %s\n", hostname);
+		}
+#ifdef LINUX
+		if ( uname(&uts) >= 0 )
+		{
+			fprintf(fp, "System : %s\n", uts.sysname);
+			fprintf(fp, "Machine : %s\n", uts.machine);
+			fprintf(fp, "Nodename : %s\n", uts.nodename);
+			fprintf(fp, "Release : %s \n", uts.release);
+			fprintf(fp, "Version : %s \n", uts.version);
+		}
+
+		// process info.
+		fprintf(fp, "Process priority : %d\n", getpriority(PRIO_PROCESS, getpid()) );
+
+		getrusage(RUSAGE_SELF, &r_usage);
+		fprintf(fp, "CPU usage : User = %ld.%06ld, System = %ld.%06ld\n",
+				r_usage.ru_utime.tv_sec, r_usage.ru_utime.tv_usec,
+				r_usage.ru_stime.tv_sec, r_usage.ru_stime.tv_usec );
+#endif
+
+	}
+
+	// host environment variables
+	{
+		extern char** environ;
+		char** env = environ;
+
+		fprintf(fp, "\n[[ Host environment variables ]]\n");
+		while(*env)
+		{
+			fprintf(fp, "%s\n", *env);
+			env++;
+		}
+	}
+
+	fprintf(fp, "g_accum_first_time = %llu\n", g_accum_first_time);
+
+	fprintf(fp, "\n\n");
+
+}
+
+
+void mm_ta_accum_show_result_fp(FILE *fp)
+{
+	int i = 0;
+	char format[256];
+
+//	__print_some_info(fp);
+
+
+	fprintf(fp, "============================ BEGIN RESULT ACCUM (usec) ====================\n");
+
+	snprintf(format, (size_t)sizeof(format), "[Idx] %%-%ds %%10s %%6s %%10s %%10s %%10s %%4s \n", g_accum_longest_name);
+
+	fprintf(fp, format, "Name", "avg", "hit", "total", "min", "max", "pair");
+
+	snprintf(format, (size_t)sizeof(format), "[%%3d] %%-%ds %%10llu %%6lu %%10llu %%10llu %%10llu %%4s \n", g_accum_longest_name);
+
+	for ( i = 0; i < g_accum_index; i++ )
+	{
+		// prevent 'devide by zero' error
+		if (g_accums[i]->num_calls == 0)
+			g_accums[i]->num_calls = 1;
+
+		fprintf(fp,
+			format,
+			i,
+			g_accums[i]->name,
+			(g_accums[i]->elapsed_accum == 0)?0:(g_accums[i]->elapsed_accum / g_accums[i]->num_calls),  // Fix it! : devide by zero.
+			g_accums[i]->num_calls,
+			g_accums[i]->elapsed_accum,
+			g_accums[i]->elapsed_min,
+			g_accums[i]->elapsed_max,
+			g_accums[i]->num_unpair == 1 ? "F" : "T" );
+	}
+
+	fprintf(fp, "============================ END RESULT ACCUM  ============================\n");
+
+	if ( fp != stdout && fp != stderr )
+	{
+		fclose(fp);
+	}
+}
+
+
+
+#ifdef STANDALONE
+int main(int argc, char* argv[])
+{
+	int a = 0, b = 0;
+
+
+	PERF_CHECK_BEGIN("Test 1");
+
+	for ( a = 0 ; a < 10; a++)
+	{
+		printf("AAA=%d\n", a);
+		usleep(1*10E6);
+	}
+
+	PERF_CHECK_END("Test 1");
+
+	printf("Test 111\n");
+	return 0;
+}
+#endif
+
+
+