panel.h

Go to the documentation of this file.

#ifndef LWPP_PANEL_H
#define LWPP_PANEL_H

#include <lwpp/global.h>
#include <lwpanel.h>
#include <lwpp/math.h>

#define LWRGB(red, green, blue) (0x01000000 | (red<<16) | (blue<<8) | green)

namespace lwpp
{


  namespace lw10
  {
    // API 21
    typedef enum {   /* Tags to get/set panel attributes */
      PAN_X, PAN_Y, PAN_W, PAN_H, PAN_MOUSEX, PAN_MOUSEY,
      PAN_FLAGS, PAN_USERDRAW, PAN_USERACTIVATE,
      PAN_USEROPEN, PAN_USERCLOSE, PAN_TITLE,PAN_USERDATA, PAN_USERKEYS,
      PAN_LWINSTANCE, PAN_MOUSEBUTTON, PAN_MOUSEMOVE  ,PAN_PANFUN, PAN_VERSION, PAN_RESULT,
      PAN_HOSTDISPLAY, PAN_USERKEYUPS, PAN_QUALIFIERS, PAN_TO_FRONT,
      PAN_MOUSEWHEEL, PAN_USERRESIZE, PAN_MIN_W, PAN_MIN_H, PAN_MAX_W, PAN_MAX_H, PAN_CONFIGTAG
    } pTag;
    typedef enum {           /* Tags to get/set panel attributes */
      CTL_X, CTL_Y, CTL_W, CTL_H, CTL_VALUE,
      CTL_HOTX, CTL_HOTY, CTL_HOTW, CTL_HOTH, CTL_LABELWIDTH,
      CTL_MOUSEX, CTL_MOUSEY,
      CTL_FLAGS, CTL_USERDRAW, CTL_USEREVENT, CTL_LABEL, CTL_USERDATA,
      CTL_PANEL, CTL_PANFUN,  /* use these 2 to get your panelID and functions! */
      CTL_RANGEMIN, CTL_RANGEMAX,             /* get/set slider range params  API 10 and later */
      CTL_ACTIVATE,   /*  set only, to actvate/enter string controls   API 10 and later */
      CTL_MOUSEBUTTON /* get the mouse button pressed, read only API 20 and later */
    } cTag;
    typedef enum {           /* Tags to get mouse buttons for controls */
      CTL_MOUSELEFT=1, CTL_MOUSECENTER, CTL_MOUSERIGHT
    } mBut;
    typedef void (*LWPanResizeHook)(LWPanelID, void *, int w, int h);
    #define PAN_SETCONFIGTAG(pfunc,pan,tag)   ( ival.intv.value=tag, (*pfunc->set)(pan, PAN_CONFIGTAG, (void *)&ival.intv.value) )
  } // namespace lw10


  class LWDynaValue
  {
    LWValue val; 

    void _reset()
    {
      if (val.type == LWT_STRING)
      {
        delete [] val.str.buf;
      }
    }
  public:
    ~LWDynaValue()
    {
      _reset();
    }
    LWDynaValue()
    {
    }
    LWDynaValue(std::string s, int len = 0)
    {
      val.type = LWT_STRING;
      len = Max<int>(len, (int)s.length() + 1);
      if (len < 2) len = 2048; // use a large buffer just in case
      val.str.buf = new char[len];
      strcpy(val.str.buf, s.c_str());
      val.str.bufLen = len;
    }
    LWDynaValue(int i)
    {
      val.type = LWT_INTEGER;
      val.intv.value = i;
    }
    LWDynaValue(unsigned int i)
    {
      val.type = LWT_INTEGER;
      val.intv.value = i;
    }
    LWDynaValue(double d)
    {
      val.type = LWT_FLOAT;
      val.flt.value = d;
    }
    LWDynaValue(int i, int j, int k)
    {
      val.type = LWT_VINT;
      val.ivec.val[0] = i;
      val.ivec.val[1] = j;
      val.ivec.val[2] = k;
    }
    LWDynaValue(int v[3])
    {
      val.type = LWT_VINT;
      val.ivec.val[0] = v[0];
      val.ivec.val[1] = v[1];
      val.ivec.val[2] = v[2];
    }
    LWDynaValue(double i, double j, double k)
    {
      val.type = LWT_VFLOAT;
      val.fvec.val[0] = i;
      val.fvec.val[1] = j;
      val.fvec.val[2] = k;
    }
    LWDynaValue(double v[3])
    {
      val.type = LWT_VFLOAT;
      val.fvec.val[0] = v[0];
      val.fvec.val[1] = v[1];
      val.fvec.val[2] = v[2];
    }
    LWDynaValue(float v[3])
    {
      val.type = LWT_VFLOAT;
      val.fvec.val[0] = v[0];
      val.fvec.val[1] = v[1];
      val.fvec.val[2] = v[2];
    }
    LWDynaValue(void *p)
    {
      val.type = LWT_POINTER;
      val.ptr.ptr = p;
    }
    void setType (int type)
    {
      val.type = type;
    }
    void getValue(int &i) const
    {
      i = val.intv.value;
    }
    void getValue(double &d) const
    {
      d = val.flt.value;    }

    void getValue(int &i, int &j, int &k) const
    {
      i = val.ivec.val[0];
      j = val.ivec.val[1];
      k = val.ivec.val[2];
    }
    void getValue(int v[]) const
    {
      v[0] = val.ivec.val[0];
      v[1] = val.ivec.val[1];
      v[2] = val.ivec.val[2];
    }
    void getValue(double &i, double &j, double &k) const
    {
      i = val.fvec.val[0];
      j = val.fvec.val[1];
      k = val.fvec.val[2];
    }
    void getValue(void *&p) const
    {
      p = val.ptr.ptr;
    }
    void getValue(std::string &s) const
    {
      s = val.str.buf;
    }
    LWValue *get() {return &val;}
  };

  class LWDrawFuncs
  {
    LWPanelID pan; 
    DrawFuncs *df; 
    public:
      LWDrawFuncs(DrawFuncs *_df = 0, LWPanelID _pan = 0) : df(_df), pan(_pan) {;}
      void drawPixel(int c, int x,int y) const
      {
        df->drawPixel(pan, c, x, y);
      }
      void drawPixel(int r,int g,int b,int x,int y) const
      {
        df->drawRGBPixel(pan, r, g, b, x, y);
      }
      void drawLine(int c, int x1, int y1, int x2, int y2) const
      {
        df->drawLine(pan, c, x1, y1, x2, y2);
      }
      void drawLine(int r, int g, int b, int x1, int y1, int x2, int y2) const
      {
        drawBox(r, g, b, x1, y1, x2 - x1, y2 - y1);
      }
      void drawBox(int c, int x, int y, int w, int h) const
      {
        df->drawBox(pan, c, x, y, w, h);
      }
      void drawWireBox(int c, int x, int y, int w, int h) const
      {
        h -= 1; w -= 1;
        drawLine(c, x  , y  , x+w, y);
        drawLine(c, x+w, y  , x+w, y+h);
        drawLine(c, x+w, y+h, x  , y+h);
        drawLine(c, x  , y+h, x  , y);
      }
      void drawBox(int r, int g, int b, int x, int y, int w, int h) const
      {
        df->drawRGBBox(pan, r, g, b, x, y, w, h);
      }

      int textWidth(const std::string s) const
      {
        return df->textWidth(pan, const_cast<char *>(s.c_str()));
      }
      int textWidth(const std::ostringstream &s) const
      {
        return df->textWidth(pan, const_cast<char *>(s.str().c_str()));
      }

      void drawText(const std::string s, int c, int x, int y) const
      {
        df->drawText(pan, const_cast<char *>(s.c_str()), c, x, y);
      }
      void drawText(const std::ostringstream &s, int c, int x, int y) const
      {
        df->drawText(pan, const_cast<char *>(s.str().c_str()), c, x, y);
      }
      void drawBorder(int indent, int x,int y,int w,int h = 0) const
      {
        df->drawBorder(pan, indent, x, y, w, h);
      }
      /*
        int              width, height;
        int              pixX, pixY;
        int              maxColors, depth;
        int              textHeight;
        int              textAscent;
       */
      const LWDisplayMetrics *displayMetrics() const
      {
        return df->dispMetrics();
      }
  };


  template <typename T>
  class PanelControlAdaptor
  {
  public:
    static void cb_Event(LWControlID id, void *userdata);
    static void cb_Draw(LWControlID id, void *userdata, DrMode mode);
    static int cb_Count(void *userdata);
    static char *cb_Name(void *userdata, int index);
    static char *cb_MultiListName(void *userdata, int index, int column);
    static int cb_MultiListColumnWidth(void *userdata, int index);
    static void *cb_TreeChild(void *userdata, void *node, int i);
    static int cb_TreeCount(void *userdata, void *node);
    static char *cb_TreeInfo(void *userdata, void *node, int *flags);
    static void cb_TreeMove(void *userdata, void *node, void *parent, int i);
  };
  
  class PanelControl
  {
  private:
    LWControl *control; 
    bool ghosted;
  protected:
    void get (cTag tag, LWValue *val) { control->get(control, tag, val); }
    void set (cTag tag, LWValue *val) { control->set(control, tag, val); }
  public:
    PanelControl (LWControlID ctl = 0)
      : ghosted(false)
    {
      SetControl (ctl);
    }
    PanelControl (const PanelControl &ctl)
      : ghosted(ctl.ghosted)
    {
      SetControl (ctl.control);
    }
    PanelControl &operator=(const PanelControl &from)
    {
      if (this != &from)
      {
        control = from.control;
        ghosted = from.ghosted;
      }
      return *this;
    }
    void SetControl(LWControlID ctl)
    {
      control = static_cast<LWControl *>(ctl);
    }
    LWControlID getID() const
    {
      return (void *) control;
    }
    LWControl *getControl()
    {
      return control;
    }
    void operator=(LWControlID ctl)
    {
      SetControl(ctl);
    }
    void operator=(LWControl *ctl)
    {
      control = ctl;
    }
    bool operator==(const LWControlID ctl)
    {
      return (control == static_cast<LWControl *>(ctl));
    }
    bool operator==(const PanelControl ctl)
    {
      return (getID() == ctl.getID());
    }
    bool operator<(const PanelControl ctl) const
    {
      return (getID() < ctl.getID());
    }
    bool operator==(const LWControl *ctl)
    {
      return (control == ctl);
    }
    bool isValid() const
    {
      return (control != 0);
    }

    void Draw(DrMode mode = DR_RENDER)
    {
      if (control) control->draw(control, mode);
    }
    void Erase()
    {
      Draw(DR_ERASE);
    }
    void Redraw() 
    {
      Draw (DR_REFRESH);
    }
    void Refresh() 
    {
      Draw (DR_REFRESH);
    }
    void Ghost(bool render = true)
    {
      ghosted = true;
      if (render) Render();
    }
    void UnGhost(bool render = true)
    {
      ghosted = false;
      if (render) Render();
    }
    void Render()
    {      
      Draw();
      if (ghosted)
      {
        Draw(DR_GHOST);
      }
    }
    bool isGhosted() const
    {
      return ghosted;
    }
    
    template<typename T>
    void Set (T val, cTag tag = CTL_VALUE)
    {
      LWDynaValue dval(val);
      set(tag, dval.get());
    }
    template<typename T>
    void Get (T &val, cTag tag = CTL_VALUE)
    {
      LWDynaValue dval(val);
      get(tag, dval.get());
      dval.getValue(val);
    }
    int GetInt(cTag tag = CTL_VALUE)
    {
      int v;
      Get (v, tag);
      return v;
    }
    void GetVec(int &a, int &b, int &c)
    {
      LWDynaValue dval;
      dval.setType(LWT_VINT);
      get(CTL_VALUE, dval.get());
      dval.getValue(a,b,c);
    }
    void GetVec(int v[])
    {
      LWDynaValue dval;
      dval.setType(LWT_VINT);
      get(CTL_VALUE, dval.get());
      dval.getValue(v);
    }
    bool GetBool(cTag tag = CTL_VALUE)
    {
      return (GetInt(tag) != 0);
    }

    void *GetPointer(cTag tag = CTL_USERDATA)
    {
      LWValue ival = {LWT_POINTER};
      get(tag, &ival);
      return ival.ptr.ptr;
    }
    double GetFloat()
    {
      LWValue fval = {LWT_FLOAT};
      get(CTL_VALUE, &fval);
      return fval.flt.value;
    }

    int RangeMin() {return GetInt(CTL_RANGEMIN);}
    int RangeMax() {return GetInt(CTL_RANGEMAX);}

    void RangeMin(int m) {return Set(m, CTL_RANGEMIN);}
    void RangeMax(int m) {return Set(m, CTL_RANGEMAX);}



    // control positioning
    int X() {return GetInt(CTL_X);}
    int Y() {return GetInt(CTL_Y);}
    int W() {return GetInt(CTL_W);}
    int H() {return GetInt(CTL_H);}
    int LW() {return GetInt(CTL_LABELWIDTH);}
    int HotX() {return GetInt(CTL_HOTX);}
    int HotY() {return GetInt(CTL_HOTY);}
    int HotW() {return GetInt(CTL_HOTW);}
    int HotH() {return GetInt(CTL_HOTH);}
    int MouseX() {return GetInt(CTL_MOUSEX);}
    int MouseY() {return GetInt(CTL_MOUSEY);}
#if LWPP_PANELS_API_VERSION > 19

    lw10::mBut getMouseButton()
    {
      return static_cast<lw10::mBut>(GetInt(static_cast<cTag>(lw10::CTL_MOUSEBUTTON)));
    }    
#endif

    // @}
    LWPanelID PanelID()
    {
      return static_cast<LWPanelID>(GetPointer(CTL_PANEL));
    }
    LWPanelFuncs *PanelFuncs()
    {
      return static_cast<LWPanelFuncs *>(GetPointer(CTL_PANFUN));
    }
    void Move(int x, int y) { Set(x, CTL_X); Set(y, CTL_Y); }
    void MoveRightOf(PanelControl &ref, int space = 0)  {
      MoveX(ref.X() + ref.W() + space);
      MoveY(ref.Y());
    }
    void MoveLeftOf(PanelControl &ref, int space = 0) {
      MoveX(ref.X() - W() - space);
      MoveY(ref.Y());
    }
    void MoveBelow(PanelControl &ref, int space = 0)  {
      MoveX(ref.X());
      MoveY(ref.Y() + ref.H() + space);
    }
    void MoveBelowTab(PanelControl &ref)  {
      MoveX(ref.X() + 6);
      MoveY(ref.Y() + ref.H());
    }
    void LeftAlign(PanelControl &ref, int nudge = 0)  {
      MoveX(ref.X() + nudge);
    }
    void RightAlign(PanelControl &ref, int nudge = 0) {
      MoveX(ref.X() + ref.W() - W() + nudge);
    }
    void MoveX(int x) { Set(x, CTL_X);}
    void MoveY(int y) { Set(y, CTL_Y);}
    void setSize(int w, int h)  {setWidth(w); setHeight(h);}
    void setWidth(int w)  { Set(w, CTL_W);}
    void setHeight(int h) { Set(h, CTL_H);}

    void SetUserDraw(LWCtlDrawHook d)
    {
      Set(reinterpret_cast<void *>(d), CTL_USERDRAW);
    }
    void SetUserData(void *d)
    {
      Set(d, CTL_USERDATA);
    }
    void *GetUserData()
    {
      return GetPointer(CTL_USERDATA);
    }
    template <typename T> void SetEventCallback()
    {
      Set<void *>((void *)PanelControlAdaptor<T>::cb_Event, CTL_USEREVENT);
    }
    template <typename T> void SetDrawCallback()
    {
      Set<void *>((void *)PanelControlAdaptor<T>::cb_Draw, CTL_USERDRAW);
    }
    void initMultiListBox()
    {
      initListBox();
    }
    void initListBox()
    {
      SetUserData(control);
    }

  };

  class LWPanelControlCallBacks
  {
  public:
    virtual void controlEvent(PanelControl& ) {;}
    virtual void controlDraw(PanelControl& , DrMode ) {;}
  };

  class LWPanelListCallBacks
  {
  public:

    virtual int controlCount(PanelControl& control) = 0;
    /*
     *  @param control reference to the control 
     *  @param index A 0 based integer used to find the name of the item 
     */
    virtual const char* controlName(PanelControl& control, int index) = 0;
  };


  class LWPanelMultiListControlCallBacks
  {
  public:

    virtual const char* controlMultiListName(PanelControl& control, int index, int column) = 0;

    virtual int controlMultiListColumnWidth(PanelControl& control, int index) = 0;
  };

  class PanelTreeNode
  {
    int m_flags;
  public:
    PanelTreeNode() : m_flags(0) {;}
    virtual ~PanelTreeNode() {;}
    virtual PanelTreeNode *getChild(int ) {return 0;}
    virtual int getChildCount() {return 0;}
    virtual const char *getName() = 0;
    virtual const char *getInfo(int *flags)
    {
      if (*flags)
      {
        m_flags = *flags;
      }
      else
      {
        *flags = m_flags;
      }
      return getName();
    }
  };

  class LWPanelTreeControlCallBacks
  {
  public:
    virtual PanelTreeNode* controlTreeGetRoot(lwpp::PanelControl& control) = 0;
    virtual PanelTreeNode* controlTreeChild(PanelControl& control, PanelTreeNode *node, int i)
    {
      if (node) return node->getChild(i);
      return controlTreeGetRoot(control)->getChild(i);
    }
    virtual int controlTreeCount(PanelControl& control, PanelTreeNode *node)
    {
      if (node) return node->getChildCount();
      return controlTreeGetRoot(control)->getChildCount();
    }
    virtual const char* controlTreeInfo(PanelControl& control, PanelTreeNode *node, int *flags)
    {
      if (node) return node->getInfo(flags);
      return controlTreeGetRoot(control)->getInfo(flags);
    }
    virtual void controlTreeMove(PanelControl& , PanelTreeNode *, PanelTreeNode *, int ) {;}
  };

  class LWPanel : public GlobalBase<LWPanelFuncs>
  {
  private:
    LWPanelID id; 
    bool close_on_destroy; 
    std::string title; 
  protected:
    /*
     * @param tag One of the pTag defined in lwpanel.h (line 175).
     * @param *data is the panel attribute cast as a void *
     */
    void get (pTag tag, void *data) const { globPtr->get(id, tag, data);}


    void set (pTag tag, void *data) { globPtr->set(id, tag, data);}


    LWControl *addControl (const char *type, LWPanControlDesc *desc, const char *label)
    {
      return globPtr->addControl(id, const_cast<char *>(type), desc, const_cast<char *>(label));
    }
  public:
    LWPanel ()
      : id(0),
        close_on_destroy(false)
    {
      ;
    }

    LWPanel (const std::string _title)
      : close_on_destroy(true),
        title(_title)
    {
      if (!available()) return; // in the case LWPanels aren't available - i.e. LWSN
      id = globPtr->create(const_cast<char *>(title.c_str()), globPtr);
    }

    LWPanel (LWPanelID pan_id)
      : id(pan_id),
        close_on_destroy(false)
    {
      ;
    }
    ~LWPanel ()
    {
      if (!available()) return; // in the case LWPanels aren't available - i.e. LWSN
      if (close_on_destroy)
      {
        globPtr->destroy(id);
        id = 0;
      }
    }
    LWPanel &operator=(const LWPanel &from)
    {
      if (&from != this)
      {
        id = from.id;
        close_on_destroy = false;
        title = from.title;
      }
      return *this;
    }
    /*
     * @param _title a std:string with the title for the panel
     * @param _close_on_destroy a bool value indicating if the panel is closed when the plugin is destroyed???
     */
    void Create (const std::string _title, bool _close_on_destroy = true)
    {
      title = _title;
      close_on_destroy = _close_on_destroy;
      id = globPtr->create(const_cast<char *>(title.c_str()), globPtr);
    }

    LWPanelID GetID() const { return id; }


    int Open (int flags)
    {
      return globPtr->open(id, flags);
    }
    int Post (int flags = 0)
    {
      return globPtr->open(id, PANF_BLOCKING | PANF_CANCEL | PANF_FRAME | flags);
    }
    void Close() {globPtr->close(id);}
    void ClearID() {id = 0;}
    void Recreate ()
    {
      if (id)
      {
        Close();
        globPtr->destroy(id);
        id = 0;
      }
      id = globPtr->create(const_cast<char *>(title.c_str()), globPtr);
    }
    void Recreate (const std::string _title)
    {
      if (id)
      {
        Close();
        globPtr->destroy(id);
        id = 0;
      }
      Create(_title);
    }
    int Handle (int block) { return globPtr->open(id, block); }

    void Draw(DrMode mode = DR_REFRESH) { globPtr->draw(id, mode); }

    LWControl *nextControl(LWControlID *ctl){ return globPtr->nextControl(id, ctl);}

    LWDrawFuncs getDrawFuncs()
    {
      return LWDrawFuncs(globPtr->drawFuncs, id);
    }

    // Draw functions
    void DrawLine(int color, int x1, int y1, int x2, int y2)
    {
      globPtr->drawFuncs->drawLine(id, color, x1, y1, x2, y2);
    }
    void DrawBorder(int indent, int x,int y,int w,int h = 0) const
    {
        globPtr->drawFuncs->drawBorder(id, indent, x, y, w, h);
    }

    void DrawResizeHandle()
    {
      int width = GetWidth();
      int height = GetHeight();
      DrawLine(LWP_WHITE, width-18, height-2, width-2,height-18 );
      DrawLine(LWP_WHITE, width-14, height-2, width-2,height-14 );
      DrawLine(LWP_WHITE, width-10, height-2, width-2,height-10 );
      DrawLine(LWP_WHITE, width-6, height-2, width-2,height-6 );

      DrawLine(LWP_BLACK, width-17, height-2, width-2,height-17 );
      DrawLine(LWP_BLACK, width-13, height-2, width-2,height-13 );
      DrawLine(LWP_BLACK, width-9, height-2, width-2,height-9 );
      DrawLine(LWP_BLACK, width-5, height-2, width-2,height-5 );
    }

    void *user_data() {return globPtr->user_data;}

    GlobalFunc *globalFun() {return globPtr->globalFun;}


    LWControl *AddChoice (const char *title, const char **items, bool orientation)
    {
      LWPanControlDesc desc;
      desc.type = LWT_CHOICE;
      desc.choice.vertical = orientation ? MX_HCHOICE : MX_VCHOICE;
      desc.choice.items=items;
      return addControl("ChoiceControl", &desc, title);
    }
    LWControl *AddPopUp (const char *title, const char **items, int width = 0)
    {
      LWPanControlDesc desc;
      desc.type = LWT_CHOICE;
      desc.choice.vertical=width;
      desc.choice.items=items;
      return addControl("PopupControl", &desc, title);
    }
    LWControl *AddFloat (const char *title, LWType type = LWT_FLOAT)
    {
      LWPanControlDesc desc;
      desc.type = type;
      return addControl("FloatControl", &desc, title);
    }
    LWControl *AddDistance (const char *title) { return AddFloat(title, LWT_DISTANCE); }
    LWControl *AddFloatInfo (const char *title)
    {
      LWPanControlDesc desc;
      desc.type = LWT_FLOAT;
      return addControl("FloatInfoControl", &desc, title);
    }
    LWControl *AddFloatVector (const char *title, LWType type = LWT_VFLOAT)
    {
      LWPanControlDesc desc;
      desc.type = type;
      return addControl("FVecControl", &desc, title);
    }
    LWControl *AddDistanceVector (const char *title) {return AddFloatVector(title, LWT_VDIST);}
    LWControl *AddFloatVectorInfo (const char *title)
    {
      LWPanControlDesc desc;
      desc.type = LWT_VFLOAT;
      return addControl("FVecInfoControl", &desc, title);
    }

    LWControl *AddItem (const char *title, LWItemType type, int width = 0)
    {
      LWPanControlDesc desc;
      desc.type=LWT_LWITEM;
      desc.lwitem.global=reinterpret_cast<void *>(lwpp::SuperGlobal);
      desc.lwitem.itemType=type;
      desc.lwitem.list=NULL;
      desc.lwitem.count=0;
      desc.lwitem.width=width;
      return addControl("LWListControl", &desc, title);
    }
    LWControl *AddPickItem (const char *title, LWItemType type, int width)
    {
      LWPanControlDesc desc;
      desc.type=LWT_LWITEM;
      desc.lwitem.global=reinterpret_cast<void *>(lwpp::SuperGlobal);
      desc.lwitem.itemType=type;
      desc.lwitem.list=NULL;
      desc.lwitem.count=0;
      desc.lwitem.width=width;
      return addControl("LWPickListControl", &desc, title);
    }
    LWControl *AddButton (const char *title, int width = 0)
    {
      LWPanControlDesc desc;
      desc.type=LWT_INTEGER;
      if (width != 0)
      {
        desc.type=LWT_AREA;
        desc.area.width=width;
        desc.area.height=0;
      }
      return addControl("ButtonControl", &desc, title);
    }
    LWControl *AddBoolean (const char *title, int width = 0)
    {
      LWPanControlDesc desc;
      desc.type=LWT_BOOLEAN;
      desc.area.width=width;
      desc.area.height=0;
      return addControl("BoolControl", &desc, title);
    }
    LWControl *AddBoolButton (const char *title, int width = 0)
    {
      LWPanControlDesc desc;
      desc.type= (width == 0 ) ? LWT_BOOLEAN : LWT_AREA; // is this actually correct in the SDK macros?
      desc.area.width=width;
      desc.area.height=0;
      return addControl("BoolButtonControl", &desc, title);
    }

    LWControl *AddInteger (const char *title, int width = 0)
    {
      width;
      LWPanControlDesc desc;
      desc.type= LWT_INTEGER;
      return addControl("NumControl", &desc, title);
    }
    LWControl *AddIntegerInfo (const char *title, int width = 0)
    {
      width;
      LWPanControlDesc desc;
      desc.type= LWT_INTEGER;
      return addControl("NumInfoControl", &desc, title);
    }

    LWControl *AddSlider (const char *title, int min, int max, int width, const char *type = "SliderControl")
    {
      LWPanControlDesc desc;
      desc.type=LWT_RANGE;
      desc.range.width=width;
      desc.range.min=min;
      desc.range.max=max;
      return addControl(type, &desc, title);
    }
    LWControl *AddVerticalSlider (const char *title, int min, int max, int width)
    {
      return AddSlider(title, min, max, width, "VSlideControl");
    }
    LWControl *AddHorizontalSlider (const char *title, int min, int max, int width)
    {
      return AddSlider(title, min, max, width, "HSlideControl");
    }
    LWControl *AddUnboundSlider (const char *title, int min, int max, int width)
    {
      return AddSlider(title, min, max, width, "UnboundSlideControl");
    }
    LWControl *AddMiniSlider (const char *title, int min, int max, int width)
    {
      return AddSlider(title, min, max, width, "MiniSliderControl");
    }

    LWControl *AddVector (const char *title, const char *type = "VecControl")
    {
      LWPanControlDesc desc;
      desc.type = LWT_VINT;
      return addControl(type, &desc, title);
    }
    LWControl *AddVectorInfo (const char *title) { return AddVector(title,"VecInfoControl"); }
    LWControl *AddRGB (const char *title) { return AddVector(title,"RGBControl"); }
    LWControl *AddMiniRGB (const char *title) { return AddVector(title,"MiniRGBControl"); }
    LWControl *AddMiniHSV (const char *title) { return AddVector(title,"MiniHSVControl"); }
    LWControl *AddRGBVector (const char *title) { return AddVector(title,"RGBVecControl"); }
    LWControl *AddString (const char *title, int width, const char *type = "EditControl")
    {
      LWPanControlDesc desc;
      desc.type = LWT_STRING;
      desc.string.width=width;
      return addControl(type, &desc, title);
    }
    LWControl *AddStringInfo (const char *title, int width) { return AddString(title, width, "InfoControl"); }
    LWControl *AddFile (const char *title, int width) { return AddString(title, width, "FileControl");}
    LWControl *AddFileButton (const char *title, int width) { return AddString(title, width, "FileButtonControl");}
    LWControl *AddLoad (const char *title, int width) { return AddString(title, width, "LoadControl");}
    LWControl *AddLoadButton (const char *title, int width) {return AddString(title, width, "LoadButtonControl");}
    LWControl *AddSave (const char *title, int width) { return AddString(title, width, "SaveControl");}
    LWControl *AddSaveButton (const char *title, int width) {return AddString(title, width, "SaveButtonControl");}
    LWControl *AddDir (const char *title, int width){return AddString(title, width, "DirControl");}
    LWControl *AddDirButton (const char *title, int width){return AddString(title, width, "DirButtonControl");}
    LWControl *AddText (const char *title, const char**text)
    {
      LWPanControlDesc desc;
      desc.type = LWT_TEXT;
      desc.text.text=text;
      return addControl("TextControl", &desc, title);
    }
    LWControl *AddArea (const char *title, int width, int height, const char *type = "AreaControl")
    {
      LWPanControlDesc desc;
      desc.type = LWT_AREA;
      desc.area.width=width;
      desc.area.height=height;
      return addControl(type, &desc, title);
    }
    LWControl *AddOpenGL (const char *title, int width, int height) {return AddArea(title, width, height, "OpenGLControl");}
    LWControl *AddCanvas (const char *title, int width, int height) {return AddArea(title, width, height, "CanvasControl");}
    LWControl *AddDragButton (const char *title, int width, int height){return AddArea(title, width, height, "DragButtonControl");}
    LWControl *AddVDragButton (const char *title){return AddArea(title, 0, -1, "DragButtonControl");}
    LWControl *AddHDragButton (const char *title){return AddArea(title, -1, 0, "DragButtonControl");}
    LWControl *AddDragArea (const char *title, int width, int height){return AddArea(title, width, height, "DragAreaControl");}
    LWControl *AddBorder (const char *title, int width, int height){return AddArea(title, width, height, "BorderControl");}
    LWControl *AddChannel (const char *title, int width, int height){return AddArea(title, width, height, "ChannelControl");}
    LWControl *AddPalette (const char *title, int width, int height)
    {
      LWPanControlDesc desc;
      desc.type = LWT_RANGE;
      desc.area.width=width;
      desc.area.height=height;
      return addControl("PaletteControl", &desc, title);
    }
    LWControl *AddPercent (const char *title)
    {
      LWPanControlDesc desc;
      desc.type = LWT_RANGE;
      desc.range.min=0;
      desc.range.max=100;
      return addControl("PercentControl", &desc, title);
    }
    LWControl *AddAngle (const char *title)
    {
      LWPanControlDesc desc;
      desc.type = LWT_RANGE;
      desc.range.min=0;
      desc.range.max=360;
      return addControl("AngleControl", &desc, title);
    }
    LWControl *AddCustomPopup (const char *title, int width, int (*count)(void *), char *(*name)(void *, int))
    {
      LWPanControlDesc desc;
      desc.type = LWT_POPUP;
      desc.popup.width=width;
      desc.popup.nameFn=name;
      desc.popup.countFn=count;
      return addControl("CustomPopupControl", &desc, title);
    }
    template<typename T>
    LWControl *AddCustomPopup (const char *title, int width)
    {
      LWPanControlDesc desc;
      desc.type = LWT_POPUP;
      desc.popup.width=width;
      desc.popup.nameFn=PanelControlAdaptor<T>::cb_Name;
      desc.popup.countFn=PanelControlAdaptor<T>::cb_Count;
      PanelControl control = addControl("CustomPopupControl", &desc, title);
      control.SetUserData(control.getControl());
      return control.getControl();
    }
    LWControl *AddPopdown (const char *title, const char **items)
    {
      LWPanControlDesc desc;
      desc.type = LWT_CHOICE;
      desc.choice.vertical=MX_POPUP;
      desc.choice.items=items;
      return addControl("PopDownControl", &desc, title);
    }
    LWControl *AddTabs (const char *title, const char **items)
    {
      LWPanControlDesc desc;
      desc.type = LWT_CHOICE;
      desc.choice.vertical=MX_HCHOICE;
      desc.choice.items=items;
      return addControl("TabChoiceControl", &desc, title);
    }
    LWControl *AddXPanel (const char *title, LWXPanelID xp)
    {
      LWPanControlDesc desc;
      desc.type = LWT_XPANEL;
      desc.xpanel.xpan=xp;
      return addControl("XPanelControl", &desc, title);
    }

    LWControl *AddListbox (const std::string &title, int width, int (*count)(void *), char *(*name)(void *, int), int items, int topVisible = 0)
    {
      LWPanControlDesc desc;
      desc.type = LWT_POPUP;
      desc.listbox.width=width;
      desc.listbox.nameFn=name;
      desc.listbox.countFn=count;
      desc.listbox.visItems=items;
      desc.listbox.top = topVisible;
      return addControl("ListBoxControl", &desc, title.c_str());
    }



    template<typename T>
    LWControl *AddListbox (const std::string &title, int width, int items, int topVisible = 0)
    {
      LWPanControlDesc desc;
      desc.type = LWT_POPUP;
      desc.listbox.width=width;
      desc.listbox.nameFn=PanelControlAdaptor<T>::cb_Name;
      desc.listbox.countFn=PanelControlAdaptor<T>::cb_Count;
      desc.listbox.visItems=items;
      desc.listbox.top = topVisible;
      PanelControl control = addControl("ListBoxControl", &desc, title.c_str());
      control.SetUserData(control.getControl());
      return control.getControl();
    }
    template<typename T>
    void AddListbox (PanelControl &control, const std::string &title, int width, int items, int topVisible = 0)
    {
      LWPanControlDesc desc;
      desc.type = LWT_POPUP;
      desc.listbox.width=width;
      desc.listbox.nameFn=PanelControlAdaptor<T>::cb_Name;
      desc.listbox.countFn=PanelControlAdaptor<T>::cb_Count;
      desc.listbox.visItems=items;
      desc.listbox.top = topVisible;
      control = addControl("ListBoxControl", &desc, title.c_str());
      control.SetUserData(control.getControl());
    }
    template<typename T>
    void AddListbox (PanelControl &control, int width, int items, int topVisible = 0)
    {
      LWPanControlDesc desc;
      desc.type = LWT_POPUP;
      desc.listbox.width=width;
      desc.listbox.nameFn=PanelControlAdaptor<T>::cb_Name;
      desc.listbox.countFn=PanelControlAdaptor<T>::cb_Count;
      desc.listbox.visItems=items;
      desc.listbox.top = topVisible;
      control = addControl("ListBoxControl", &desc, 0);
      control.SetUserData(control.getControl());
      return control.getControl();
    }
    template<typename T>
    LWControl *AddListbox (int width, int items, int topVisible = 0)
    {
      LWPanControlDesc desc;
      desc.type = LWT_POPUP;
      desc.listbox.width=width;
      desc.listbox.nameFn=PanelControlAdaptor<T>::cb_Name;
      desc.listbox.countFn=PanelControlAdaptor<T>::cb_Count;
      desc.listbox.visItems=items;
      desc.listbox.top = topVisible;
      PanelControl control = addControl("ListBoxControl", &desc, 0);
      control.SetUserData(control.getControl());
      return control.getControl();
    }






    LWControl *AddMultiListbox (const char *title, int width, int items, int topVisible,
                                int (*count)(void *),
                                char *(*name)(void *, int, int),
                                int (*colwidth)(void *, int i))
    {
      LWPanControlDesc desc;
      desc.type = LWT_MLIST;
      desc.multiList.width=width;
      desc.multiList.nameFn=name;
      desc.multiList.countFn=count;
      desc.multiList.visItems = items;
      desc.multiList.top = topVisible;
      desc.multiList.colWidth=colwidth;
      return addControl("MultiListBoxControl", &desc, title);
    }






    template<typename T>
    LWControl *AddMultiListbox (const char *title, int width, int items, int topVisible = 0)
    {
      LWPanControlDesc desc;
      desc.type = LWT_MLIST;
      desc.multiList.width=width;
      desc.multiList.visItems=items;
      desc.multiList.top=topVisible;      
      desc.multiList.nameFn=PanelControlAdaptor<T>::cb_MultiListName;
      desc.multiList.countFn=PanelControlAdaptor<T>::cb_Count;
      desc.multiList.colWidth=PanelControlAdaptor<T>::cb_MultiListColumnWidth;
      PanelControl control = addControl("MultiListBoxControl", &desc, title);
      control.SetUserData(control.getControl());
      return control.getControl();
    }

    template<typename T>
    void AddMultiListbox (PanelControl &control, const char *title, int width, int items, int topVisible = 0)
    {
      LWPanControlDesc desc;
      desc.type = LWT_MLIST;
      desc.multiList.width=width;
      desc.multiList.visItems=items;
      desc.multiList.top=topVisible;      
      desc.multiList.nameFn=PanelControlAdaptor<T>::cb_MultiListName;
      desc.multiList.countFn=PanelControlAdaptor<T>::cb_Count;
      desc.multiList.colWidth=PanelControlAdaptor<T>::cb_MultiListColumnWidth;
      control = addControl("MultiListBoxControl", &desc, title);
      control.SetUserData(control.getControl());      
    }


    template<typename T>
    LWControl *AddTree (const char *title, int width, int height)
    {
      LWPanControlDesc desc;
      desc.type = LWT_TREE;
      desc.tree.width=width;
      desc.tree.height=height;
      desc.tree.infoFn=PanelControlAdaptor<T>::cb_TreeInfo;
      desc.tree.countFn=PanelControlAdaptor<T>::cb_TreeCount;
      desc.tree.leafFn=PanelControlAdaptor<T>::cb_TreeChild;
      desc.tree.moveFn=0;
      PanelControl control = addControl("TreeControl", &desc, title);
      control.SetUserData(control.getControl());
      return control.getControl();
    }
    LWControl *AddTree (const char *title, int width, int height,
                        int   (*count)(void *data, void *node),
                        void *(*leaf)(void *data, void *node, int i),
                        char *(*info)(void *data, void *node, int *nodeFlags),
                        void  (*move)(void *data, void *node, void *parentNode, int i) = 0
                       )
    {
      LWPanControlDesc desc;
      desc.type = LWT_TREE;
      desc.tree.width=width;
      desc.tree.height=height;
      desc.tree.infoFn=info;
      desc.tree.countFn=count;
      desc.tree.leafFn=leaf;
      desc.tree.moveFn=move;
      return addControl("TreeControl", &desc, title);
    }
    // Set
    void Set (void *p, pTag tag)
    {
      set(tag, p);
    }
    void Set (int i, pTag tag)
    {
      set(tag, &i);
    }

    // Get any integer tag
    int GetInt(pTag tag) const
    {
      int i;
      get(tag, &i);
      return i;
    }
    // Get any pointer
    void *GetPointer(pTag tag)
    {
      LWValue pval;
      get(tag, &pval);
      return pval.ptr.ptr;
    }
    void Set(pTag tag, void *p)
    {
      set(tag, p);
    }
    int GetWidth() const {return GetInt(PAN_W);}
    void SetWidth(int w){Set(w, PAN_W);}
    int GetHeight() const {return GetInt(PAN_H);}
    void SetHeight(int h){Set(h, PAN_H);}
    int GetQualifiers(){return GetInt(PAN_QUALIFIERS);}
    void SetUserData (void *d){set(PAN_USERDATA, d);}
    void ToFront() {Set(1, PAN_TO_FRONT);}
    void SetTitle(std::string &s) {Set(const_cast<char*>(s.c_str()), PAN_TITLE);}
    void *GetUserData ()
    {
      void *ud;
      get(PAN_USERDATA, &ud);
      return ud;
    }
    void SetUserDraw (LWPanDrawHook d){set(PAN_USERDRAW, reinterpret_cast<void*>(d));}
    void SetUserKeys (LWPanKeyHook d) {set(PAN_USERKEYS, reinterpret_cast<void*>(d));}
    void SetUserKeyUp (LWPanKeyHook d) {set(PAN_USERKEYUPS, reinterpret_cast<void*>(d));}
    void SetUserActivate (LWPanHook d) {set(PAN_USERACTIVATE, reinterpret_cast<void*>(d));}
    void SetUserOpen (LWPanHook d) {set(PAN_USEROPEN, reinterpret_cast<void*>(d));}
    void SetUserClose (LWPanHook d) {set(PAN_USERCLOSE, reinterpret_cast<void*>(d));}
    void SetUserMouseMove (LWPanMouseHook d) {set(PAN_MOUSEMOVE, reinterpret_cast<void*>(d));}
    void SetUserMouseButton (LWPanMouseHook d) {set(PAN_MOUSEBUTTON, reinterpret_cast<void*>(d));}

    template <typename T>
    void SetCallbacks(T *host)
    {
      SetUserData(host);
      SetUserDraw(cb_PanDraw<T>);
      SetUserMouseButton(cb_PanMouseButton<T>);
      SetUserMouseMove(cb_PanMouseMove<T>);
      SetUserActivate(cb_PanActivate<T>);
      SetUserOpen(cb_PanOpen<T>);
      SetUserClose(cb_PanClose<T>);
      SetUserKeys(cb_PanKeyDown<T>);
      SetUserKeyUp(cb_PanKeyUp<T>);
    }

    // static callbacks
    template<typename T>  static void cb_PanDraw(LWPanelID id, void *userdata, DrMode DrawMode)
    {
        if (T *instance = static_cast<T *>(userdata))
        {
          instance->panelDraw(LWPanel(id), DrawMode);
        }
    }

    template<typename T>  static void cb_PanActivate(LWPanelID id, void *userdata);

    template<typename T>  static void cb_PanOpen(LWPanelID id, void *userdata);

    template<typename T>  static void cb_PanClose(LWPanelID id, void *userdata);

    template<typename T> static int cb_PanKeyDown (LWPanelID id, void *userdata, LWDualKey key);

    template<typename T>  static int cb_PanKeyUp (LWPanelID id, void *userdata, LWDualKey key);

    template<typename T>  static void cb_PanMouseButton (LWPanelID id, void *userdata, int qualifiers, int x, int y);

    template<typename T>  static void cb_PanMouseMove (LWPanelID id, void *userdata, int qualifiers, int x, int y);
    
    template<typename T>  static void cb_PanResize (LWPanelID id,  void *userdata, int w, int h);
  };

  class LWRaster : public GlobalBase<LWRasterFuncs>
  {
    LWRasterID id;
    int lastX, lastY;
  public:
    LWRaster(int w, int h, int flags = 0) : id(0)
    {
      create(w, h, flags);
    }
    LWRaster() : id(0)
    {
      ;
    }
    ~LWRaster()
    {
      if (id)
      {
        globPtr->destroy(id);
        id = 0;
      }
    }
    void create(int w, int h, int flags = 0)
    {
      if (id) globPtr->destroy(id);
      id = globPtr->create(w, h, flags);
    }
    void drawPixel(int c, int x, int y)
    {
      globPtr->drawPixel(id, c, x, y);
    }
    void drawPixel(int r, int g, int b, int x, int y)
    {
      globPtr->drawRGBPixel(id, r, g, b, x, y);
    }
    void moveTo(int x, int y)
    {
      lastX = x; lastY = y;
    }
    void drawTo(int c, int x, int y)
    {
      drawLine(c, lastX, lastY, x, y);
      moveTo(x,y);
    }
    void drawLine(int c, int x1, int y1, int x2, int y2)
    {
      globPtr->drawLine(id, c, x1, y1, x2, y2);
    }
    void drawBox(int c, int x, int y, int w, int h)
    {
      globPtr->drawBox(id, c, x, y, w, h);
    }
    void drawBox(int r, int g, int b, int x, int y, int w, int h)
    {
      globPtr->drawRGBBox(id, r, g, b, x, y, w, h);
    }

    void drawRoundBox(int c, int x, int y, int w, int h, int bevel = 2);
    void drawBoxOutline(int c, int x, int y, int w, int h);
    void fillRoundBox(int c, int x, int y, int w, int h, int bevel = 2);

    void eraseBox(int x, int y, int w, int h)
    {
      globPtr->eraseBox(id, x, y, w, h);
    }
    void drawBorder(int indent, int x, int y, int w, int h = 0)
    {
      globPtr->drawBorder(id, indent, x, y, w, h);
    }
    void drawText(std::string s, int c, int x, int y)
    {
      globPtr->drawText(id, const_cast<char *>(s.c_str()), c, x, y);
    }
    void blitPanel(int srcx, int srcy, LWPanelID pan, int destx, int desty, int w, int h)
    {
      globPtr->blitPanel(id, srcx, srcy, pan, destx, desty, w, h);
    }
    void blitPanel(int srcx, int srcy, LWPanel &pan, int destx, int desty, int w, int h)
    {
      blitPanel(srcx, srcy, pan.GetID(), destx, desty, w, h);
    }
    void blitRaster(LWRasterID raster, int srcx, int srcy, int destx, int desty, int w, int h)
    {
      globPtr->blitRaster(id, srcx, srcy, raster, destx, desty, w, h);
    }
    void blitRaster(LWRaster &raster, int srcx, int srcy, int destx, int desty, int w, int h)
    {
      blitRaster(raster.id, srcx, srcy, destx, desty, w, h);
    }
  };
  
  class LWPanelCallbacks
  {
      friend class LWPanel;
    public:
      virtual void panelDraw(const LWPanel&, DrMode ) {;}
      virtual void panelActivate(const LWPanel&) {;}
      virtual void panelOpen(const LWPanel&) {;}
      virtual void panelClose(const LWPanel&) {;}
      virtual int panelKeyDown(const LWPanel&, LWDualKey ) {return 0;}
      virtual int panelKeyUp(const LWPanel&, LWDualKey ) {return 0;}
      virtual void panelMouseButton(const LWPanel&, int , int, int) {;}
      virtual void panelMouseMove(const LWPanel&, int , int, int) {;}
  };

  template<typename T>
  T *getEventHandler(PanelControl &control)
  {
    if (control.isValid())
    {
      LWPanel panel(control.PanelID());
      return static_cast<T *>(panel.GetUserData());
    }
    return 0;
  }

  // Callbacks for Panel controls
  template <typename T>
  void PanelControlAdaptor<T>::cb_Event(LWControlID id, void *)
  {
    PanelControl control(id);
    if (T *eventHandler = getEventHandler<T>(control))
    {
      eventHandler->controlEvent(control);
    }
  }
  template <typename T>
  void PanelControlAdaptor<T>::cb_Draw(LWControlID id, void *, DrMode mode)
  {
    PanelControl control(id);
    if (T *eventHandler = getEventHandler<T>(control))
    {
      eventHandler->controlDraw(control, mode);
    }
  }
  template <typename T>
  int PanelControlAdaptor<T>::cb_Count(void *userdata)
  {
    PanelControl control(static_cast<LWControlID>(userdata));
    if (T *eventHandler = getEventHandler<T>(control))
    {
      return eventHandler->controlCount(control);
    }
    return 0;
  }
  template <typename T>
  char *PanelControlAdaptor<T>::cb_Name(void *userdata, int index)
  {
    PanelControl control(static_cast<LWControlID>(userdata));
    if (T *eventHandler = getEventHandler<T>(control))
    {
      return const_cast<char *>(eventHandler->controlName(control, index));
    }
    return const_cast<char *>("");
  }
    template <typename T>
  char *PanelControlAdaptor<T>::cb_MultiListName(void *userdata, int index, int column)
  {
    PanelControl control(static_cast<LWControlID>(userdata));
    if (T *eventHandler = getEventHandler<T>(control))
    {
      return const_cast<char *>(eventHandler->controlMultiListName(control, index, column));
    }
    return const_cast<char *>("");
  }
  template <typename T>
  int PanelControlAdaptor<T>::cb_MultiListColumnWidth(void *userdata, int index)
  {
    PanelControl control(static_cast<LWControlID>(userdata));
    if (T *eventHandler = getEventHandler<T>(control))
    {
      return eventHandler->controlMultiListColumnWidth(control, index);
    }
    return 0;
  }
  template <typename T>
  void *PanelControlAdaptor<T>::cb_TreeChild(void *userdata, void *node, int i)
  {
    PanelControl control(static_cast<LWControlID>(userdata));
    if (T *eventHandler = getEventHandler<T>(control))
    {
      return eventHandler->controlTreeChild(control, (PanelTreeNode *)node, i);
    }
    return 0;
  }
  template <typename T>
  int PanelControlAdaptor<T>::cb_TreeCount(void *userdata, void *node)
  {
    PanelControl control(static_cast<LWControlID>(userdata));
    if (T *eventHandler = getEventHandler<T>(control))
    {
      return eventHandler->controlTreeCount(control, (PanelTreeNode *)node);
    }
    return 0;
  }
  template <typename T>
  char *PanelControlAdaptor<T>::cb_TreeInfo(void *userdata, void *node, int *flags)
  {
    PanelControl control(static_cast<LWControlID>(userdata));
    if (T *eventHandler = getEventHandler<T>(control))
    {
      return const_cast<char *>(eventHandler->controlTreeInfo(control, (PanelTreeNode *)node, flags));
    }
    return const_cast<char *>("");
  }
  template <typename T>
  void PanelControlAdaptor<T>::cb_TreeMove(void *userdata, void *node, void *parent, int i)
  {
    PanelControl control(static_cast<LWControlID>(userdata));
    if (T *eventHandler = getEventHandler<T>(control))
    {
      eventHandler->controlTreeMove(control, (PanelTreeNode *)node, parent, i);
    }
  }

  /*
   * Panel Callbacks
   */


  template<typename T>
  void LWPanel::cb_PanActivate(LWPanelID id, void *userdata)
  {
    if (T *instance = static_cast<T *>(userdata))
    {
      instance->panelActivate(LWPanel(id));
    }
  }
  template<typename T>
  void LWPanel::cb_PanOpen(LWPanelID id, void *userdata)
  {
    if (T *instance = static_cast<T *>(userdata))
    {
      instance->panelOpen(LWPanel(id));
    }
  }
  template<typename T>
  void LWPanel::cb_PanClose(LWPanelID id, void *userdata)
  {
    if (T *instance = static_cast<T *>(userdata))
    {
      instance->panelClose(LWPanel(id));
    }
  }
  template<typename T>
  int LWPanel::cb_PanKeyDown (LWPanelID id, void *userdata, LWDualKey key)
  {
      if (T *instance = static_cast<T *>(userdata))
      {
        return instance->panelKeyDown(LWPanel(id), key);
      }
      return 0; // The keypress has not been processed
  }
  template<typename T>
  int LWPanel::cb_PanKeyUp (LWPanelID id, void *userdata, LWDualKey key)
  {
      if (T *instance = static_cast<T *>(userdata))
      {
        return instance->panelKeyUp(LWPanel(id),key);
      }
      return 0; // The keypress has not been processed
  }
  
  template<typename T>
  void LWPanel::cb_PanMouseButton (LWPanelID id, void *userdata, int qualifiers, int x, int y)
  {
      if (T *instance = static_cast<T *>(userdata))
      {
        return instance->panelMouseButton(LWPanel(id), qualifiers, x, y);
      }
  }
  template<typename T>
  void LWPanel::cb_PanMouseMove (LWPanelID id, void *userdata, int qualifiers, int x, int y)
  {
      if (T *instance = static_cast<T *>(userdata))
      {
        instance->panelMouseMove(LWPanel(id), qualifiers, x, y);
      }
  }

  template<typename T>
  void LWPanel::cb_PanResize (LWPanelID id,  void *userdata, int w, int h)
  {
      if (T *instance = static_cast<T *>(userdata))
      {
        instance->panelResize(LWPanel(id), w, h);
      }
  }
   



  class AboutPanel : private LWPanel
  {
  private:
    const unsigned char *image;
    int width;
    int height;
    LWRaster mRaster;
    PanelControl canvas;
    void draw(LWControlID control, DrMode drawmode);
  public:
    AboutPanel(const std::string title, const char**message, const unsigned char *_image = 0, int w = 0, int h = 0);
    ~AboutPanel();
    void Open();
    static void UserDraw( LWControlID control, void *userdata, DrMode drawmode );
  };

  class LogPanel : private LWPanel, protected LWPanelListCallBacks, public std::vector<std::string>
  {
    PanelControl listbox;
    int w, h;
  public:
    virtual int controlCount(PanelControl&);
    virtual const char* controlName(PanelControl&, int index);
  public:
    LogPanel(const std::string &title, int width = 600, int height = 20)
      : LWPanel (title), w(width), h(height)
    {;}
    void Open(const std::string &name);
  };

  class Qualifier
  {
    int mQualifier;
  public:
    Qualifier(const int qual)
      : mQualifier(qual)
    {}
    bool isRightClick() const {return RCLICK(mQualifier);}
    bool isLeftClick() const {return LCLICK(mQualifier);}
    bool isMiddleClick() const {return MCLICK(mQualifier);}
    bool isMouseDown() const {return (mQualifier & MOUSE_DOWN) == MOUSE_DOWN;}
    bool isCtrl() const {return (mQualifier & IQ_CTRL) == IQ_CTRL;}
    bool isShift() const {return (mQualifier & IQ_SHIFT) == IQ_SHIFT;}
    bool isAlt() const {return (mQualifier & IQ_ALT) == IQ_ALT;}
    bool isConstrain() const {return (mQualifier & IQ_CONSTRAIN) == IQ_CONSTRAIN;}
    bool isAdjust() const {return (mQualifier & IQ_ADJUST) == IQ_ADJUST;}
  };

} // namespace lwpp

#endif // LWPP_PANEL_H