#ifndef TNZ_POPUPMENU_INCLUDED
#define TNZ_POPUPMENU_INCLUDED

#include "tw/action.h"
#include "tw/popup.h"
#include "tw/button.h"

#undef DVAPI
#undef DVVAR
#ifdef TWIN_EXPORTS
#define DVAPI DV_EXPORT_API
#define DVVAR DV_EXPORT_VAR
#else
#define DVAPI DV_IMPORT_API
#define DVVAR DV_IMPORT_VAR
#endif

//-------------------------------------------------------------

class TPopupMenu;
class TPopupMenuItem;

//-------------------------------------------------------------

class DVAPI TPopupMenuListener
{
public:
	TPopupMenuListener() {}
	virtual ~TPopupMenuListener() {}

	virtual void onMenuSelect(TPopupMenuItem *item) = 0;
};

//-------------------------------------------------------------

class DVAPI TPopupMenuItem : public TButton
{
	wstring m_title;
	bool m_selected;

public:
	TPopupMenuItem(TPopupMenu *parent, string name);
	void repaint();

	void enter(const TPoint &);
	void leave(const TPoint &);

	void leftButtonDown(const TMouseEvent &e);
	void leftButtonUp(const TMouseEvent &e);

	void setTitle(wstring title);

	TPopupMenu *getPopup();

	void select(bool on);
	bool isSelected() const { return m_selected; }

	virtual int getWidth();
};

//-------------------------------------------------------------

class DVAPI TPopupMenuSeparator : public TWidget
{

public:
	TPopupMenuSeparator(TPopupMenu *parent);
	void repaint();
};

//-------------------------------------------------------------

//
// Note: to implement right-mouse-bottom menu use
// the class TContextMenu (see below)
//

class DVAPI TPopupMenu : public TPopup
{
	TPopupMenuItem *m_currentItem;
	TPopupMenuListener *m_listener;
	int m_firstVisibleItem;
	int m_visibleItemCount;
	bool m_leftAlignment;

public:
	TPopupMenu(TWidget *parent, string name = "popupMenu");
	void draw();
	void configureNotify(const TDimension &);

	void leftButtonDrag(const TPoint &, UCHAR);
	void leftButtonUp(const TPoint &);

	void popup(const TPoint &pos, int width = 120);
	void close();

	TPopupMenuItem *getCurrentItem() { return m_currentItem; }
	void setListener(TPopupMenuListener *);

	static TPopupMenu *getCurrentMenu();

	void setLeftAlignment(bool a)
	{
		m_leftAlignment = a;
	}

private:
	void updateItemsVisibility();
	void updateSize();
	void computeSize(TPoint &pos, int maxY);

	friend class TPopupMenuArrow;
};

//-------------------------------------------------------------

//
// TContextMenu :
//  a class specifically dedicated to
//  right-mouse-button popup menu (aka Context Menu)
//
// Note: DON'T use the method popup() (inherited from TPopupMenu)
//
// Note: the context menu will be automatically destroyed
// DON'T keep a reference to the context menu
//
// see examples below
//

/*---- Example 1 (position indipendent) ----
   
   void Pluto::rightButtonUp(const TMouseEvent &e) {
     TContextMenu *menu = new TContextMenu(this);
     menu->addCommand("MI_Cut");
     menu->addCommand("MI_Copy");
     menu->addCommand("MI_Paste");
     menu->addCommand("MI_Clear");
     TContextMenu::open(menu, e.m_pos);
   }


  ---- Example 2 (position dependent) ----


   class MyContextMenu : public TContextMenu {
     int m_myValue;
   public:
     MyContextMenu(TWidget*parent, int myValue) 
     : TContextMenu(parent), m_myValue(myValue), m_col(col) {
        tconnect(this, "foo",  this, &CellContextMenu::onFoo);
        tconnect(this, "bar",  this, &CellContextMenu::onBar);
     }
     void onFoo() { ... }
     void onBar() { ... }
   };

   void Pluto::rightButtonUp(const TMouseEvent &e) {
     int row = ....
     int col = ....
     TContextMenu::open(new CellContextMenu(this, row, col), e.m_pos);
   }

  -----------------------------------------*/

class DVAPI TContextMenu : public TPopupMenu
{
public:
	class CommandFilter
	{
	public:
		virtual bool check(string cmdName) const = 0;
		virtual ~CommandFilter() {}
	};

	TContextMenu(TWidget *parent);

	void add(string name, TGenericCommandAction *action);
	void addCommand(string cmdName);
	void addCommand(string cmdName, TGenericCommandAction *action);

	void addSeparator() { new TPopupMenuSeparator(this); }

	/*
  template <class T>
  inline void addCommand(string cmdName, T*target, void (T::*method)()) {
    //addCommand(cmdName, new TCommandAction<T>(target, method));
  }
*/
	static void open(TContextMenu *menu, const TPoint &pos);

	static void setCommandFilter(CommandFilter *filter);

	void onTimer(int);
};

template <class T>
inline void tconnect(TContextMenu *menu, string cmdName, T *target, void (T::*method)())
{
	menu->addCommand(cmdName, new TCommandAction<T>(target, method));
}

template <class T, class Arg>
inline void tconnect(
	TContextMenu *menu, string cmdName,
	T *target, void (T::*method)(Arg), Arg arg)
{
	menu->addCommand(cmdName, new TCommandAction1<T, Arg>(target, method, arg));
}

#endif