path: root/lib-apps-common/inc/Ux/SelectView.h

/*
 * Copyright 2017 Samsung Electronics Co., Ltd
 *
 * Licensed under the Flora License, Version 1.1 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://floralicense.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 UX_SELECT_VIEW_H
#define UX_SELECT_VIEW_H

#include "Ui/View.h"
#include "Ux/MultiSelector.h"
#include "Ux/SelectTypes.h"

#include <vector>

namespace Ui
{
	class GenItem;
}

namespace Ux
{
	class SelectItem;

	/**
	 * @brief Base class for a view that support single and multiple selection modes.
	 */
	class EXPORT_API SelectView : public Ui::View
	{
	public:
		/**
		 * @brief Translatable strings table for view elements.
		 */
		struct Strings
		{
			const char *selectAll;      /**< "Select all" text. */
			const char *deselectAll;    /**< "Deselect all" text. */
			const char *buttonDone;     /**< "Done" button text. */
			const char *buttonCancel;   /**< "Cancel" button text. */
			const char *titleDefault;   /**< Title for #SelectNone mode. */
			const char *titleSingle;    /**< Title for #SelectSingle mode */
			const char *titleMulti;     /**< Title for #SelectMulti mode */
			const char *titleWithCount; /**< Title for #SelectMulti mode with selection count.
											 Can contain one integer format specifier. */
			const char *titleWithLimit; /**< Title for #SelectMulti mode with limit.
											 Can contain two integer format specifiers. */
			const char *popupLimit;     /**< Selection limit reached popup text.
											 Can contain one integer format specifiers. */
		};

		/**
		 * @brief Called when item's "checked" state changed in #SelectMulti mode.
		 * @param[in]   item            Changed item
		 * @param[in]   isChecked       Whether item is checked
		 * @param[in]   isMultiChecked  Whether item is being checked via "Select All"
		 * @return Whether item's state should be changed.
		 */
		typedef std::function<bool(SelectItem *item, bool isChecked, bool isMultiChecked)> CheckCallback;

		/**
		 * @brief Called when selection limit is reached.
		 * @return Whether limit popup should be shown.
		 */
		typedef std::function<bool()> LimitCallback;

		/**
		 * @brief Array of selectable items.
		 */
		typedef std::vector<SelectItem *> SelectItems;

		SelectView();
		virtual ~SelectView() override;

		/**
		 * @return View selection mode.
		 */
		SelectMode getSelectMode() const;

		/**
		 * @return Current selection limit.
		 */
		size_t getSelectLimit() const;

		/**
		 * @return Current selected items count.
		 */
		size_t getSelectCount() const;

		/**
		 * @return Selectable items managed by the view.
		 */
		const SelectItems &getSelectItems() const;

		/**
		 * @return Whether all items are selected.
		 */
		bool isMaxSelected() const;

		/**
		 * @brief Set translatable strings for the view.
		 * @remark Should be called before create().
		 * @param[in]   strings    Translatable strings table
		 */
		void setStrings(const Strings &strings);

		/**
		 * @brief Set selection mode.
		 * @param[in]   selectMode  Selection mode
		 */
		void setSelectMode(SelectMode selectMode);

		/**
		 * @brief Set item selection limit.
		 * @param[in]   selectLimit     Maximum selectable items count
		 */
		void setSelectLimit(size_t selectLimit);

		/**
		 * @brief Enable active Done button despite number of selections.
		 * @param[in]   isAllowed   True - Done button should be enabled, otherwise false
		 */
		void setEmptyResultAllowed(bool isAllowed);

		/**
		 * @brief Set selection callback.
		 * @param[in]   callback    Selection callback
		 */
		void setSelectCallback(SelectCallback callback);

		/**
		 * @brief Set cancel callback.
		 * @param[in]   callback    Cancel callback
		 */
		void setCancelCallback(CancelCallback callback);

		/**
		 * @brief Set item check callback.
		 * @param[in]   callback    Check callback
		 */
		void setCheckCallback(CheckCallback callback);

		/**
		 * @brief Set limit callback.
		 * @param[in]   callback    Limit callback
		 */
		void setLimitCallback(LimitCallback callback);

	protected:
		/**
		 * @brief Creates "Done" and "Cancel" buttons in #SelectMulti mode.
		 * @see View::onPageAttached()
		 */
		virtual void onPageAttached(Ui::NavigatorPage *page) override;

		/**
		 * @brief Calls cancel callback if it exists.
		 * @see View::onBackPressed()
		 */
		virtual bool onBackPressed() override;

		/**
		 * @brief Called when title was changed.
		 * @param[in]   title  Title
		 */
		virtual void onTitleChanged(const char *title);

		/**
		 * @brief Called when selection mode was changed.
		 * @param[in]   selectMode  New selection mode
		 */
		virtual void onSelectModeChanged(SelectMode selectMode) { }

		/**
		 * @brief Called when selection limit was changed.
		 * @param[in]   selectLimit New selection limit
		 */
		virtual void onSelectLimitChanged(size_t selectLimit) { }

		/**
		 * @brief Called when selection count was changed.
		 * @param[in]   selectCount New selection count
		 */
		virtual void onSelectCountChanged(size_t selectCount) { }

		/**
		 * @return Done button.
		 */
		virtual Evas_Object *createDoneButton();

		/**
		 * @return Cancel button.
		 */
		virtual Evas_Object *createCancelButton();

		/**
		 * @return MultiSelector control.
		 */
		virtual Ux::MultiSelector *createMultiSelector() = 0;

		/**
		 * @brief Add selectable item to be managed by the view.
		 * @param[in]   item    Item to add
		 */
		void addSelectItem(SelectItem *item);

		/**
		 * @brief Remove selectable item.
		 * @param[in]   item    Item to remove
		 */
		void removeSelectItem(SelectItem *item);

		/**
		 * @return MultiSelector
		 */
		Ui::ControlPtr getMultiSelector();

	private:
		friend class SelectItem;

		enum CountChange
		{
			CountIncrement,
			CountDecrement
		};

		size_t getSelectMax() const;
		bool isLimitReached() const;

		void updatePageTitle();
		void updatePageButtons();
		void updateDoneButtonState();
		void updateMultiSelector();
		void updateMultiSelectorState();

		void updateTotalCount(CountChange change, SelectItem *item);
		void updateTotalSelectCount(CountChange change, SelectItem *item);

		void updateVisibleCount(CountChange change, SelectItem *item);
		void updateVisibleSelectCount(CountChange change, SelectItem *item);

		void createPageButtons();
		void destroyPageButtons();

		void onItemExcluded(SelectItem *item, bool isExcluded);
		void onItemVisibilityChanged(SelectItem *item, bool isVisible);
		void onItemSelected(SelectItem *item);
		bool onItemChecked(SelectItem *item, bool isChecked);
		bool onMultiSelectorChanged(MultiSelector::State state);

		void onDonePressed(Evas_Object *button, void *eventInfo);
		void onCancelPressed(Evas_Object *button, void *eventInfo);
		void onLimitReached();

		Ui::ControlPtr m_MultiSelector;
		SelectItems m_Items;

		Evas_Object *m_DoneButton;
		Evas_Object *m_CancelButton;

		bool m_IsMultiChecking;
		size_t m_TotalCount;
		size_t m_TotalSelectCount;
		size_t m_VisibleCount;
		size_t m_VisibleSelectCount;
		size_t m_SelectLimit;
		bool m_IsEmptyResultAllowed;

		SelectMode     m_SelectMode;
		SelectCallback m_OnSelected;
		CheckCallback  m_OnChecked;
		CancelCallback m_OnCanceled;
		LimitCallback  m_OnLimitReached;

		Strings m_Strings;
	};
}

#endif /* UX_SELECT_VIEW_H */