listbox.h

/*
    An virtual parent for FGListBox that implement all stuff

  $Id: listbox.h,v 1.7 2005/01/31 07:46:30 majo Exp $

  $Log: listbox.h,v $
  Revision 1.7  2005/01/31 07:46:30  majo
  fgx + pointbutton&checkbutton rename

  Revision 1.6  2005/01/03 07:47:18  majo
  xmas, gradient, lrmi

  Revision 1.5  2004/10/13 12:32:46  majo
  warnings only`

  Revision 1.4  2004/10/12 12:25:19  majo
  make ~FGListBox() as private (no direct call is permitted)

  Revision 1.3  2004/05/24 17:41:44  majo
  documentation

  Revision 1.2  2004/02/23 20:08:01  majo
  all classes are with prefix FG* on now
  polygon functions uses FGPointArray from now
  class GuiEvent is renamed to FGEvent
  some by parameters overloaded methods was removed (class FGWindow)
  many other small changes

  Revision 1.1.1.1  2004/01/22 16:25:08  majo
  initial release

*/

#ifndef __LISTBOX__
#define __LISTBOX__

#include <vector>

#ifdef __BORLANDC__
#pragma option push -b
#pragma option push -a4
#endif

#ifdef FG_NAMESPACE
namespace fgl {
#endif

class listbox : public FGSlider
{
        static  void    lbCall(FGControl *T);
        void    corecture(void);

    protected:
        int         cursor;             // visible cursor
        int         slider;             // for position of slider
        int         drop_down;          // size in visible lines
        unsigned    color_bg0, color_bg1, color_fg0, color_fg1; // colors
        int         xx, yy,             // top left of widgets
                    curr,               // current item or -1
                    count,              // 0 ...
                    fpol,               // first visible
                    line,               // Y-position of line
                    onew, oneh;         // width x height of one item

        void    Cursor(int);
        int     AdjustCursor(int item);
        int     Enabled(void) { if (curr<0 || count<=0) return 0; return 1;}
        listbox(int xs, int ys, int w, int h, int DropDown, FGWindow *wind);

        virtual void draw(void); // for slider
        virtual void DrawItem(int , int , int , int ) {}
        virtual void WheelSpin(int direction)
        {
            if (direction<0) Up();
            else if (direction>0) Down();
        }

    public:
        void    SetColors(int a, int b, int c, int d)
        {
            color_bg0 = a;
            color_fg0 = b;
            color_bg1 = c;
            color_fg1 = d;
        }
        void    Draw(int i=1);  // for listbox, default with cursor
        void    ShowCursor(void);
        void    HideCursor(void);
        void    Up(void);
        void    Down(void);
        void    Begin(void);
        void    End(void);
        void    SetSize(int);
        int     GetSize(void) const { return count; };
        void    SetIndex(int);
        int     GetIndex(void) const { return curr; };
        void    SetIndexRel(int);
        int     GetCurrent(void) const { return GetIndex(); };
        void    SetToItemRel(int a) { SetIndexRel(a); }
        void    Resize(int a) { SetSize(GetSize()+a); }
        void    SetToItem(int a) { SetIndex(a); }
        void    RedrawItem(void)
        {
            ShowCursor();
        }
        int     Test(int, int);
        int     DoListBox(int key);
        virtual const int ToInteger() const { return GetIndex(); }
};

template <typename T> class FGListBoxTemplate : public listbox
{
    protected:

        typedef typename std::vector<T>::iterator Iter;
        std::vector<T>      items;
        int                 update;
        FGListBoxCallBack   show;
        void*               user_data;

        virtual void DrawItem(int x, int y, int index, int flag) { }
    public:
        FGListBoxTemplate(
            int xs,
            int ys,
            int w,
            int h,
            int DropDown,
            FGWindow *wind,
            FGListBoxCallBack show_cb,
            void* user_ptr = 0)
            : listbox(xs,ys,w,h,DropDown,wind)
        {
            update = 0;
            show = show_cb;
            user_data = user_ptr;
        }
        void DisableUpdate(void) { update = 0; }
        void Update(void)
        {
            update = 1;
            Draw(1);
        }
        void erase(int i)
        {
            items.erase(items.begin()+i);
            count--;
            if (update) Draw(0);
        }
        void clear(void)
        {
            count = fpol = line = curr = 0;
            Draw(0);
            update = 0;
            items.clear();
        }
        void insert(T s)
        {
            items.push_back(s);
            count++;
            if (update) Draw(0);
        }
        void insert(int i, T s)
        {
            items.insert(items.begin()+i,s);
            count++;
            if (update) Draw(0);
        }
        void replace(int i, T s)
        {
            Iter ti = items.begin();
            ti[i] = T(s);
        }
        const T& item(int i) const { return items[i]; }
};

struct id_string
{
    char str[64];
    id_string()
    {
        *str=0;
    }
    id_string(const char *s)
    {
        strncpy(str,s,63);
        str[63]=0;
    }
};

class FGListBox : public FGListBoxTemplate<struct id_string>
{
        typedef std::vector<id_string>::iterator Iter;
        friend class FWindow;
        virtual void DrawItem(int x, int y, int index, int flag)
        {
            if (index>=count) return; // out of range
            Iter i=items.begin();

            if (user_data)
            {
                if (show)
                    show(flag, owner, x, y, user_data, index);
            }
            else
            {
                if (show==0)
                    owner->WindowText(x+4, y, i[index].str, flag?color_fg1:color_fg0,flag?color_bg1:color_bg0);
                else
                    show(flag, owner, x, y, i[index].str, index);
            }
        }
        ~FGListBox() {}
    public:
        FGListBox(int xs, int ys, int w, int h, int DropDown, FGWindow *wind, FGListBoxCallBack show_cb=0, void* user_data = 0)
         : FGListBoxTemplate<id_string>(xs, ys, w, h, DropDown, wind, show_cb, user_data)
        {
        }
        const char *GetString(int i) const { return item(i).str; }
        virtual const char* ToString() const { return GetString(GetIndex()); }
};

#ifdef __BORLANDC__
#pragma option pop /* pop -a switch */
#pragma option pop /* pop -b */
#endif

#ifdef FG_NAMESPACE
}
#endif

#endif

---