/*
 * Copyright 2004-2010, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef KERNEL_BOOT_MENU_H
#define KERNEL_BOOT_MENU_H


#include <SupportDefs.h>
#include <util/DoublyLinkedList.h>


class Menu;
class MenuItem;

typedef bool (*menu_item_hook)(Menu* menu, MenuItem* item);
typedef void (*shortcut_hook)(char key);


enum menu_item_type {
	MENU_ITEM_STANDARD = 1,
	MENU_ITEM_MARKABLE,
	MENU_ITEM_TITLE,
	MENU_ITEM_NO_CHOICE,
	MENU_ITEM_SEPARATOR,
};


class MenuItem : public DoublyLinkedListLinkImpl<MenuItem> {
public:
								MenuItem(const char* label = NULL,
									Menu* subMenu = NULL);
	virtual						~MenuItem();

			void				SetTarget(menu_item_hook target);
			menu_item_hook		Target() const { return fTarget; }

	virtual	void				SetMarked(bool marked);
			bool				IsMarked() const { return fIsMarked; }

			void				Select(bool selected);
			bool				IsSelected() const { return fIsSelected; }

			void				SetEnabled(bool enabled);
			bool				IsEnabled() const { return fIsEnabled; }

			void				SetType(menu_item_type type);
			menu_item_type		Type() const { return fType; }

			void				SetData(const void* data);
			const void*			Data() const { return fData; }

			void				SetHelpText(const char* text);
			const char*			HelpText() const { return fHelpText; }

			void				SetShortcut(char key);
			char				Shortcut() const { return fShortcut; }

			const char*			Label() const { return fLabel; }
			void				SetLabel(const char* label);

			Menu*				Submenu() const { return fSubMenu; }
			void				SetSubmenu(Menu* subMenu);

			Menu*				Supermenu() const { return fMenu; }

private:
			friend class Menu;
			void				SetMenu(Menu* menu);

private:
			const char*			fLabel;
			menu_item_hook		fTarget;
			bool				fIsMarked;
			bool				fIsSelected;
			bool				fIsEnabled;
			menu_item_type		fType;
			Menu*				fMenu;
			Menu*				fSubMenu;
			const void*			fData;
			const char*			fHelpText;
			char				fShortcut;
};


typedef DoublyLinkedList<MenuItem> MenuItemList;
typedef MenuItemList::Iterator MenuItemIterator;


enum menu_type {
	MAIN_MENU = 1,
	SAFE_MODE_MENU,
	STANDARD_MENU,
	CHOICE_MENU,
};


class Menu {
public:
								Menu(menu_type type, const char* title = NULL);
	virtual						~Menu();

			menu_type			Type() const { return fType; }

	virtual	void				Entered();
	virtual	void				Exited();

			void				Hide() { fIsHidden = true; }
			void				Show() { fIsHidden = false; }
			bool				IsHidden() const { return fIsHidden; }

			MenuItemIterator	ItemIterator() { return fItems.GetIterator(); }
			MenuItem*			ItemAt(int32 index);
			int32				IndexOf(MenuItem* item);
			int32				CountItems() const;

			MenuItem*			FindItem(const char* label);
			MenuItem*			FindMarked();
			MenuItem*			FindSelected(int32* _index = NULL);

			void				AddItem(MenuItem* item);
			status_t			AddSeparatorItem();

			MenuItem*			RemoveItemAt(int32 index);
			void				RemoveItem(MenuItem* item);

			MenuItem*			Superitem() const { return fSuperItem; }
			Menu*				Supermenu() const
									{ return fSuperItem
										? fSuperItem->fMenu : NULL; }

			const char*			Title() const { return fTitle; }
			void				SetTitle(const char* title)
									{ fTitle = title; }

			void				SetChoiceText(const char* text)
									{ fChoiceText = text; }
			const char*			ChoiceText() const { return fChoiceText; }

			void				AddShortcut(char key, shortcut_hook function);
			shortcut_hook		FindShortcut(char key) const;
			MenuItem*			FindItemByShortcut(char key);

			void				SortItems(bool (*less)(const MenuItem*,
									const MenuItem*));

			void				Run();

private:
			friend class MenuItem;
			void				Draw(MenuItem* item);

private:
			struct shortcut {
				shortcut*		next;
				shortcut_hook	function;
				char			key;
			};

			const char*			fTitle;
			const char*			fChoiceText;
			int32				fCount;
			bool				fIsHidden;
			MenuItemList		fItems;
			menu_type			fType;
			MenuItem*			fSuperItem;
			shortcut*			fShortcuts;
};


#endif	/* KERNEL_BOOT_MENU_H */