path: root/main/src/slider/ivug-slider.cpp

/*
 * 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 <ui-gadget-module.h>		// ug_destroy_me, ug_send_result

#include "ivug-slider.h"
#include "ivug-common.h"

#include "ivug-parameter.h"
#include "ivug-define.h"
#include "ivug-config.h"

#include "ivug-util.h"
#include "ivug-medialist.h"
#include "ivug-media.h"

#include "ivug-drm.h"
#include "ivug-mouse-event.h"
#include "ivug-slider-item.h"

#include "ivug-slider-priv.h"

#include "ivug-image.h"

#include "Animation.h"
#include "ECoreAnimator.h"
#include "ivug-slideshow.h"
#include "EFLUtil.h"

#define LOG_CAT "IV-SLIDER"

/* local subsystem globals */
static Evas_Smart *_smart_ = NULL;

#define USE_CLIPPER

// Forward declaration
void _ivug_slider_slide_resize(struct Smart_Data *sd, Evas_Coord w, Evas_Coord h);
void _ivug_slider_slide_move(struct Smart_Data *sd, Evas_Coord x, Evas_Coord y);

const char *_GetStateString(slide_state_t state)
{
	static const char *szState[] =
	{
		"None",
		"Set",
		"Downloading",
		"DRM Checking",
		"Ready",
		"Loading",
		"Loaded",
		"Download Failed",
		"No Right",
		"Error",
	};

	return szState[state];
}

static Eina_Bool _idler_loading_func(void* data)
{
	struct Smart_Data *sd = static_cast<struct Smart_Data *>(data);

	sd->load_idler = NULL;
	MSG_SLIDER_HIGH("Do idle loading");

	int i;
	if ( sd->slide[CENTER_SLIDE]->state == SLIDE_STATE_READY )	// Center image must be loaded even while other image is loading.
	{
		ivug_slider_item_load(sd->slide[CENTER_SLIDE]);
		goto end;
	}

	for ( i = 0; i < MAX_SLIDE ; i++)
	{
		if ( sd->slide[i]->state == SLIDE_STATE_LOADING )
		{
			goto end;
		}
	}

	if ( sd->slide[NEXT_SLIDE]->state == SLIDE_STATE_READY )
	{
		ivug_slider_item_load(sd->slide[NEXT_SLIDE]);
		goto end;
	}

	if ( sd->slide[PREV_SLIDE]->state == SLIDE_STATE_READY )
	{
		ivug_slider_item_load(sd->slide[PREV_SLIDE]);
		goto end;
	}

	MSG_SLIDER_WARN("Set Data loading State=%s,%s,%s",
		_GetStateString(sd->slide[PREV_SLIDE]->state),
		_GetStateString(sd->slide[CENTER_SLIDE]->state),
		_GetStateString(sd->slide[NEXT_SLIDE]->state)
	);

end:
	return ECORE_CALLBACK_CANCEL;

}

static void _do_load(struct Smart_Data *sd)
{
	if ( sd->load_idler )
	{
		ecore_idler_del(sd->load_idler);
		sd->load_idler = NULL;
	}

	MSG_SLIDER_HIGH("Add idler for loading.");
	sd->load_idler = ecore_idler_add(_idler_loading_func, sd);
}

static void _ivug_slider_on_center_changed(Evas_Object *obj, Slide_Item *old, Slide_Item *cur)
{
	IV_ASSERT(old != cur );

	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);

	if ( old != NULL )
	{
		ivug_slider_item_zoom_reset(old, EINA_TRUE, 0, 0);

		ivug_slider_item_pause(old);		// Pause DRM consume/Animation
	}

	if(cur->state == SLIDE_STATE_LOADED)
	{
		ivug_slider_item_play(cur);
	}
	else
	{
		MSG_SLIDER_ERROR("Invalid state : %s", _GetStateString(cur->state));
	}

	MSG_SLIDER_HIGH("Center item changed. State=%s", _GetStateString(cur->state));

	evas_object_smart_callback_call(sd->obj, "slider,item,changed", cur);
}

void _ivug_slider_item_state_changed(slide_state_t state, Slide_Item *si, void *client_data)
{
	struct Smart_Data *sd = static_cast<struct Smart_Data *>(client_data);
	IV_ASSERT(sd != NULL);

	if ( sd->slide[CENTER_SLIDE] == si )
	{
		MSG_SLIDER_HIGH("Center Item state changed. Old=%s New=%s", _GetStateString(state), _GetStateString(si->state));

		if ( state == SLIDE_STATE_LOADED )
		{
			ivug_slider_item_play(si);
			evas_object_smart_callback_call(sd->obj, "slider,item,state,changed", si);
		}
		else
		{
			evas_object_smart_callback_call(sd->obj, "slider,item,state,changed", si);
		}
	}

	_do_load(sd);

}

static void _on_event_mouse_down(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
	MSG_SLIDER_HIGH("Event layer clicked : %s Layer=%d", evas_object_name_get(obj), evas_object_layer_get(obj));
}

static Eina_Bool _item_loader(void* data)
{
	IV_ASSERT(data != NULL);
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get((Evas_Object *)data);

	sd->item_load_idler = NULL;

	Slide_Item *si = sd->slide[CENTER_SLIDE];

	si->state = SLIDE_STATE_READY;

	ivug_slider_item_load(si);

	return ECORE_CALLBACK_CANCEL;
}

static void _sizing_eval(void *data)
{
	struct Smart_Data *sd = (struct Smart_Data *)data;

	sd->calc_job = NULL;

	MSG_SLIDER_HIGH("Object geometry resized. (%d,%d,%d,%d)", sd->x, sd->y , sd->w , sd->h);

#ifdef USE_CLIPPER
	evas_object_move(sd->clipper, sd->x, sd->y);
	evas_object_resize(sd->clipper, sd->w, sd->h);
#endif

	evas_object_move(sd->event_obj, sd->x, sd->y);
	evas_object_resize(sd->event_obj, sd->w, sd->h);

	evas_object_smart_changed(sd->obj);
}

static void
_ivug_slider_smart_add(Evas_Object *obj)
{
	MSG_SLIDER_HIGH("Slider Add : 0x%08x", obj);

	PERF_CHECK_BEGIN(LVL4, "slider smart add");

	struct Smart_Data *sd = (struct Smart_Data *)calloc(1, sizeof(struct Smart_Data));
   	ivug_ret_if(!sd);
   	evas_object_smart_data_set(obj, sd);

	sd->obj = obj;
	sd->momentum = 0;

	sd->anim = new ECoreAnimator();

	sd->edge = EDGE::SLIDE_FIT;
	sd->last_dir = SLIDE_SHIFT_TO_RIGHT;	/* default for first loading*/
	sd->bPassEvent = false;

	//create slider item.
	for (int idx = 0; idx < MAX_SLIDE; idx++)
	{
		PERF_CHECK_BEGIN(LVL5, "add slider item");
		sd->slide[idx] = ivug_slider_item_add(obj);
		PERF_CHECK_END(LVL5, "add slider item");

		ivug_slider_item_set_callback(sd->slide[idx], _ivug_slider_item_state_changed, sd);
	}

	sd->event_obj = evas_object_rectangle_add(evas_object_evas_get(obj));
	evas_object_name_set(sd->event_obj, "slider-event");
	evas_object_color_set(sd->event_obj , 0, 0, 0, 0);		// Fully Transparent object.
	evas_object_size_hint_align_set(sd->event_obj, EVAS_HINT_FILL, EVAS_HINT_FILL);
	evas_object_size_hint_weight_set(sd->event_obj, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
	evas_object_repeat_events_set(sd->event_obj, EINA_TRUE);
	evas_object_show(sd->event_obj);

	evas_object_smart_member_add(sd->event_obj, obj);

	sd->gesture = elm_gesture_layer_add(sd->event_obj);
	elm_gesture_layer_hold_events_set(sd->gesture, EINA_FALSE);

	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_START, _zoom_start, obj);
	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_MOVE, _zoom_move, obj);
	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_END, _zoom_end, obj);
	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_ABORT, _zoom_abort, obj);

	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_MOMENTUM, ELM_GESTURE_STATE_START, _momentum_start, obj);
	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_MOMENTUM, ELM_GESTURE_STATE_MOVE, _momentum_move, obj);
	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_MOMENTUM, ELM_GESTURE_STATE_END, _momentum_end, obj);
	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_MOMENTUM, ELM_GESTURE_STATE_ABORT, _momentum_abort, obj);
	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_N_FLICKS, ELM_GESTURE_STATE_START, _flick_start, obj);
	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_N_FLICKS, ELM_GESTURE_STATE_END, _flick_move, obj);
	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_N_FLICKS, ELM_GESTURE_STATE_END, _flick_end, obj);
	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_N_FLICKS, ELM_GESTURE_STATE_ABORT, _flick_abort, obj);

	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_N_DOUBLE_TAPS, ELM_GESTURE_STATE_START, _dbl_click_start, obj);
	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_N_DOUBLE_TAPS, ELM_GESTURE_STATE_END, _dbl_click_end, obj);
	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_N_DOUBLE_TAPS, ELM_GESTURE_STATE_ABORT, _dbl_click_abort, obj);

	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_N_TAPS, ELM_GESTURE_STATE_START, n_finger_tap_start, obj);
	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_N_TAPS, ELM_GESTURE_STATE_END, n_finger_tap_end, obj);
	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_N_TAPS, ELM_GESTURE_STATE_ABORT, n_finger_tap_abort, obj);

	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_N_LONG_TAPS, ELM_GESTURE_STATE_START, n_long_tap_start, obj);
	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_N_LONG_TAPS, ELM_GESTURE_STATE_MOVE, n_long_tap_move, obj);
	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_N_LONG_TAPS, ELM_GESTURE_STATE_END, n_long_tap_end, obj);
	elm_gesture_layer_cb_set(sd->gesture, ELM_GESTURE_N_LONG_TAPS, ELM_GESTURE_STATE_ABORT, n_long_tap_abort, obj);

	if ( elm_gesture_layer_attach(sd->gesture, sd->event_obj) == EINA_FALSE)
	{
		MSG_SLIDER_ERROR("Cannot attach event rect");
	}
	evas_object_name_set(sd->gesture, "Slider:Getsture");

	evas_object_event_callback_add(obj, EVAS_CALLBACK_MOUSE_DOWN, _on_event_mouse_down, NULL);
	evas_object_event_callback_add(sd->event_obj, EVAS_CALLBACK_MOUSE_DOWN, _on_event_mouse_down, NULL);

	sd->bLongtapEnable = true;

#if 0
	for (int idx = 0; idx < MAX_SLIDE; idx++)
	{
		// Video iconÀÌ event¸¦ ¸ÕÀú ¹Þ°Ô Çϱâ À§ÇØ z orderÀ» º¯°æ ÇÑ´Ù.
		evas_object_stack_above(sd->slide[idx]->vIcon, sd->event_obj);
	}
#endif


#ifdef USE_CLIPPER
	sd->clipper = evas_object_rectangle_add(evas_object_evas_get(obj));
	evas_object_color_set(sd->clipper, 255,255,255,255);
	evas_object_smart_member_add(sd->clipper, obj);
	evas_object_name_set(sd->clipper, "slider-clipper");

	MSG_SLIDER_HIGH("Create clipper(0x%08x)", sd->clipper);

	evas_object_show(sd->clipper);
#endif

	PERF_CHECK_END(LVL4, "slider smart add");

	return;

}

static void
_ivug_slider_smart_del(Evas_Object *obj)
{
	MSG_SLIDER_HIGH("Slider delete. obj=0x%08x", obj);

	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);
	ivug_ret_if(!sd);

	if ( sd->tween) delete sd->tween;
	sd->tween = NULL;

	if ( sd->anim) delete sd->anim;
	sd->anim = NULL;

	if ( sd->item_load_idler )
	{
		ecore_idler_del(sd->item_load_idler);
		sd->item_load_idler = NULL;
	}

	if ( sd->load_idler )
	{
		ecore_idler_del(sd->load_idler);
		sd->load_idler = NULL;
	}

	if ( sd->calc_job ) ecore_job_del(sd->calc_job);
	sd->calc_job = NULL;

	if ( sd->event_obj )
	{
		evas_object_del(sd->event_obj);
		sd->event_obj = NULL;
	}

	if ( sd->gesture )
	{
		evas_object_del(sd->gesture);
		sd->gesture = NULL;
	}

	for (int i = 0; i < MAX_SLIDE ; i++) 	//delete layout
	{
		ivug_slider_item_del(sd->slide[i]);
		sd->slide[i] = NULL;
	}

#ifdef USE_CLIPPER
	if ( sd->clipper )
	{
		evas_object_del(sd->clipper);
		sd->clipper = NULL;
	}
#endif

	free(sd);

}


static void
_ivug_slider_smart_move(Evas_Object *obj, Evas_Coord x, Evas_Coord y)
{
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);
	MSG_ASSERT(sd != NULL);

	if ((sd->x == x) && (sd->y == y)) return;

	MSG_SLIDER_MED("Slider Move : XY(%d,%d)", x, y);

   	sd->x = x;
   	sd->y = y;

#ifdef USE_CALC_JOB
	if ( sd->calc_job ) ecore_job_del(sd->calc_job);
	sd->calc_job = NULL;

	sd->calc_job = ecore_job_add(_sizing_eval, sd);
#else
	evas_object_smart_changed(obj);
#endif

}

static void
_ivug_slider_smart_resize(Evas_Object *obj, Evas_Coord w, Evas_Coord h)
{
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);
	MSG_ASSERT(sd != NULL);

	if ((sd->w == w) && (sd->h == h)) return;

	MSG_SLIDER_MED("Slider Resize : WH(%d,%d)", w,h);

	sd->w = w;
	sd->h = h;

#ifdef USE_CALC_JOB
	if ( sd->calc_job ) ecore_job_del(sd->calc_job);
	sd->calc_job = NULL;

	sd->calc_job = ecore_job_add(_sizing_eval, sd);
#else
	evas_object_smart_changed(obj);
#endif

}

static void
_ivug_slider_smart_show(Evas_Object *obj)
{
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);
	MSG_ASSERT(sd != NULL);

	if ( sd->bShow == EINA_TRUE) return;

	sd->bShow = EINA_TRUE;

	MSG_SLIDER_HIGH("Slider Show");

	ivug_slider_item_show(sd->slide[CENTER_SLIDE]);
	ivug_slider_item_show(sd->slide[NEXT_SLIDE]);
	ivug_slider_item_show(sd->slide[PREV_SLIDE]);

	evas_object_show(sd->event_obj);
	evas_object_show(sd->clipper);
}

static void
_ivug_slider_smart_hide(Evas_Object *obj)
{
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);
	MSG_ASSERT(sd != NULL);

	if ( sd->bShow == EINA_FALSE) return;

	sd->bShow = EINA_FALSE;

	MSG_SLIDER_HIGH("Slider Hide");

	ivug_slider_item_hide(sd->slide[CENTER_SLIDE]);
	ivug_slider_item_hide(sd->slide[NEXT_SLIDE]);
	ivug_slider_item_hide(sd->slide[PREV_SLIDE]);

	evas_object_hide(sd->event_obj);
	evas_object_hide(sd->clipper);
}

static void
_ivug_slider_smart_clip_set(Evas_Object *obj, Evas_Object * clip)
{
	int x, y, w, h;
	evas_object_geometry_get(clip, &x, &y, &w, &h);
	MSG_SLIDER_HIGH("Slider Clip set : Clipper=0x%08x (%d,%d,%d,%d)", x, y, w, h);

#ifdef USE_CLIPPER
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);

	for (int i = 0; i < MAX_SLIDE; i++)
	{	//set resize
		ivug_slider_item_clip_set(sd->slide[i], sd->clipper);
	}

	evas_object_clip_set(sd->event_obj, sd->clipper);
#endif

}

static void
_ivug_slider_smart_clip_unset(Evas_Object *obj)
{
	MSG_SLIDER_HIGH("Slider Clip unset");

#ifdef USE_CLIPPER
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);

	for (int i = 0; i < MAX_SLIDE; i++)
	{	//set resize
		ivug_slider_item_clip_unset(sd->slide[i]);
	}

	evas_object_clip_unset(sd->event_obj);
#endif

}

static void
_ivug_slider_smart_calculate(Evas_Object *obj)
{
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);
	if ((sd->w == 0) || (sd->h == 0)) return;

	MSG_SLIDER_MED("Slider Calculate : XYWH(%d,%d, %d,%d)", sd->x, sd->y, sd->w, sd->h);

	sd->anim->Stop();

	_ivug_slider_slide_resize(sd, sd->w, sd->h);
	_ivug_slider_slide_move(sd, sd->x, sd->y);
}

// Smart Object
static void
_ivug_slider_smart_init(void)
{
	if (_smart_) return;
	{
		const char* name = eina_stringshare_add("ivug-slider");
		MSG_SLIDER_MED("name=%s", name);
		static Evas_Smart_Class sc =
		{
			NULL,
			EVAS_SMART_CLASS_VERSION,
			_ivug_slider_smart_add,
			_ivug_slider_smart_del,
			_ivug_slider_smart_move,
			_ivug_slider_smart_resize,
			_ivug_slider_smart_show,
			_ivug_slider_smart_hide,
			NULL,
			_ivug_slider_smart_clip_set,
			_ivug_slider_smart_clip_unset,
			_ivug_slider_smart_calculate,
			NULL,
			NULL,
			NULL,
			NULL,
			NULL,
			NULL
		};	//Evas_smart_Class
		sc.name = name;
		_smart_ = evas_smart_class_new(&sc);
	}
}


/******* slide UI function *******/

void
_ivug_slider_slide_move(struct Smart_Data *sd, Evas_Coord x, Evas_Coord y)
{
	IV_ASSERT(sd != NULL);

	MSG_SLIDER_LOW("Slider move. XY(%d,%d)", x, y);
#if 0
	int nOffset = 100;		// For debugging
	x += nOffset;
#endif
// TODO : If size is smaller than screen's, image should be put in middle
	ivug_slider_item_move(sd->slide[CENTER_SLIDE], x, y);

// TODO : so as to increas perf, dont draw slide under certain condition
	ivug_slider_item_move(sd->slide[PREV_SLIDE], x - sd->slide[PREV_SLIDE]->w - IMAGE_BETWEEN_MARGIN , y);
	ivug_slider_item_move(sd->slide[NEXT_SLIDE], x + sd->slide[CENTER_SLIDE]->w + IMAGE_BETWEEN_MARGIN , y);
}

void
_ivug_slider_slide_resize(struct Smart_Data *sd, Evas_Coord w, Evas_Coord h)
{
	IV_ASSERT(sd != NULL);

	ivug_slider_item_resize(sd->slide[CENTER_SLIDE], sd->w, sd->h);
	ivug_slider_item_resize(sd->slide[PREV_SLIDE], sd->w, sd->h);
	ivug_slider_item_resize(sd->slide[NEXT_SLIDE], sd->w, sd->h);
}


static void _ivug_slider_on_tween(double value, void *data)
{
	struct Smart_Data *sd = (struct Smart_Data *)data;

	_ivug_slider_slide_move(sd, value, sd->y);
}

static void _ivug_slider_on_moment(double value, void *data)
{
	struct Smart_Data *sd = (struct Smart_Data *)data;

	sd->momentum = value;
}

static bool _ivug_slider_on_ecore_animator(double value, void *pData)
{
	struct Smart_Data *sd = (struct Smart_Data *)pData;

	if ( sd->tween->IsFinished() )
	{
		MSG_SLIDER_HIGH("animation ended");

		shift_direction_t direction = SLIDE_SHIFT_NONE;

		if ( (sd->slide[CENTER_SLIDE]->x - sd->x) + sd->slide[CENTER_SLIDE]->w < 0 )
		{
			direction = SLIDE_SHIFT_TO_RIGHT;
		}
		else if ( (sd->slide[CENTER_SLIDE]->x - sd->x) > sd->w )
		{
			direction = SLIDE_SHIFT_TO_LEFT;
		}

		_ivug_slider_slide_shift(sd, direction);		// Change center item

		delete sd->tween;
		sd->tween = NULL;
		return false;
	}

	MSG_SLIDER_LOW("On Animaion. %f ", value);

	sd->tween->Update(value);

	return true;
}

void
_ivug_slider_start_slide(struct Smart_Data *sd, int src_x, int dst_x, int momentum)
 {
 // Slider Move animation.
	IV_ASSERT(sd != NULL);

// TODO : If transition is preceeding, change slide item,
	sd->anim->Stop();

	if ( sd->tween ) delete sd->tween;
	sd->tween = NULL;

	if ( src_x == dst_x )
	{
		MSG_SLIDER_ERROR("Src and Dest are same.");
		return;
	}

	double duration;

	duration = (src_x - dst_x) / (double)momentum;

	duration = fabs(duration);

	sd->tween = new CGroupAnimator();

	sd->tween->AddAnimator(new CSingleAnimator(src_x, dst_x, duration, CTranstionFunc::LinearTransit, _ivug_slider_on_tween, sd));
	sd->tween->AddAnimator(new CSingleAnimator(sd->momentum, 0, duration, CTranstionFunc::LinearTransit, _ivug_slider_on_moment, sd));

	sd->anim->Start(_ivug_slider_on_ecore_animator, (void *)sd);

	MSG_SLIDER_HIGH("Start scroll anim from %d~%d duration=%f Momentyum=%d~%d", src_x, dst_x, duration, sd->momentum, sd->momentum + (src_x - dst_x));

}

void
_ivug_slider_slide_shift(struct Smart_Data *sd, shift_direction_t direction)
{
	IV_ASSERT(sd != NULL);

	if ( direction == SLIDE_SHIFT_NONE )
	{
		MSG_SLIDER_ERROR("Shift none!. just return");
		return;
	}

	sd->zoom_level = 0;	//reset zoom level

	Media_Item *item = NULL;
	Slide_Item *NewItem = NULL;

	if ( direction == SLIDE_SHIFT_TO_RIGHT )
	{
		MSG_SLIDER_HIGH( "Slide shited. <-----");

		NewItem = sd->slide[PREV_SLIDE];

		item = ivug_medialist_get_next(sd->media_list, sd->slide[NEXT_SLIDE]->mitem);

		sd->slide[PREV_SLIDE] = sd->slide[CENTER_SLIDE];
		sd->slide[CENTER_SLIDE] = sd->slide[NEXT_SLIDE];
		sd->slide[NEXT_SLIDE] = NewItem;

	}
	else
	{
		MSG_SLIDER_HIGH( "Slide shited. ----->");

		NewItem = sd->slide[NEXT_SLIDE];
		item = ivug_medialist_get_prev(sd->media_list, sd->slide[PREV_SLIDE]->mitem);

		sd->slide[NEXT_SLIDE] = sd->slide[CENTER_SLIDE];
		sd->slide[CENTER_SLIDE] = sd->slide[PREV_SLIDE];
		sd->slide[PREV_SLIDE] = NewItem;
	}

	ivug_slider_item_data_set(NewItem, item); //set data.

	_do_load(sd);

	MSG_SLIDER_HIGH("Center slide. XY(%d,%d)", sd->slide[CENTER_SLIDE]->x , sd->slide[CENTER_SLIDE]->y);

	sd->last_dir = direction;

	if ( direction == SLIDE_SHIFT_TO_RIGHT )
	{
		_ivug_slider_on_center_changed(sd->obj, sd->slide[PREV_SLIDE], sd->slide[CENTER_SLIDE]);
	}
	else
	{
		_ivug_slider_on_center_changed(sd->obj, sd->slide[NEXT_SLIDE], sd->slide[CENTER_SLIDE]);
	}

}


Evas_Object*
ivug_slider_add(Evas_Object* parent)
{
	Evas_Object *obj = NULL;
	_ivug_slider_smart_init();	//init smart object for ivug slider

	PERF_CHECK_BEGIN(LVL3, "evas_object_smart_add");

	obj = evas_object_smart_add(evas_object_evas_get(parent), _smart_);	//create smart object.
	evas_object_name_set(obj, "Slider");

	ivug_retv_if(!obj, NULL);

	PERF_CHECK_END(LVL3, "evas_object_smart_add");

	MSG_SLIDER_HIGH("Slider Added Obj(0x%08x) Evas(0x%08x) Parent(0x%08x)", obj, evas_object_evas_get(parent), parent);

	return obj;
}

void
ivug_slider_start(Evas_Object *obj)
{
	IV_ASSERT(obj != NULL);
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);

	MSG_SLIDER_HIGH("Slider start");

}


Media_Item *
ivug_slider_get_item(Evas_Object* obj)
{
	IV_ASSERT(obj != NULL);
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);

	return sd->slide[CENTER_SLIDE]->mitem;
}

slide_state_t
ivug_slider_get_state(Evas_Object* obj)
{
	IV_ASSERT(obj != NULL);
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);
	IV_ASSERT(sd != NULL);

	return sd->slide[CENTER_SLIDE]->state;
}

void
ivug_slider_delete_item(Evas_Object* obj)
{
	IV_ASSERT(obj != NULL);
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);
	IV_ASSERT(sd != NULL);

	ivug_slider_item_stop(sd->slide[CENTER_SLIDE]);

	shift_direction_t direction = SLIDE_SHIFT_NONE;

	if (sd->slide[NEXT_SLIDE]->state != SLIDE_STATE_NONE)
	{
		MSG_SLIDER_HIGH("right slide state : %s", _GetStateString(sd->slide[NEXT_SLIDE]->state));
		direction = SLIDE_SHIFT_TO_RIGHT;
	}
	else if (sd->slide[PREV_SLIDE]->state != SLIDE_STATE_NONE)
	{
		MSG_SLIDER_HIGH("left slide state : %s", _GetStateString(sd->slide[PREV_SLIDE]->state));
		direction = SLIDE_SHIFT_TO_LEFT;
	}

	MSG_SLIDER_HIGH("shift direction = %d ", direction);

	ivug_medialist_delete_item(sd->media_list,  sd->slide[CENTER_SLIDE]->mitem );	//delete data.
	ivug_slider_item_data_set(sd->slide[CENTER_SLIDE], NULL);

	Media_Item* item = NULL;

//move slide.
	if (  direction  ==  SLIDE_SHIFT_TO_RIGHT )		// <-------------- Next image
	{
		Slide_Item *tmp = sd->slide[CENTER_SLIDE];

		item = ivug_medialist_get_next(sd->media_list, sd->slide[NEXT_SLIDE]->mitem); //get next data.

		sd->slide[CENTER_SLIDE] = sd->slide[NEXT_SLIDE];
		sd->slide[NEXT_SLIDE] = tmp;

		if(item != NULL)
		{
			ivug_slider_item_data_set(sd->slide[NEXT_SLIDE],  item);
			ivug_slider_item_load(sd->slide[NEXT_SLIDE]);
		}
		else
		{
			MSG_SLIDER_WARN("Item is NULL");
		}
	}
	else if ( direction  ==  SLIDE_SHIFT_TO_LEFT)		// Prev Image ----------->
	{
		Slide_Item *tmp = sd->slide[CENTER_SLIDE];

		item = ivug_medialist_get_prev(sd->media_list, sd->slide[PREV_SLIDE]->mitem);

		sd->slide[CENTER_SLIDE] = sd->slide[PREV_SLIDE];
		sd->slide[PREV_SLIDE] = tmp;

		if(item != NULL)
		{
			ivug_slider_item_data_set(sd->slide[PREV_SLIDE], item);
			ivug_slider_item_load(sd->slide[PREV_SLIDE]);
		}
		else
		{
			MSG_SLIDER_WARN("Item is NULL");
		}
	}
	else		// Shift none
	{
		MSG_SLIDER_WARN("Direction is NONE");
	}

	_ivug_slider_slide_move(sd, 0 , 0);	//draw item

	_ivug_slider_on_center_changed(sd->obj, NULL, sd->slide[CENTER_SLIDE]);

//	evas_object_smart_callback_call(sd->obj, "slider,item,deleted", sd->slide[CENTER_SLIDE]);

}

Eina_Bool
ivug_slider_set_medialist(Evas_Object* obj, Media_List *mList, Media_Item *current)
{
	IV_ASSERT(obj != NULL);
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);
	IV_ASSERT(current != NULL);

	sd->media_list = mList;

	//set init
	PERF_CHECK_BEGIN(LVL4, "set center");

	ivug_slider_item_data_set(sd->slide[CENTER_SLIDE], current);
	ivug_slider_item_load(sd->slide[CENTER_SLIDE]);

	PERF_CHECK_END(LVL4, "set center");

	Media_Item *item = ivug_medialist_get_next(sd->media_list, current);

	PERF_CHECK_BEGIN(LVL4, "set next");

	ivug_slider_item_data_set(sd->slide[NEXT_SLIDE], item);

	PERF_CHECK_END(LVL4, "set next");

	item = ivug_medialist_get_prev(sd->media_list, current);

	PERF_CHECK_BEGIN(LVL4, "set prev");

	ivug_slider_item_data_set(sd->slide[PREV_SLIDE], item);

	PERF_CHECK_END(LVL4, "set prev");

	PERF_CHECK_BEGIN(LVL4, "_ivug_slider_on_center_changed");

	_ivug_slider_on_center_changed(sd->obj, NULL, sd->slide[CENTER_SLIDE]);

	PERF_CHECK_END(LVL4, "_ivug_slider_on_center_changed");

	return EINA_TRUE;
}//ivug slider set list

void
ivug_slider_set_item(Evas_Object* obj, Media_Item *newItem, slide_dir_t dir)
{
	IV_ASSERT(obj != NULL);
	IV_ASSERT(newItem != NULL);

	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);

	MSG_SLIDER_HIGH("Slider set item. Dir=%d", dir);

	Media_Item *mitem = NULL;

	if ( ivug_slider_item_data_get(sd->slide[CENTER_SLIDE]) == newItem )
	{
		MSG_SLIDER_HIGH("Same item.");
		return ;
	}

	switch(dir)
	{
		case SLIDE_TO_RIGHT:		// <--------------- Next image
			ivug_slider_item_data_set(sd->slide[NEXT_SLIDE], newItem);

			_ivug_slider_start_slide(sd, sd->slide[CENTER_SLIDE]->x , sd->slide[CENTER_SLIDE]->w + IMAGE_BETWEEN_MARGIN, ANIN_VELOCITY);

			mitem = ivug_medialist_get_prev(sd->media_list, newItem);

			ivug_slider_item_data_set(sd->slide[PREV_SLIDE], mitem);
			break;
		case SLIDE_TO_LEFT:			// Prev Image ------------------>
			ivug_slider_item_data_set(sd->slide[PREV_SLIDE], newItem);

			_ivug_slider_start_slide(sd, sd->slide[CENTER_SLIDE]->x , sd->slide[CENTER_SLIDE]->w + IMAGE_BETWEEN_MARGIN, ANIN_VELOCITY);

			mitem = ivug_medialist_get_next(sd->media_list, newItem);

			ivug_slider_item_data_set(sd->slide[NEXT_SLIDE], mitem);
			break;
		case SLIDE_INSTANTLY:
// For avoid blinking, set item in next_slide and then swap with center
			ivug_slider_item_data_set(sd->slide[NEXT_SLIDE], newItem);

			Slide_Item *sitem = sd->slide[CENTER_SLIDE];
			sd->slide[CENTER_SLIDE] = sd->slide[NEXT_SLIDE];
			sd->slide[NEXT_SLIDE] = sitem;

			_ivug_slider_slide_move(sd, 0, 0);

			mitem = ivug_medialist_get_next(sd->media_list, newItem);
			ivug_slider_item_data_set(sd->slide[NEXT_SLIDE], mitem);

			mitem = ivug_medialist_get_prev(sd->media_list, newItem);
			ivug_slider_item_data_set(sd->slide[PREV_SLIDE], mitem);

			_ivug_slider_on_center_changed(sd->obj, sitem , sd->slide[CENTER_SLIDE]);
			break;
	}

}


// Goto Background
void
ivug_slider_pause(Evas_Object *obj)
{
	IV_ASSERT(obj != NULL);
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);

	MSG_SLIDER_HIGH("Slider pause");

	ivug_slider_item_pause(sd->slide[CENTER_SLIDE]);
}

// Goto Foreground
void
ivug_slider_resume(Evas_Object *obj)
{
	IV_ASSERT(obj != NULL);
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);

	MSG_SLIDER_HIGH("Slider resume");

	ivug_slider_item_resume(sd->slide[CENTER_SLIDE]);
}

void
ivug_slider_skip(Evas_Object* obj)
{
	ivug_ret_if(!obj);		// TODO
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);

	if ( sd->last_dir == SLIDE_SHIFT_TO_RIGHT) // <--------------
	{
		if(sd->slide[NEXT_SLIDE]->mitem == NULL)
		{
			MSG_SLIDER_HIGH("next is NULL");
			if(sd->slide[PREV_SLIDE]->mitem == NULL)
			{
				MSG_SLIDER_HIGH("prev is NULL too, exit Image viewer");
				ug_destroy_me(gGetUGHandle());
				return;
			}
			_ivug_slider_start_slide(sd, sd->slide[CENTER_SLIDE]->x , sd->slide[CENTER_SLIDE]->w + IMAGE_BETWEEN_MARGIN, ANIN_VELOCITY);
		}
		else
		{
			_ivug_slider_start_slide(sd, sd->slide[CENTER_SLIDE]->x , -sd->slide[CENTER_SLIDE]->w - IMAGE_BETWEEN_MARGIN, ANIN_VELOCITY);
		}
	}
	else if (sd->last_dir == SLIDE_SHIFT_TO_LEFT)  // -------------->
	{
		if(sd->slide[PREV_SLIDE]->mitem == NULL)
		{
			MSG_SLIDER_HIGH("prev is NULL");
			if(sd->slide[NEXT_SLIDE]->mitem == NULL)
			{
				MSG_SLIDER_HIGH("mext is NULL too, exit Image viewer");
				ug_destroy_me(gGetUGHandle());
				return;
			}
			_ivug_slider_start_slide(sd, sd->slide[CENTER_SLIDE]->x , -sd->slide[CENTER_SLIDE]->w - IMAGE_BETWEEN_MARGIN, ANIN_VELOCITY);
		}
		else
		{
			_ivug_slider_start_slide(sd, sd->slide[CENTER_SLIDE]->x , sd->slide[CENTER_SLIDE]->w + IMAGE_BETWEEN_MARGIN, ANIN_VELOCITY);
		}
	}
}

bool ivug_slider_load(Evas_Object* obj)
{
	IV_ASSERT(obj != NULL);
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);

	ivug_retv_if(!sd, EINA_FALSE);	//check smart data.

	if ( sd->item_load_idler )
	{
		ecore_idler_del(sd->item_load_idler);
		sd->item_load_idler = NULL;
	}

	sd->item_load_idler = ecore_idler_add(_item_loader, (void *)obj);

	return true;
}

void
ivug_slider_set_menu_visibility(Evas_Object* obj, Eina_Bool bVisible)
{
	IV_ASSERT(obj != NULL);
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);

	Slide_Item *si = sd->slide[CENTER_SLIDE];

	if ( bVisible == EINA_TRUE )
	{
		ivug_slider_item_show_menu(si);
	}
	else
	{
		ivug_slider_item_hide_menu(si);
	}
}




// For debugging.
void ivug_slider_dump_photocam(Evas_Object* obj)
{
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);

//	EFL::dump_obj(sd->slide[CENTER_SLIDE]->photocam, 0);
//	EFL::dump_obj(obj, 0);

	Evas_Object *clipper;

	clipper = evas_object_clip_get(obj);
	if (clipper)
	{
		Eina_List *clippees;

		Eina_List *l;

		clippees = (Eina_List *)evas_object_clipees_get(clipper);
		MSG_SLIDER_HIGH("Clipper clips %i objects", eina_list_count(clippees));

		void *data;

		EINA_LIST_FOREACH(clippees, l, data)
		{
			Evas_Object *obj_tmp = (Evas_Object *)data;

			int x, y, w, h;
			evas_object_geometry_get(obj_tmp, &x, &y, &w, &h);

			MSG_SLIDER_HIGH("Obj=%s(%s) Geometry(%d,%d,%d,%d)",
				evas_object_name_get(obj_tmp), evas_object_type_get(obj_tmp),
				x, y, w, h);
		//	evas_object_show(obj_tmp);
		}
	}


	Evas *e = evas_object_evas_get(sd->slide[CENTER_SLIDE]->photocam);

	int w, h;

	evas_output_size_get(e, &w, &h);

	int vx, vy, vw, vh;

	evas_output_viewport_get(e, &vx, &vy, &vw, &vh);

	EFL::dump_obj(sd->obj);

	MSG_SLIDER_HIGH("Evas Size(%d,%d) Viewport(%d,%d,%d,%d)", w, h, vx, vy, vw, vh);

}

unsigned int
ivug_slider_zoom_level_get(Evas_Object *obj)
{
	IV_ASSERT(obj != NULL);
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);

	MSG_SLIDER_HIGH("Slider zoom level");

	return sd->zoom_level;
}

void
ivug_slider_zoom_in(Evas_Object *obj)
{
	IV_ASSERT(obj != NULL);
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);

	MSG_SLIDER_HIGH("Slider zoom in");

	if(sd->zoom_level > ZOOM_LEVEL_MAX)
	{
		MSG_MAIN_ERROR("zoom_level is %d", sd->zoom_level);
		return;
	}

	Slide_Item *si = sd->slide[CENTER_SLIDE];

	double zoom = 0.0;
	Evas_Coord ix = 0, iy= 0, iw= 0, ih= 0;

	evas_object_geometry_get(si->photocam, &ix, &iy, &iw, &ih);

	zoom = ivug_slider_item_zoom_get(si);
	zoom *= ZOOM_LEVEL_STEP;
	ivug_slider_item_zoom_set(si, zoom, iw/2, ih/2);

	ivug_slider_item_hold_set(si, EINA_FALSE);

	sd->zoom_level++;
}

void
ivug_slider_zoom_out(Evas_Object *obj)
{
	IV_ASSERT(obj != NULL);
	struct Smart_Data *sd = (struct Smart_Data *) evas_object_smart_data_get(obj);

	MSG_SLIDER_HIGH("Slider zoom in");

	if(sd->zoom_level == 0)
	{
		MSG_MAIN_ERROR("zoom_level is 0");
		return;
	}

	Slide_Item *si = sd->slide[CENTER_SLIDE];

	double zoom = 0.0;
	Evas_Coord ix = 0, iy= 0, iw= 0, ih= 0;

	evas_object_geometry_get(si->photocam, &ix, &iy, &iw, &ih);

	zoom = ivug_slider_item_zoom_get(si);
	zoom /= ZOOM_LEVEL_STEP;
	ivug_slider_item_zoom_set(si, zoom, iw/2, ih/2);

	ivug_slider_item_hold_set(si, EINA_FALSE);

	sd->zoom_level--;
}