GList.h

Go to the documentation of this file.

#ifndef __GLIST2_H
#define __GLIST2_H

// Includes
#include "GPopup.h"
#include "GArray.h"

// GList notification flags

#define GLIST_NOTIFY_INSERT         0
#define GLIST_NOTIFY_DELETE         1
#define GLIST_NOTIFY_SELECT         2
#define GLIST_NOTIFY_CLICK          3
#define GLIST_NOTIFY_DBL_CLICK      4
#define GLIST_NOTIFY_CHANGE         5
#define GLIST_NOTIFY_COLS_CHANGE    6
#define GLIST_NOTIFY_COLS_SIZE      7
#define GLIST_NOTIFY_COLS_CLICK     8
#define GLIST_NOTIFY_BACKSPACE      9
#define GLIST_NOTIFY_RETURN         13
#define GLIST_NOTIFY_DEL_KEY        14
#define GLIST_NOTIFY_ESC_KEY        15

// Messages
#define WM_END_EDIT_LABEL           (WM_USER+0x556)

// Constants
#define DEFAULT_COLUMN_SPACING      12


enum GListMode
{
    GListDetails,
    GListColumns,
    GListSpacial,
};

class LgiClass GMeasureInfo
{
public:
    int x;
    int y;
};

class LgiClass GItem : virtual public GEventsI
{
    GAutoPtr<GViewFill> _Fore, _Back;
    
public:
    struct ItemPaintCtx : public GRect
    {
        GSurface *pDC;

        COLOUR Fore;
        COLOUR Back;
    };

    GItem &operator =(GItem &i)
    {
        if (i._Fore.Get())
            _Fore.Reset(new GViewFill(*i._Fore));
        else
            _Fore.Reset();

        if (i._Back.Get())
            _Back.Reset(new GViewFill(*i._Back));
        else
            _Back.Reset();

        return *this;
    }

    // Events
    
    virtual void OnSelect() {}
    virtual void OnMouseClick(GMouse &m) {}
    virtual void OnPaint(ItemPaintCtx &Ctx) = 0;
    virtual bool OnBeginDrag(GMouse &m) { return false; }
    virtual void OnMeasure(GMeasureInfo *Info) {}
    virtual void OnInsert() {}
    virtual void OnRemove() {}

    // Methods

    virtual void Update() {}
    virtual void ScrollTo() {}
    virtual GView *EditLabel(int Col = -1) { return 0; }
    virtual void OnEditLabelEnd() {}

    // Data

    virtual bool Select() { return false; }
    virtual void Select(bool b) {}
    virtual char *GetText(int Col=0) { return 0; }
    virtual bool SetText(char *s, int Col=0) { return false; }
    virtual int GetImage(int Flags = 0) { return -1; }
    virtual void SetImage(int Col) {}
    virtual GRect *GetPos(int Col = -1) { return 0; }
    virtual GFont *GetFont() { return 0; }
    virtual GViewFill *GetForegroundFill() { return _Fore; }
    virtual void SetForegroundFill(GViewFill *Fill) { _Fore.Reset(Fill); }
    virtual GViewFill *GetBackgroundFill() { return _Back; }
    virtual void SetBackgroundFill(GViewFill *Fill) { _Back.Reset(Fill); }
    
    virtual bool XmlIo(class GXmlTag *Tag, bool Write) { return false; }

    bool OnScriptEvent(GViewI *Ctrl) { return false; }
    int OnEvent(GMessage *Msg) { return 0; }
    void OnMouseEnter(GMouse &m) {}
    void OnMouseExit(GMouse &m) {}
    void OnMouseMove(GMouse &m) {}
    void OnMouseWheel(double Lines) {}
    bool OnKey(GKey &k) { return false; }
    void OnAttach() {}
    void OnCreate() {}
    void OnDestroy() {}
    void OnFocus(bool f) {}
    void OnPulse() {}
    void OnPosChange() {}
    bool OnRequestClose(bool OsShuttingDown) { return false; }
    int OnHitTest(int x, int y) { return 0; }
    void OnChildrenChanged(GViewI *Wnd, bool Attaching) {}
    int OnNotify(GViewI *Ctrl, int Flags) { return 0; }
    int OnCommand(int Cmd, int Event, OsView Wnd) { return 0; }
    void OnPaint(GSurface *pDC) { LgiAssert(0); }
};

class GItemEdit : public GPopup
{
    class GItemEditPrivate *d;

public:
    GItemEdit(GView *parent, GItem *item, int index, int selstart, int selend);
    ~GItemEdit();
    
    void OnPaint(GSurface *pDC);
    int OnNotify(GViewI *v, int f);
    void Visible(bool i);
    int OnEvent(GMessage *Msg);
};

#define GLI_MARK_NONE               0
#define GLI_MARK_UP_ARROW           1
#define GLI_MARK_DOWN_ARROW         2

class LgiClass GListColumn
    : public ResObject
{
    class GListColumnPrivate *d;
    friend class GDragColumn;
    friend class GListItem;
    friend class GList;

public:
    GListColumn(GList *parent, char *name, int width);
    virtual ~GListColumn();

    // properties
    
    void Name(char *n);
    char *Name();
    void Width(int i);
    int Width();
    void Type(int i);
    int Type();
    void Mark(int i);
    int Mark();
    void Icon(GSurface *i, bool Own = true);
    GSurface *Icon();
    int Value();
    
    void Image(int i);
    int Image();
    bool Resizable();
    void Resizable(bool i);

    int GetIndex();
    int GetContentSize();
    GList *GetList();

    void OnPaint(GSurface *pDC, GRect &r);

    void OnPaint_Content(GSurface *pDC, GRect &r, bool FillBackground); 
};

class LgiClass GListItemPainter
{
public:
    // Overridable
    virtual void OnPaintColumn(GItem::ItemPaintCtx &Ctx, int i, GListColumn *c) = 0;
};

class LgiClass GListItemColumn : public GBase, public GItem, public GListItemPainter
{
    GListItem *_Item;
    int _Column;
    int _Value;

    void OnPaint(ItemPaintCtx &Ctx) {}

protected:
    List<GListItem> *GetAllItems();
    GListItemColumn *GetItemCol(GListItem *i, int Col);

public:
    GListItemColumn(GListItem *item, int col);

    // Other objects
    GListItem *GetItem() { return _Item; }
    GList *GetList();

    // Props
    int GetColumn() { return _Column; }
    void SetColumn(int i) { _Column = i; }
    virtual int64 Value() { return _Value; }
    virtual void Value(int64 i);
};

class LgiClass GListItem : public GItem, public GListItemPainter
{
    friend class GList;
    friend class GListItemColumn;
    friend class GListColumn;

    void OnEditLabelEnd();

protected:
    // Data
    class GListItemPrivate *d;
    GRect Pos;
    GList *Parent;

    // Methods
    bool GridLines();
    GDisplayString *GetDs(int Col, int FitTo = -1);

public:
    // Application defined, defaults to 0
    void *_UserData;

    // Object
    GListItem();
    virtual ~GListItem();

    GList *GetList() { return Parent; }
    List<GListItemColumn> *GetItemCols();

    // Properties
    
    bool SetText(char *s, int i=0);

    char *GetText
    (
        int i
    );

    int GetImage(int Flags = 0);
    void SetImage(int i);
    bool Select();
    void Select(bool b);
    GRect *GetPos(int Col = -1);
    bool OnScreen() { return Pos.y1 < Pos.y2; }

    // Methods
    
    void Update();
    void ScrollTo();
    void SetEditLabelSelection(int SelStart, int SelEnd); // call before 'EditLabel'
    GView *EditLabel(int Col = -1);
    
    // Events;
    void OnMouseClick(GMouse &m);
    void OnMeasure(GMeasureInfo *Info);
    void OnPaint(GSurface *pDC) { LgiAssert(0); }
    void OnPaint(GItem::ItemPaintCtx &Ctx);
    void OnPaintColumn(GItem::ItemPaintCtx &Ctx, int i, GListColumn *c);

    // Overridable
    virtual int Compare(GListItem *To, int Field) { return 0; }
    virtual void OnColumnNotify(int Col, int Data) {}
};

typedef int (*GListCompareFunc)(GListItem *a, GListItem *b, int Data);

class GListItems
{
protected:
    List<GListItem> Items;

public:
    template<class T>
    bool GetSelection(List<T> &n)
    {
        n.Empty();
        List<GListItem>::I It = Items.Start();
        for (GListItem *i=*It; i; i=*++It)
        {
            if (i->Select())
                n.Insert(dynamic_cast<T*>(i));
        }
        return n.Length() > 0;
    }

    template<class T>
    bool GetAll(List<T> &n)
    {
        n.Empty();
        List<GListItem>::I It = Items.Start();
        for (GListItem *i=*It; i; i=*++It)
        {
            n.Insert(dynamic_cast<T*>(i));
        }
        return n.Length() > 0;
    }

    List<GListItem>::I Start()
    {
        return Items.Start();
    }

    List<GListItem>::I End()
    {
        return Items.End();
    }
};

class LgiClass GList :
    public GLayout,
    public GItemContainer,
    public ResObject,
    public GListItems
{
    friend class GListItem;
    friend class GListColumn;
    friend class GListItemColumn;

    #ifdef WIN32
    HCURSOR Cursor;
    #endif
    
protected:
    class GListPrivate *d;

    // Contents
    List<GListColumn> Columns;
    int Keyboard; // index of the item with keyboard focus

    // Flags
    bool ColumnHeaders;
    bool EditLabels;
    bool GridLines;
    bool MultiItemSelect;

    // Double buffered
    GSurface *Buf;

    // Drawing locations
    GRect ItemsPos;
    GRect ColumnHeader;
    GRect ScrollX, ScrollY;
    int FirstVisible;
    int LastVisible;
    int CompletelyVisible;
    GListColumn *IconCol;

    // Misc
    bool GetUpdateRegion(GListItem *i, GRegion &r);
    GListItem *HitItem(int x, int y, int *Index = 0);
    GRect &GetClientRect();
    void Pour();
    void UpdateScrollBars();
    void KeyScroll(int iTo, int iFrom, bool SelectItems);
    int HitColumn(int x, int y, GListColumn *&Resize, GListColumn *&Over);

public:
    GList
    (
        int id,
        int x,
        int y,
        int cx,
        int cy,
        char *name = "List"
    );
    ~GList();

    char *GetClass() { return "GList"; }

    // Overridables
    
    virtual void OnItemClick
    (
        GListItem *Item,
        GMouse &m
    );
    virtual void OnItemBeginDrag
    (
        GListItem *Item,
        GMouse &m
    );
    virtual void OnItemSelect
    (
        GArray<GListItem*> &Items
    );
    virtual void OnColumnClick
    (
        int Col,
        GMouse &m
    );
    virtual void OnColumnDrag
    (
        int Col,
        GMouse &m
    ) {}
    virtual bool OnColumnReindex
    (
        GListColumn *Col,
        int OldIndex,
        int NewIndex
    )
    {
        return false;
    }
    
    // Events
    
    void OnPaint(GSurface *pDC);
    int OnEvent(GMessage *Msg);
    int OnHitTest(int x, int y);
    void OnMouseClick(GMouse &m);
    void OnMouseMove(GMouse &m);
    int OnNotify(GViewI *Ctrl, int Flags);
    void OnPosChange();
    bool OnKey(GKey &k);
    void OnMouseWheel(double Lines);
    void OnFocus(bool b);
    void OnPulse();

    // Columns
    
    GListColumn *AddColumn
    (
        char *Name,
        int Width = 50,
        int Where = -1
    );
    bool AddColumn
    (
        GListColumn *Col,
        int Where = -1
    );
    bool DeleteColumn(GListColumn *Col);
    void EmptyColumns();
    GListColumn *ColumnAt(int Index) { return Columns.ItemAt(Index); }
    int ColumnAtX(int X, GListColumn **Col = 0, int *Offset = 0);
    int GetColumns() { return Columns.Length(); }
    void DragColumn(int Index);
    bool GetColumnClickInfo(int &Col, GMouse &m);

    // Properties
    
    bool ShowColumnHeader() { return ColumnHeaders; }
    void ShowColumnHeader(bool Show) { ColumnHeaders = Show; }
    bool AllowEditLabels() { return EditLabels; }
    void AllowEditLabels(bool b) { EditLabels = b; }
    bool DrawGridLines() { return GridLines; }
    void DrawGridLines(bool b) { GridLines = b; }
    bool MultiSelect() { return MultiItemSelect; }
    void MultiSelect(bool b) { MultiItemSelect = b; }

    // Methods
    
    GListMode GetMode();
    void SetMode(GListMode m);  

    int64 Value();
    void Value(int64 i);
    bool Select(GListItem *Obj);
    GListItem *GetSelected();
    void SelectAll();
    void ScrollToSelection();
    void UpdateAllItems();
    int Length() { return Items.Length(); }

    bool IsEmpty() { return Items.Length() == 0; }
    bool Delete();
    bool Delete(int Index);
    bool Delete(GListItem *p);
    bool Insert
    (
        GListItem *p,
        int Index = -1,
        bool Update = true
    );
    bool Insert
    (
        List<GListItem> &l,
        int Index = -1,
        bool Update = true
    );
    bool Remove(GListItem *Obj);
    bool HasItem(GListItem *Obj);
    int IndexOf(GListItem *Obj);
    GListItem *ItemAt(int Index);
    void Sort
    (
        GListCompareFunc Compare,
        int Data
    );

    void Empty();
    void RemoveAll();
    void ResizeColumnsToContent(int Border = DEFAULT_COLUMN_SPACING);
};

#endif

---