mirror of
https://github.com/ultimatepp/ultimatepp.git
synced 2026-05-15 22:02:49 -06:00
332 lines
9.9 KiB
C++
332 lines
9.9 KiB
C++
#ifndef _GridCtrl_GridBase_h_
|
|
#define _GridCtrl_GridBase_h_
|
|
#include "GridDisplay.h"
|
|
|
|
class GridCtrl;
|
|
class GridHeader;
|
|
class ItemRect;
|
|
|
|
inline static bool IsSet(int s, int b)
|
|
{
|
|
return s & b;
|
|
}
|
|
|
|
inline static void BitSet(dword &k, dword v, bool s)
|
|
{
|
|
if(s) k |= v; else k &= ~v;
|
|
}
|
|
|
|
inline static bool BitInverse(dword &k, dword v)
|
|
{
|
|
bool s = k & v;
|
|
BitSet(k, v, !s);
|
|
return s;
|
|
}
|
|
|
|
struct Edit : Moveable<Edit>
|
|
{
|
|
Ptr<Ctrl> ctrl;
|
|
Convert * convert;
|
|
Callback1<One<Ctrl>&> factory;
|
|
|
|
Edit()
|
|
{
|
|
ctrl = NULL;
|
|
convert = NULL;
|
|
}
|
|
};
|
|
|
|
/*--------------------------------------------------------------------------------*/
|
|
struct Item : Moveable<Item>
|
|
{
|
|
friend class ItemRect;
|
|
friend class GridCtrl;
|
|
|
|
Item()
|
|
{
|
|
ctrl = NULL;
|
|
convert = NULL;
|
|
display = NULL;
|
|
|
|
fs = fe = 0;
|
|
style = 0;
|
|
editable = true;
|
|
clickable = true;
|
|
idx = 0;
|
|
idy = 0;
|
|
cx = 0;
|
|
cy = 0;
|
|
group = -1;
|
|
isjoined = false;
|
|
sync_flag = -1;
|
|
paint_flag = -1;
|
|
}
|
|
~Item()
|
|
{
|
|
delete ctrl;
|
|
}
|
|
|
|
private:
|
|
|
|
bool InvertSelect() { return BitInverse(style, GD::SELECT); }
|
|
bool IsSelect() { return style & GD::SELECT; }
|
|
bool IsLive() { return style & GD::LIVE; }
|
|
bool IsCursor() { return style & GD::CURSOR; }
|
|
bool IsFound() { return style & GD::FOUND; }
|
|
|
|
void Select(bool s) { BitSet(style, GD::SELECT, s); }
|
|
void Cursor(bool s) { BitSet(style, GD::CURSOR, s); }
|
|
void Live(bool s) { BitSet(style, GD::LIVE, s); }
|
|
void Found(bool s) { BitSet(style, GD::FOUND, s); }
|
|
|
|
bool IsJoined() { return isjoined; }
|
|
|
|
int idx, idy, cx, cy, group;
|
|
bool isjoined:1;
|
|
int fs, fe;
|
|
dword style;
|
|
bool editable:1;
|
|
bool clickable:1;
|
|
|
|
int sync_flag;
|
|
int paint_flag;
|
|
|
|
Ptr<Ctrl> ctrl;
|
|
|
|
Convert *convert;
|
|
GridDisplay *display;
|
|
|
|
void SetCtrl(Ctrl * newCtrl);
|
|
void DropCtrl();
|
|
|
|
public:
|
|
Value val;
|
|
|
|
Item& Editable(bool b) { editable = b; return *this; }
|
|
Item& NoEditable() { editable = false; return *this; }
|
|
|
|
Item& Clickable(bool b) { clickable = b; return *this; }
|
|
Item& NoClickable() { clickable = false; return *this; }
|
|
|
|
};
|
|
|
|
typedef Vector< Vector<Item> > Items;
|
|
typedef Vector< Edit > Edits;
|
|
/*--------------------------------------------------------------------------------*/
|
|
|
|
class ItemRect : public Moveable<ItemRect>
|
|
{
|
|
friend class GridCtrl;
|
|
|
|
public:
|
|
ItemRect()
|
|
{
|
|
min = 5; max = 1000000;
|
|
pos = npos = 0;
|
|
id = uid = n = 0;
|
|
prop = 1;
|
|
size = nsize = 0;
|
|
tsize = tnsize = 0;
|
|
sortmode = 0;
|
|
hidden = false;
|
|
index = false;
|
|
convertion = true;
|
|
editable = true;
|
|
sortable = true;
|
|
clickable = true;
|
|
style = 0;
|
|
|
|
calign = 0;
|
|
sl = sr = st = sb = 0;
|
|
sx = sy = 0;
|
|
join = 0;
|
|
|
|
ismin = false;
|
|
ismax = false;
|
|
|
|
fnt = StdFont();
|
|
align = GD::LEFT | GD::VCENTER;
|
|
wrap = false;
|
|
fg = Null;
|
|
bg = Null;
|
|
|
|
ctrl = NULL;
|
|
convert = NULL;
|
|
display = NULL;
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
Items *items;
|
|
Ctrl *parent;
|
|
Edits *edits;
|
|
|
|
Ptr<Ctrl> ctrl;
|
|
Convert *convert;
|
|
GridDisplay *display;
|
|
|
|
Callback1<One<Ctrl>&> factory;
|
|
|
|
// GridDisplay *display;
|
|
|
|
static VectorMap<Id, int> *aliases;
|
|
|
|
double pos, size, prop;
|
|
int npos, nsize;
|
|
int min, max;
|
|
int id, uid, n;
|
|
int sl, sr, st, sb, sx, sy;
|
|
|
|
double tpos, tsize, tprop;
|
|
int tnpos, tnsize;
|
|
|
|
int join;
|
|
|
|
bool hidden;
|
|
bool index;
|
|
bool convertion;
|
|
bool editable;
|
|
bool sortable;
|
|
bool clickable;
|
|
|
|
Value defval;
|
|
|
|
dword style;
|
|
|
|
bool ismin;
|
|
bool ismax;
|
|
|
|
/* operatory typu friend moga odwolywac sie tylko do zmiennych statycznych klasy */
|
|
|
|
static int sortCol;
|
|
static int sortMode;
|
|
|
|
int sortcol;
|
|
int sortmode;
|
|
|
|
int align, calign;
|
|
bool wrap;
|
|
Font fnt;
|
|
Color fg, bg;
|
|
|
|
double Left(int scroll = 0) { return pos - scroll; }
|
|
double Right(int scroll = 0) { return pos + size - scroll; }
|
|
double Top(int scroll = 0) { return pos - scroll; }
|
|
double Bottom(int scroll = 0) { return pos + size - scroll; }
|
|
double Width() { return size; }
|
|
double Height() { return size; }
|
|
|
|
bool InvertSelect() { return BitInverse(style, GD::SELECT); }
|
|
bool IsSelect() { return style & GD::SELECT; }
|
|
bool IsLive() { return style & GD::LIVE; }
|
|
bool IsCursor() { return style & GD::CURSOR; }
|
|
bool IsHighlight() { return style & GD::HIGHLIGHT; }
|
|
|
|
void Select(bool s) { BitSet(style, GD::SELECT, s); }
|
|
void Cursor(bool s) { BitSet(style, GD::CURSOR, s); }
|
|
void Live(bool s) { BitSet(style, GD::LIVE, s); }
|
|
void Highlight(bool s) { BitSet(style, GD::HIGHLIGHT, s); }
|
|
|
|
int nLeft(int scroll = 0) { return npos - scroll; }
|
|
int nRight(int scroll = 0) { return npos + nsize - scroll; }
|
|
int nTop(int scroll = 0) { return npos - scroll; }
|
|
int nBottom(int scroll = 0) { return npos + nsize - scroll; }
|
|
int nWidth() { return nsize; }
|
|
int nHeight() { return nsize; }
|
|
|
|
ItemRect& Size(int n);
|
|
|
|
bool IsMin() { return ismin; }
|
|
bool IsMax() { return ismax; }
|
|
|
|
void ChangeSortMode(bool idsort = true);
|
|
|
|
friend bool operator<(const ItemRect& a, const ItemRect& b)
|
|
{
|
|
if(sortMode)
|
|
return (StdValueCompare((*a.items)[a.id][sortCol].val, (*b.items)[b.id][sortCol].val, 0) < 0);
|
|
else
|
|
return a.id < b.id;
|
|
}
|
|
friend bool operator>(const ItemRect& a, const ItemRect& b)
|
|
{
|
|
if(sortMode)
|
|
return (StdValueCompare((*a.items)[a.id][sortCol].val, (*b.items)[b.id][sortCol].val, 0) > 0);
|
|
else
|
|
return a.id > b.id;
|
|
}
|
|
public:
|
|
|
|
ItemRect& Alias(Id id);
|
|
ItemRect& Alias(const char * s);
|
|
ItemRect& Name(String &s);
|
|
ItemRect& Name(const char * s);
|
|
ItemRect& Width(int n);
|
|
ItemRect& Height(int n);
|
|
ItemRect& Min(int n);
|
|
ItemRect& Max(int n);
|
|
ItemRect& Fixed(int n);
|
|
ItemRect& Edit(Ctrl &newCtrl);
|
|
ItemRect& SetConvert(Convert &c);
|
|
ItemRect& SetFormat(const char *fmt);
|
|
ItemRect& SetDisplay(GridDisplay &gd);
|
|
ItemRect& NoConvertion();
|
|
ItemRect& Default(Value v);
|
|
|
|
ItemRect& AlignTop() { align = GD::TOP; return *this; }
|
|
ItemRect& AlignBottom() { align = GD::BOTTOM; return *this; }
|
|
ItemRect& AlignLeft() { align = GD::LEFT; return *this; }
|
|
ItemRect& AlignRight() { align = GD::RIGHT; return *this; }
|
|
ItemRect& AlignHorzCenter() { align = GD::HCENTER; return *this; }
|
|
ItemRect& AlignVertCenter() { align = GD::VCENTER; return *this; }
|
|
ItemRect& AlignCenter() { align = GD::HCENTER | GD::VCENTER; return *this; }
|
|
ItemRect& AlignTopLeft() { align = GD::LEFT | GD::TOP; return *this; }
|
|
ItemRect& AlignTopRight() { align = GD::RIGHT | GD::TOP; return *this; }
|
|
ItemRect& AlignTopCenter() { align = GD::HCENTER | GD::TOP; return *this; }
|
|
ItemRect& AlignBottomLeft() { align = GD::LEFT | GD::BOTTOM; return *this; }
|
|
ItemRect& AlignBottomRight() { align = GD::RIGHT | GD::BOTTOM; return *this; }
|
|
ItemRect& AlignBottomCenter() { align = GD::HCENTER | GD::BOTTOM; return *this; }
|
|
|
|
|
|
ItemRect& CtrlAlignTop(int t = 0, int s = 0) { calign |= GD::TOP; st = t; sy = s; return *this; }
|
|
ItemRect& CtrlAlignBottom(int b = 0, int s = 0) { calign |= GD::BOTTOM; sb = b; sy = s; return *this; }
|
|
ItemRect& CtrlAlignLeft(int l = 0, int s = 0) { calign |= GD::LEFT; sl = l; sx = s; return *this; }
|
|
ItemRect& CtrlAlignRight(int r = 0, int s = 0) { calign |= GD::RIGHT; sr = r; sx = s; return *this; }
|
|
ItemRect& CtrlAlignHorzCenter(int s = 0) { calign |= GD::HCENTER; sx = s; return *this; }
|
|
ItemRect& CtrlAlignVertCenter(int s = 0) { calign |= GD::VCENTER; sy = s; return *this; }
|
|
ItemRect& CtrlAlignHorzPos(int l = 0, int r = 0) { calign |= GD::HPOS; sl = l; sr = r; sx = 1; return *this; }
|
|
ItemRect& CtrlAlignVertPos(int t = 0, int b = 0) { calign |= GD::VPOS; st = t; sb = b; sy = 1; return *this; }
|
|
|
|
ItemRect& WrapText() { wrap = true; return *this; }
|
|
|
|
ItemRect& SetFont(Font &f) { fnt = f; return *this; }
|
|
ItemRect& Bg(Color c) { bg = c; return *this; }
|
|
ItemRect& Fg(Color c) { fg = c; return *this; }
|
|
|
|
ItemRect& Ctrls(Callback1<One<Ctrl>&> _factory) { (*edits)[id].factory = _factory; return *this; }
|
|
ItemRect& Ctrls(void (*factory)(One<Ctrl>&)) { return Ctrls(callback(factory)); }
|
|
template<class T> ItemRect& Ctrls() { return Ctrls(DefaultCtrlFactory<T>()); }
|
|
ItemRect& Option();
|
|
|
|
ItemRect& Editable(bool b) { editable = b; return *this; }
|
|
ItemRect& NoEditable() { editable = false; return *this; }
|
|
|
|
ItemRect& Sortable(bool b) { sortable = b; return *this; }
|
|
ItemRect& NoSortable() { sortable = false; return *this; }
|
|
|
|
ItemRect& Clickable(bool b) { clickable = b; return *this; }
|
|
ItemRect& NoClickable() { clickable = false; return *this; }
|
|
|
|
bool IsConvertion() { return convertion; }
|
|
|
|
void Serialize(Stream &s);
|
|
void Clear();
|
|
};
|
|
|
|
typedef Vector<ItemRect> RectItems;
|
|
typedef Vector<ItemRect> VItems;
|
|
typedef Vector<ItemRect> HItems;
|
|
/*--------------------------------------------------------------------------------*/
|
|
|
|
#endif
|