path: root/src/action_menu_view.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 <viewmgr.h>
#include <inputmgr.h>
#include <app_debug.h>
#include <app_define.h>
#include <notification.h>

#include "define.h"
#include "util.h"

#define BUF_MAX 128
#define BUTTON_MAX 16
#define BUTTON_BORDER 1
#define ITEMS_IN_ROW 4

#define STYLE_LIVETV_BTN "style.livetv.button"
#define STYLE_ACTION_MENU_BTN "style.action.menu.button"

#define UNTOGGLE 0
#define TOGGLE 1

enum _button_id {
	BUTTON_INVALID = -1,
	BUTTON_CLEAR,
	BUTTON_LIVETV = BUTTON_MAX,
};

enum _button_state {
	STATE_INVALID = -1,
	STATE_UNTOGGLE,
	STATE_TOGGLE,
	STATE_DISABLED,
};

struct _priv {
	Evas_Object *win;
	Evas_Object *base;
	Evas_Object *table;
	Evas_Object *live;
	Evas_Object *menu_btn[BUTTON_MAX];

	notification_h noti;
};

struct _button_data {
	const char *text;
	const char *normal;
	const char *focused;
	const char *selected;
	const char *disabled;
};

static void _livetv_clicked(void *data)
{
	app_control_h app_ctrl;
	int r;

	r = app_control_create(&app_ctrl);
	if (r != APP_CONTROL_ERROR_NONE) {
		_ERR("failed to create app control handle");
		return;
	}

	r = app_control_set_operation(app_ctrl, APP_CONTROL_OPERATION_DEFAULT);
	if (r != APP_CONTROL_ERROR_NONE) {
		_ERR("failed to set app control operation");
		app_control_destroy(app_ctrl);
		return;
	}

	r = app_control_set_app_id(app_ctrl, APP_ID_LIVETV);
	if (r != APP_CONTROL_ERROR_NONE) {
		_ERR("failed to set app control app id");
		app_control_destroy(app_ctrl);
		return;
	}

	r = app_control_send_launch_request(app_ctrl, NULL, NULL);
	if (r != APP_CONTROL_ERROR_NONE) {
		_ERR("failed to send app control launch request");
		app_control_destroy(app_ctrl);
		return;
	}

	app_control_destroy(app_ctrl);

	viewmgr_hide_view(ACTION_MENU_VIEW);
}

static void _clear_clicked(void *data)
{
	struct _priv *priv;

	if (!data) {
		_ERR("Get data failed.");
		return;
	}

	priv = data;

	notification_delete(priv->noti);

	viewmgr_hide_view(ACTION_MENU_VIEW);
}

static int _clear_state(void *data)
{
	struct _priv *priv;
	int noti_err = NOTIFICATION_ERROR_NONE;
	notification_type_e type;

	if (!data) {
		_ERR("Get data failed.");
		return STATE_INVALID;
	}

	priv = data;

	if (!priv->noti)
		return STATE_DISABLED;

	noti_err = notification_get_type(priv->noti, &type);
	if (noti_err != NOTIFICATION_ERROR_NONE ||
			type == NOTIFICATION_TYPE_ONGOING)
		return STATE_DISABLED;

	return STATE_UNTOGGLE;
}

struct _button {
	int id;
	struct _button_data data[2];

	void (*clicked)(void *data);
	int (*state)(void *data);
};

static struct _button buttons[] = {
	{
		.id = BUTTON_CLEAR,
		.data[UNTOGGLE] = {
			.text = STR_BUTTON_CLEAR,
			.normal = IMAGE_CLEAR_NOR,
			.focused = IMAGE_CLEAR_FOC,
			.selected = IMAGE_CLEAR_SEL,
			.disabled = IMAGE_CLEAR_DIS
		},
		.clicked = _clear_clicked,
		.state = _clear_state
	},
	{
		.id = BUTTON_INVALID
	}
};

static void _key_up_cb(int id, void *data, Evas *e, Evas_Object *obj,
		Evas_Event_Key_Up *ev)
{
	if (!strcmp(ev->keyname, KEY_BACK) ||
			!strcmp(ev->keyname, KEY_BACK_REMOTE))
		viewmgr_hide_view(ACTION_MENU_VIEW);
}

static input_handler key_handler = {
	.key_up = _key_up_cb,
};

static void _update_button_state(Evas_Object *obj,
		struct _button *button, void *data)
{
	int state;

	if (!obj || !button->state) {
		_ERR("failed to get button state");
		return;
	}

	state = button->state(data);

	switch (state) {
	case STATE_UNTOGGLE:
		elm_object_signal_emit(obj, SIGNAL_UNTOGGLE, SOURCE_ELM);
		break;
	case STATE_TOGGLE:
		elm_object_signal_emit(obj, SIGNAL_TOGGLE, SOURCE_ELM);
		break;
	case STATE_DISABLED:
		elm_object_disabled_set(obj, EINA_TRUE);
		break;
	case STATE_INVALID:
		break;
	}
}

static void _button_clicked(Evas_Object *obj, int id, void *data)
{
	struct _button *button;

	switch (id) {
	case BUTTON_LIVETV:
		_livetv_clicked(data);
		break;
	case BUTTON_CLEAR:
		button = evas_object_data_get(obj, KEY_BUTTON);

		if (!button) {
			_ERR("failed to get button");
			return;
		}

		if (button->clicked)
			button->clicked(data);

		_update_button_state(obj, button, data);

		break;
	}
}

static void _button_key_up_cb(int id, void *data, Evas *e, Evas_Object *obj,
		Evas_Event_Key_Up *ev)
{
	if (strcmp(ev->keyname, KEY_ENTER) &&
		strcmp(ev->keyname, KEY_ENTER_REMOTE))
		return;

	_button_clicked(obj, id, data);
}

static void _button_mouse_up_cb(int id, void *data, Evas *e,
		Evas_Object *obj, Evas_Event_Mouse_Up *ev)
{
	_button_clicked(obj, id, data);
}

static void _button_mouse_move_cb(int id, void *data, Evas *e, Evas_Object *obj,
		Evas_Event_Mouse_Move *ev)
{
	if (!obj)
		return;

	if (!elm_object_focus_get(obj))
		elm_object_focus_set(obj, EINA_TRUE);
}

static input_handler button_handler = {
	.key_up = _button_key_up_cb,
	.mouse_up = _button_mouse_up_cb,
	.mouse_move = _button_mouse_move_cb
};

static void _child_removed_cb(void *data, Evas_Object *obj, void *ei)
{
	if (obj)
		inputmgr_remove_callback(obj, &button_handler);
}


static bool _draw_top_area(struct _priv *priv)
{
	Evas_Object *btn;

	btn = util_add_button(priv->base,
			PART_TOP_BUTTON, STR_LIVETV, STYLE_LIVETV_BTN);
	if (!btn) {
		_ERR("Add button failed.");
		return false;
	}
	inputmgr_add_callback(btn, BUTTON_LIVETV,
				&button_handler, NULL);

	priv->live = btn;

	return true;
}

static void _update_menu_area(struct _priv *priv)
{
	Evas_Object *btn;
	int i, row, col;

	elm_table_clear(priv->table, EINA_TRUE);

	i = 0;
	while (buttons[i].id != BUTTON_INVALID && i < BUTTON_MAX) {
		btn = util_add_button(priv->base, NULL,
				buttons[i].data[UNTOGGLE].text,
				STYLE_ACTION_MENU_BTN);
		if (!btn) {
			_ERR("Add button failed.");
			return;
		}

		evas_object_data_set(btn, KEY_BUTTON, &buttons[i]);
		util_add_icon(btn, buttons[i].data[UNTOGGLE].normal,
				PART_ICON);
		util_add_icon(btn, buttons[i].data[UNTOGGLE].focused,
				PART_ICON_FOCUSED);
		util_add_icon(btn, buttons[i].data[UNTOGGLE].selected,
				PART_ICON_SELECTED);
		util_add_icon(btn, buttons[i].data[UNTOGGLE].disabled,
				PART_ICON_DISABLED);
		elm_object_part_text_set(btn, PART_TEXT_1,
				buttons[i].data[TOGGLE].text);
		util_add_icon(btn, buttons[i].data[TOGGLE].normal,
				PART_ICON_1);
		util_add_icon(btn, buttons[i].data[TOGGLE].focused,
				PART_ICON_1_FOCUSED);
		util_add_icon(btn, buttons[i].data[TOGGLE].selected,
				PART_ICON_1_SELECTED);
		util_add_icon(btn, buttons[i].data[TOGGLE].disabled,
				PART_ICON_1_DISABLED);
		inputmgr_add_callback(btn, buttons[i].id,
				&button_handler, priv);

		_update_button_state(btn, &buttons[i], priv);

		col = i % ITEMS_IN_ROW;
		row = i / ITEMS_IN_ROW;
		elm_table_pack(priv->table, btn, col, row, 1, 1);

		priv->menu_btn[i] = btn;

		i++;
	}

	elm_object_focus_next_object_set(priv->menu_btn[0],
			priv->menu_btn[i - 1], ELM_FOCUS_LEFT);
	elm_object_focus_next_object_set(priv->menu_btn[i - 1],
			priv->menu_btn[0], ELM_FOCUS_RIGHT);

	while (col + 1 != ITEMS_IN_ROW) {
		btn = util_add_button(priv->base, NULL, NULL,
				STYLE_ACTION_MENU_BTN);
		if (!btn) {
			_ERR("Add button failed.");
			return;
		}

		elm_object_disabled_set(btn, EINA_TRUE);

		col = i % ITEMS_IN_ROW;

		elm_table_pack(priv->table, btn, col, row, 1, 1);

		i++;
	}
}

static bool _draw_menu_area(struct _priv *priv)
{
	Evas_Object *table;

	table = elm_table_add(priv->base);
	if (!table) {
		_ERR("Add table failed.");
		return false;
	}
	elm_table_padding_set(table, BUTTON_BORDER, BUTTON_BORDER);
	evas_object_show(table);
	elm_object_part_content_set(priv->base, PART_MENU, table);
	evas_object_smart_callback_add(priv->table, SIGNAL_CHILD_REMOVED,
			_child_removed_cb, NULL);

	priv->table = table;

	return true;
}

static void _draw_view_content(struct _priv *priv)
{
	if (!_draw_top_area(priv)) {
		_ERR("Draw top area failed.");
		return;
	}

	if (!_draw_menu_area(priv)) {
		_ERR("Draw menu area failed.");
		return;
	}
}

static Evas_Object *_create(Evas_Object *win, void *data)
{
	struct _priv *priv;
	Evas_Object *base;

	if (!win) {
		_ERR("Get window object failed.");
		return NULL;
	}

	priv = calloc(1, sizeof(*priv));
	if (!priv) {
		_ERR("Calloc failed.");
		return NULL;
	}

	base = elm_layout_add(win);
	if (!base) {
		_ERR("failed to create base object");
		free(priv);
		return NULL;
	}
	elm_layout_file_set(base, EDJEFILE, GRP_VIEW_ACTION_MENU);
	evas_object_size_hint_weight_set(base,
			EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
	elm_win_resize_object_add(win, base);

	priv->base = base;
	priv->win = win;

	if (!viewmgr_set_view_data(ACTION_MENU_VIEW, priv)) {
		_ERR("Set view data failed.");
		evas_object_del(base);
		free(priv);
		return NULL;
	}

	_draw_view_content(priv);

	inputmgr_add_callback(priv->base, 0, &key_handler, priv);

	return base;
}

static void _show(void *data)
{
	struct _priv *priv;

	if (!data) {
		_ERR("Get data failed.");
		return;
	}
	priv = data;

	_update_menu_area(priv);

	evas_object_show(priv->base);

	elm_object_focus_set(priv->menu_btn[0], EINA_TRUE);
}

static void _hide(void *data)
{
	struct _priv *priv;

	if (!data) {
		_ERR("Get data failed.");
		return;
	}
	priv = data;

	evas_object_hide(priv->base);
}

static void _destroy(void *data)
{
	struct _priv *priv;
	int i;

	if (!data) {
		_ERR("Get data failed.");
		return;
	}
	priv = data;

	inputmgr_remove_callback(priv->base, &key_handler);
	inputmgr_remove_callback(priv->live, &button_handler);

	i = 0;
	while (priv->menu_btn[i] && i < BUTTON_MAX) {
		inputmgr_remove_callback(priv->menu_btn[i], &button_handler);
		i++;
	}

	evas_object_smart_callback_del(priv->table, SIGNAL_CHILD_REMOVED,
			_child_removed_cb);

	evas_object_del(priv->base);

	free(priv);
}

static void _update(void *view_data, int type, void *data)
{
	struct _priv *priv;

	if (!view_data) {
		_ERR("failed to get view data");
		return;
	}

	priv = view_data;

	switch (type) {
	case UPDATE_TYPE_SET_NOTIFICATION:
		if (!data) {
			_ERR("failed to get data");
			return;
		}

		priv->noti = data;
		break;
	}
}

static view_class _vclass = {
	.view_id = ACTION_MENU_VIEW,
	.create = _create,
	.show = _show,
	.hide = _hide,
	.destroy = _destroy,
	.update = _update
};

view_class *action_menu_view_get_vclass(void)
{
	return &_vclass;
}