#pragma once

#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