path: root/src/util/listmgr.c

/*
 * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
 *
 * 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 <media_content.h>
#include <app_debug.h>
#include <app_media.h>
#include <gridmgr.h>
#include <inputmgr.h>

#include "define.h"
#include "data/mediadata.h"
#include "util/listmgr.h"
#include "util/util.h"

#define MAX_GRID_WIDTH 1858

#define SCROLLER_STEP_SIZE(x) ((x) + 10)

enum _object_type {
	LISTMGR_SCROLLER = 0,
	LISTMGR_INDEX,
	LISTMGR_PLAY_INFO,
	LISTMGR_GRID
};

struct listmgr {
	Evas_Object *base;
	Evas_Object *scr;
	Evas_Object *box;
	Evas_Object *play_info;
	Evas_Object *focused;

	Elm_Object_Item *focused_it;
	Elm_Object_Item *selected_it;

	struct gridmgr *gmgr;
	struct listmgr_data *data;

	Eina_Bool show_play_info;
	Eina_Bool focus_state;
};

static void _key_down_cb(int id, void *data, Evas *e, Evas_Object *obj,
			Evas_Event_Key_Down *ev)
{
	struct listmgr *lmgr;
	struct grid_ops *gops;

	if (!data || !obj || !ev)
		return;

	lmgr = data;

	switch (id) {
	case LISTMGR_INDEX:
		if (!strcmp(ev->keyname, KEY_BACK) ||
			!strcmp(ev->keyname, KEY_BACK_REMOTE)) {
			elm_object_focus_next(obj, ELM_FOCUS_UP);
		} else if (!strcmp(ev->keyname, KEY_DOWN)) {
			Evas_Object *grid;
			Elm_Object_Item *it;

			if (lmgr->play_info == lmgr->focused)
				break;

			grid = elm_object_part_content_get(lmgr->focused,
						PART_ITEM_CONTENT);
			it = elm_gengrid_first_item_get(grid);
			if (it)
				elm_object_item_focus_set(it, EINA_TRUE);
		}

		break;
	case LISTMGR_PLAY_INFO:
	case LISTMGR_GRID:
		if (!strcmp(ev->keyname, KEY_BACK) ||
			!strcmp(ev->keyname, KEY_BACK_REMOTE))
			elm_object_focus_next(obj, ELM_FOCUS_UP);
		else {
			gops = lmgr->data->gops;
			if (gops->key_down_cb)
				gops->key_down_cb(gops->ops_data,
							lmgr->focused_it, ev);
		}

		break;
	default:
		break;
	}
}

static void _mouse_move_cb(int id, void *data, Evas *e, Evas_Object *obj,
			Evas_Event_Mouse_Move *ev)
{
	Elm_Object_Item *it;
	struct listmgr *lmgr;

	if (!data || !obj || !ev)
		return;

	lmgr = data;

	switch (id) {
	case LISTMGR_INDEX:
	case LISTMGR_PLAY_INFO:
		if (!elm_object_focus_get(obj)) {
			lmgr->focus_state = EINA_TRUE;
			elm_object_focus_set(obj, EINA_TRUE);
		}

		break;
	case LISTMGR_GRID:
		it = elm_gengrid_at_xy_item_get(obj, ev->cur.canvas.x,
					ev->cur.canvas.y, NULL, NULL);

		if (!it)
			return;

		if (!elm_object_item_focus_get(it)) {
			lmgr->focus_state = EINA_TRUE;
			elm_object_item_focus_set(it, EINA_TRUE);
		}

		break;
	default:
		break;
	}
}

static void _clicked_cb(int id, void *data, Evas_Object *obj)
{
	if (!obj)
		return;

	switch (id) {
	case LISTMGR_PLAY_INFO:
		elm_object_signal_emit(obj, SIG_BTN_CLICKED, SIG_SOURCE_SRC);
		break;
	default:
		break;
	}
}

static void _focused_cb(int id, void *data, Evas_Object *obj,
			Elm_Object_Item *it)
{
	Evas_Object *btn;
	struct listmgr *lmgr;

	if (!data || !obj)
		return;

	lmgr = data;

	switch (id) {
	case LISTMGR_SCROLLER:
		if (lmgr->focus_state)
			break;

		btn = elm_object_part_content_get(lmgr->focused,
				PART_ITEM_TITLE);
		if (!btn) {
			_ERR("failed to get button object");
			return;
		}

		lmgr->focus_state = EINA_TRUE;
		elm_object_focus_set(btn, EINA_TRUE);

		break;
	case LISTMGR_INDEX:
	case LISTMGR_PLAY_INFO:
	case LISTMGR_GRID:
		lmgr->focused = elm_object_parent_widget_get(obj);
		elm_object_signal_emit(lmgr->data->menu_btn, SIG_BTN_SELECTED,
					SIG_SOURCE_SRC);
		break;
	default:
		break;
	}
}

static void _grid_selected(void *data)
{
	struct listmgr *lmgr;
	struct grid_ops *gops;

	if (!data) {
		_ERR("invalid argument");
		return;
	}

	lmgr = data;

	gops = lmgr->data->gops;

	if (gops->selected_cb)
		gops->selected_cb(gops->ops_data, lmgr->selected_it);
}

static void _grid_selected_cb(int id, void *data, Evas_Object *obj,
			Elm_Object_Item *it)
{
	struct listmgr *lmgr;

	if (!data || !it)
		return;

	lmgr = data;

	lmgr->selected_it = it;

	ecore_job_add(_grid_selected, lmgr);
}

static void _play_info_selected_cb(void *data, Evas_Object *obj,
			const char *emission, const char *source)
{
	struct listmgr *lmgr;
	struct play_info_ops *pops;

	if (!data || !obj)
		return;

	lmgr = data;
	pops = lmgr->data->pops;

	if (pops->selected_cb)
		pops->selected_cb(pops->ops_data, obj);
}

static void _item_focused_cb(void *data, Elm_Object_Item *it,
			const char *emission, const char *source)
{
	struct listmgr *lmgr;

	if (!data || !it)
		return;

	lmgr = data;

	lmgr->focused_it = it;
}

static void _realized_cb(int id, void *data, Evas_Object *obj,
			Elm_Object_Item *it)
{
	struct listmgr *lmgr;

	if (!data || !it)
		return;

	lmgr = data;

	elm_object_item_signal_callback_add(it, SIG_ITEM_FOCUSED,
				SIG_SOURCE_EDC,_item_focused_cb, lmgr);
}

static void _unrealized_cb(int id, void *data, Evas_Object *obj,
			Elm_Object_Item *it)
{
	if (!it)
		return;

	elm_object_item_signal_callback_del(it, SIG_ITEM_FOCUSED,
				SIG_SOURCE_EDC, _item_focused_cb);
}

static input_handler _grid_handler = {
	.key_down = _key_down_cb,
	.mouse_move = _mouse_move_cb,
	.focused = _focused_cb,
	.selected = _grid_selected_cb,
	.realized = _realized_cb,
	.unrealized = _unrealized_cb
};

static input_handler _handler = {
	.key_down = _key_down_cb,
	.mouse_move = _mouse_move_cb,
	.clicked = _clicked_cb,
	.focused = _focused_cb
};

static Evas_Object *_get_box_first_item(Evas_Object *box)
{
	Eina_List *list;

	list = elm_box_children_get(box);
	if (!list)
		return NULL;

	return (Evas_Object *)eina_list_nth(list, 0);
}

static int _get_grid_width(int count, int num_item, int item_x)
{
	int num_col, width;

	num_col = count / num_item;
	if (count % num_item > 0)
		num_col++;

	width = num_col * item_x;
	if (width > MAX_GRID_WIDTH)
		width = MAX_GRID_WIDTH;

	return width;
}

static bool _draw_play_info(struct listmgr *lmgr)
{
	Evas_Object *ly, *index, *content;
	struct play_info_ops *pops;

	ly = elm_layout_add(lmgr->box);
	if (!ly) {
		_ERR("failed to create layout object");
		return false;
	}

	elm_layout_file_set(ly, EDJEFILE, GRP_LIST_ITEM);

	pops = lmgr->data->pops;

	if (!pops->draw(pops->ops_data, ly)) {
		_ERR("failed to draw play info item");
		evas_object_del(ly);
		return false;
	}

	index = elm_object_part_content_get(ly, PART_ITEM_TITLE);

	inputmgr_add_callback(index, LISTMGR_INDEX, &_handler, lmgr);
	elm_object_focus_next_object_set(index, lmgr->data->menu_btn,
					ELM_FOCUS_UP);

	content = elm_object_part_content_get(ly, PART_ITEM_CONTENT);

	elm_object_focus_next_object_set(content, index, ELM_FOCUS_UP);

	inputmgr_add_callback(content, LISTMGR_PLAY_INFO, &_handler, lmgr);
	elm_object_signal_callback_add(content, SIG_ITEM_SELECTED,
				SIG_SOURCE_EDC, _play_info_selected_cb, lmgr);

	lmgr->play_info = ly;

	return true;
}

static Evas_Object *_draw_list_item(struct listmgr *lmgr, struct group_info *gi)
{
	Evas_Object *ly, *btn, *grid;
	struct listmgr_data *data;
	int width;
	char buf[128];

	data = lmgr->data;

	ly = elm_layout_add(lmgr->box);
	if (!ly) {
		_ERR("failed to create layout object");
		return NULL;
	}

	elm_layout_file_set(ly, EDJEFILE, GRP_LIST_ITEM);

	btn = elm_button_add(ly);
	if (!btn) {
		_ERR("failed to create button object");
		evas_object_del(ly);
		return NULL;
	}

	elm_object_style_set(btn, STYLE_BTN_INDEX);

	snprintf(buf, sizeof(buf), " %s ", gi->name);
	elm_object_text_set(btn, buf);

	elm_object_focus_next_object_set(btn,
				lmgr->data->menu_btn, ELM_FOCUS_UP);

	inputmgr_add_callback(btn, LISTMGR_INDEX, &_handler, lmgr);

	grid = util_add_gengrid(ly, data->grid_item_x,
				data->grid_item_y, EINA_TRUE);
	if (!grid) {
		_ERR("failed to create gengrid object");
		evas_object_del(ly);
		return NULL;
	}

	if (!gridmgr_add_grid(lmgr->gmgr, gi->name, grid, data->gops->gclass)) {
		_ERR("failed to add grid");
		evas_object_del(ly);
		return NULL;
	}

	width = _get_grid_width(eina_list_count(gi->list), data->grid_num_item,
				data->grid_item_x);

	evas_object_size_hint_min_set(grid, width,
				data->grid_num_item * data->grid_item_y);

	elm_object_focus_next_object_set(grid, btn, ELM_FOCUS_UP);

	inputmgr_add_callback(grid, LISTMGR_GRID, &_grid_handler, lmgr);

	elm_object_part_content_set(ly, PART_ITEM_TITLE, btn);
	elm_object_part_content_set(ly, PART_ITEM_CONTENT, grid);

	return ly;
}

bool _focus_to_content(struct listmgr *lmgr, Evas_Object *base)
{
	Evas_Object *content;

	content = elm_object_part_content_get(base, PART_ITEM_CONTENT);
	if (!content) {
		_ERR("failed to get content");
		return false;
	}

	lmgr->focus_state = EINA_TRUE;
	elm_object_focus_set(content, EINA_TRUE);

	return true;
}

void listmgr_set_focus_state(struct listmgr *lmgr, Eina_Bool state)
{
	if (!lmgr) {
		_ERR("failed to get listmgr");
		return;
	}

	lmgr->focus_state = state;
}

bool listmgr_focus_play_info(struct listmgr *lmgr)
{
	if (!lmgr) {
		_ERR("failed to get listmgr");
		return false;
	}

	if (!_focus_to_content(lmgr, lmgr->play_info)) {
		_ERR("failed to focus to content");
		return false;
	}

	return true;
}

bool listmgr_focus_content_list(struct listmgr *lmgr, int index, bool update)
{
	Eina_List *item, *l;
	Evas_Object *ly, *grid;
	Elm_Object_Item *it;
	int count;
	int r;

	if (!update) {
		r = _focus_to_content(lmgr, lmgr->focused);
		if (!r)
			_ERR("failed to focus to content");
		return r;
	}

	item = elm_box_children_get(lmgr->box);
	if (lmgr->show_play_info)
		item = eina_list_next(item);

	grid = NULL;
	EINA_LIST_FOREACH(item, l, ly) {
		grid = elm_object_part_content_get(ly, PART_ITEM_CONTENT);
		if (!grid) {
			_ERR("failed to get grid object");
			return false;
		}

		count = elm_gengrid_items_count(grid);

		if (index < count)
			break;

		index -= count;
	}

	it = elm_gengrid_first_item_get(grid);
	while (index--)
		it = elm_gengrid_item_next_get(it);

	if (!it) {
		_ERR("failed to get current grid item");
		return false;
	}

	elm_gengrid_item_bring_in(it, ELM_GENGRID_ITEM_SCROLLTO_MIDDLE);

	lmgr->focus_state = EINA_TRUE;
	elm_object_item_focus_set(it, EINA_TRUE);

	return true;
}

bool listmgr_update_content_list(struct listmgr *lmgr, Eina_List *list)
{
	Evas_Object *ly, *btn, *grid;
	Eina_List *l;
	struct group_info *gi;

	if (!lmgr) {
		_ERR("invalid argument");
		return false;
	}

	ly = NULL;
	EINA_LIST_FOREACH(list, l, gi) {
		ly = _draw_list_item(lmgr, gi);
		if (!ly) {
			_ERR("failed to draw list item");
			return false;
		}

		if (!gridmgr_append_list(lmgr->gmgr, gi->name, gi->list)) {
			_ERR("failed to append list in grid");
			return false;
		}

		evas_object_show(ly);

		elm_box_pack_end(lmgr->box, ly);
	}

	btn = elm_object_part_content_get(ly, PART_ITEM_TITLE);
	elm_object_focus_next_object_set(btn, btn, ELM_FOCUS_RIGHT);

	grid = elm_object_part_content_get(ly, PART_ITEM_CONTENT);
	elm_object_focus_next_object_set(grid, grid, ELM_FOCUS_RIGHT);

	lmgr->focused = _get_box_first_item(lmgr->box);

	elm_object_focus_allow_set(lmgr->scr, EINA_TRUE);

	return true;
}

bool listmgr_update_play_info(struct listmgr *lmgr, app_media_info *info)
{
	struct play_info_ops *pops;

	if (!lmgr) {
		_ERR("invalid argument");
		return false;
	}

	if (!info) {
		if (lmgr->show_play_info) {
			if (lmgr->play_info == lmgr->focused)
				lmgr->focused = _get_box_first_item(lmgr->box);

			elm_box_unpack(lmgr->box, lmgr->play_info);
			evas_object_hide(lmgr->play_info);
			lmgr->show_play_info = EINA_FALSE;
		}
		return true;
	}

	pops = lmgr->data->pops;

	if (!pops->update(pops->ops_data, lmgr->play_info)) {
		_ERR("failed to update play info");
		return false;
	}

	if (!lmgr->show_play_info) {
		elm_box_pack_start(lmgr->box, lmgr->play_info);
		evas_object_size_hint_align_set(lmgr->play_info, 0.0, 0.0);
		evas_object_show(lmgr->play_info);

		lmgr->show_play_info = EINA_TRUE;
		lmgr->focused = lmgr->play_info;
	}

	return true;
}

bool listmgr_draw_list_area(struct listmgr *lmgr)
{
	Evas_Object *scr, *box;
	struct listmgr_data *data;

	if (!lmgr) {
		_ERR("invalid argument");
		return false;
	}

	data = lmgr->data;

	scr = util_add_scroller(lmgr->base);
	if (!scr) {
		_ERR("failed to create scroller object");
		return false;
	}

	elm_scroller_step_size_set(scr, SCROLLER_STEP_SIZE(
				data->box_padding + data->grid_item_x), 0);

	inputmgr_add_callback(scr, LISTMGR_SCROLLER, &_handler, lmgr);

	box = util_add_box(scr);
	if (!box) {
		_ERR("failed to create box object");
		evas_object_del(scr);
		return false;
	}

	elm_box_padding_set(box, data->box_padding, 0);

	evas_object_show(box);
	elm_object_content_set(scr, box);

	elm_object_part_content_set(lmgr->base, PART_CONTENT, scr);

	lmgr->scr = scr;
	lmgr->box = box;

	if (data->pops) {
		if (!_draw_play_info(lmgr)) {
			_ERR("failed to draw play info");
			evas_object_del(scr);
			return false;
		}
	}

	elm_object_focus_next_object_set(data->menu_btn, scr, ELM_FOCUS_DOWN);

	elm_object_focus_allow_set(scr, EINA_FALSE);

	return true;
}

struct listmgr *listmgr_create(Evas_Object *base, void *data)
{
	struct gridmgr *gmgr;
	struct listmgr *lmgr;

	if (!base || !data) {
		_ERR("invalid argument");
		return NULL;
	}

	lmgr = calloc(1, sizeof(*lmgr));
	if (!lmgr) {
		_ERR("failed to allocate listmgr");
		return NULL;
	}

	gmgr = gridmgr_create();
	if (!gmgr) {
		_ERR("failed to create gridmgr");
		free(lmgr);
		return false;
	}

	lmgr->base = base;
	lmgr->gmgr = gmgr;
	lmgr->data = data;
	lmgr->show_play_info = EINA_FALSE;
	lmgr->focus_state = EINA_FALSE;

	return lmgr;
}

void listmgr_destroy(struct listmgr *lmgr)
{
	Eina_List *item, *l;
	Evas_Object *ly, *btn, *content, *grid;

	if (!lmgr) {
		_ERR("invalid argument");
		return;
	}

	if (lmgr->play_info) {
		btn = elm_object_part_content_get(lmgr->play_info,
					PART_ITEM_TITLE);
		content = elm_object_part_content_get(lmgr->play_info,
					PART_ITEM_CONTENT);

		inputmgr_remove_callback(btn, &_handler);
		inputmgr_remove_callback(content, &_handler);

		elm_object_signal_callback_del(content, SIG_ITEM_SELECTED,
					SIG_SOURCE_EDC, _play_info_selected_cb);

		elm_box_unpack(lmgr->box, lmgr->play_info);
		evas_object_del(lmgr->play_info);
	}

	item = elm_box_children_get(lmgr->box);
	EINA_LIST_FOREACH(item, l, ly) {
		btn = elm_object_part_content_get(ly, PART_ITEM_TITLE);
		grid = elm_object_part_content_get(ly, PART_ITEM_CONTENT);

		inputmgr_remove_callback(btn, &_handler);
		inputmgr_remove_callback(grid, &_grid_handler);
	}

	inputmgr_remove_callback(lmgr->scr, &_handler);

	gridmgr_destroy(lmgr->gmgr);

	free(lmgr);
}