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_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
{
public:
    // Events
    
    virtual void OnSelect() {}
    virtual void OnMouseClick(GMouse &m) {}
    virtual void OnPaint(GSurface *pDC, GRect &r) {}
    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; }

    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) {}
    void OnPaint(GSurface *pDC) {}
    int OnNotify(GViewI *Ctrl, int Flags) { return 0; }
    int OnCommand(int Cmd, int Event, OsView Wnd) { return 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(GSurface *pDC, GRect &r, int i, GListColumn *c) {}
};

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

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 int Value() { return _Value; }
    virtual void Value(int 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;
    COLOUR Fore;
    COLOUR Back;

    // 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, GRect &r);
    void OnPaintColumn(GSurface *pDC, GRect &r, 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 LgiClass GList :
    public GLayout,
    public GItemContainer,
    public ResObject
{
    friend class GListItem;
    friend class GListColumn;
    friend class GListItemColumn;
    COLOUR _Selection;

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

    // Contents
    List<GListColumn> Columns;
    List<GListItem> Items;
    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();

    // Overridables
    
    virtual void OnItemClick
    (
        GListItem *Item,
        GMouse &m
    );
    virtual void OnItemBeginDrag
    (
        GListItem *Item,
        GMouse &m
    );
    virtual void OnItemSelect
    (
        GListItem *Item
    );
    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);  

    int Value();
    void Value(int i);
    bool Select(GListItem *Obj);
    GListItem *GetSelection();
    bool GetSelection(List<GListItem> &l);
    void SelectAll();
    bool GetAll(List<GListItem> &l);
    void ScrollToSelection();
    void UpdateAllItems();

    // List
    
    GListItem *First() { return Items.First(); }
    GListItem *Last() { return Items.Last(); }
    GListItem *Next() { return Items.Next(); }
    GListItem *Prev() { return Items.Prev(); }
    GListItem *Current() { return Items.Current(); }
    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

---