U++

#define LLOG(x) // LOG(x)

	Refresh();

}

	Refresh();

}

	WhenAction();

}

	RefreshFocus();

}

	if(keypush) EndPush();

	RefreshFocus();

}

	if(Ctrl::ClickFocus() || clickfocus) SetWantFocus();

	if(IsReadOnly()) return;

	push = true;

	SetCapture();

}

	LLOG("Mouse move !");

	if(IsReadOnly() || !HasCapture()) return;

	bool b = GetScreenView().Contains(GetMousePos());

	}

}

	EndPush();

}

	if(IsReadOnly()) return;

	WhenRepeat();

}

	FinishPush();

}

	return AccessKeyBit(accesskey);

}

{

	if(!accesskey) {

		accesskey = ChooseAccessKey(label, used);

	Ctrl::AssignAccessKeys(used);

}

{

	if(keypush && GetTopCtrl() && !GetTopCtrl()->HasFocusDeep())

		EndPush();

}

	if(IsReadOnly()) return;

	if(keypush) {

		WhenRepeat();

	return true;

}

	if(IsReadOnly()) return false;

	if(key == K_SPACE) {

		KeyPush();

	return false;

}

	if(CompareAccessKey(accesskey, key)) {

		PseudoPush();

		return true;

	return false;

}

	if(IsReadOnly() || !IsEnabled()) return;

	KeyPush();

	Sync();

	FinishPush();

}

	if(push || keypush)

		RefreshPush();

	keypush = push = false;

}

	font = fnt;

	Refresh();

	return *this;

	return label;

}

	accesskey = ExtractAccessKey(atext, label);

	Refresh();

	return *this;

}

	EndPush();

}

	       CTRL_NORMAL;

}

	keypush = push = clickfocus = false;

	accesskey = 0;

	font = StdFont();

	Pusher::MouseLeave();

}

	if(Pusher::Key(key, w)) return true;

	if(key == K_ENTER) {

		KeyPush();

	return false;

}

	if(Pusher::HotKey(key)) return true;

	if(CompareAccessKey(accesskey, key)) {

		PseudoPush();

	return *this;

}

	style = NULL;

	type = NORMAL;

	monoimg = false;

	return *this;

}

	visible = true;

	onsides = false;

	inc.NoWantFocus();

	Pusher::MouseLeave();

}

	Refresh();

}

	if(showlabel)

		Refresh(0, 0, CtrlsImg::O0().GetSize().cx, GetSize().cy);

	else

		Pusher::RefreshPush();

}

	Size isz = CtrlsImg::O0().GetSize();

	return AddFrameSize(isz.cx + (GetSmartTextSize(label).cx + 4) * showlabel,

		                max(isz.cy, StdFont().Info().GetHeight()) + 2);

}

	Size sz = GetSize();

	if(!IsTransparent())

	}

}

	Set(IsString(data) ? String(data) == "1" ? 1

	                                         : IsNull(data) ? (notnull ? 0 : int(Null)) : 0

	                   : notnull ? Nvl((int)data, 0) : (int)data);

}

	return (int) option;

}

	if(option == 0)

		option = threestate ? Null : 1;

	else

	return *this;

}

	option = 0;

	notnull = true;

	switchimage = threestate = false;

	Transparent();

}

	int version = 0;

	s / version;

	bool b = Get();

		Refresh();

}

	Size sz = GetSize();

	bool ds = !IsShowEnabled();

	DrawLabel dl;

	drawfocus = false;

}

	if(IsReadOnly())

		return;

	push = true;

	Refresh();

}

	if(IsReadOnly())

		return;

	option = !option;

	UpdateActionRefresh();

}

	if(IsReadOnly())

		return;

	bool p = !!(flags & K_MOUSELEFT);

	}

}

	Refresh();

}

	if(IsReadOnly())

		return;

	if(push)

	Ctrl::AssignAccessKeys(used);

}

	accesskey = ExtractAccessKey(text, label);

	Refresh();

	return *this;

public:

	virtual void   CancelMode();

	virtual void   LeftDown(Point, dword);

	virtual void   MouseMove(Point, dword);

	virtual void   MouseLeave();

	virtual void   LeftRepeat(Point, dword);

	Callback WhenPush;

	Callback WhenRepeat;

	Pusher();

	virtual ~Pusher();

	thumbmin = 16;

	overthumb = 0;

	through = false;

	CtrlsImageLook(vupper, CtrlsImg::I_SBVU);

	CtrlsImageLook(vthumb, CtrlsImg::I_SBVT, CtrlsImg::SBVI());

	CtrlsImageLook(vlower, CtrlsImg::I_SBVL);

	isup2 = isdown2 = isleft2 = isright2 = false;

}

	minthumb = 16;

	pagepos = pagesize = totalsize = 0;

	linesize = 1;

	Add(next);

	Add(next2);

	NoWantFocus();

	prev.ScrollStyle().NoWantFocus().Transparent();

	prev.WhenPush << Proxy(WhenLeftClick);

	prev2.ScrollStyle().NoWantFocus().Transparent();

	prev2.WhenRepeat = prev.WhenRepeat;

	prev2.WhenPush = prev.WhenPush;

	next.ScrollStyle().NoWantFocus().Transparent();

	next.WhenPush << Proxy(WhenLeftClick);

	next2.ScrollStyle().NoWantFocus().Transparent();

	next2.WhenRepeat = next.WhenRepeat;

	next2.WhenPush = next.WhenPush;

	style = NULL;

	SetStyle(StyleDefault());

	BackPaint();

	return IsHorz() ? h : v;

}

	return IsHorz() ? h : v;

}

	Rect h = Slider();

	int sbo = style->overthumb;

	int off = GetHV(h.left, h.top);

	return h;

}

	w.DrawRect(GetSize(), SColorPaper());

	int cc;

	Size sz = style->through ? GetSize() : Slider(cc).GetSize();

}

{

	int q = -1;

	for(int i = 2; i >= 0; i--)

	return q;

}

	Size sz = Slider().GetSize();

	return GetHV(sz.cx, sz.cy);

}

	int maxsize = GetRange();

	if(thumbsize > maxsize)

		thumbsize = maxsize;

		thumbpos = 0;

}

	int ts = thumbsize;

	int tp = thumbpos;

	thumbsize = _thumbsize;

	return false;

}

	if(SetThumb(max(0, IsHorz() ? p.x - delta : p.y - delta), thumbsize) && track)

		Position();

}

	push = GetMousePart();

	LLOG("ScrollBar::LeftDown(" << p << ")");

	LLOG("MousePos = " << GetMousePos() << ", ScreenView = " << GetScreenView()

	WhenLeftClick();

}

	if(HasCapture() && push == 2)

		Drag(p);

	else

	Refresh();

}

	ReleaseCapture();

	if(!track)

		Position();

	push = -1;

}

	if(jump || push < 0 || push == 2) return;

	if(push == 0)

		PrevPage();

	Wheel(zdelta);

}

	push = light = -1;

}

	return false;

}

	pagesize = _pagesize;

	totalsize = _totalsize;

	is_active = totalsize > pagesize && pagesize > 0;

	Set(_pagepos);

}

	Set(pagepos, _pagesize, totalsize);

}

	Set(pagepos, pagesize, _totalsize);

}

	int slsize = GetRange();

	int mint = max(minthumb, style->thumbmin);

	if(slsize < mint || totalsize <= pagesize)

	WhenScroll();

}

	if(Set(a))

		Action();

}

	Uset(pagepos - linesize);

}

	Uset(pagepos + linesize);

}

	Uset(pagepos - max(pagesize - linesize, 1));

}

	Uset(pagepos + max(pagesize - linesize, 1));

}

	Uset(pagepos - lines * linesize * zdelta / 120);

}

	if(!IsVisible() || !IsEnabled() || GetRect().IsEmpty())

		return false;

	switch(key) {

	Uset(max(0, totalsize - pagesize));

}

	if(!IsVisible() || !IsEnabled() || GetRect().IsEmpty())

		return false;

	switch(key) {

	return true;

}

	Size sz = GetSize();

	if(IsHorz()) {

		prev.SetStyle(style->left);

	Refresh();

}

	int new_pos = pagepos;

	if(pos > new_pos + pagesize - _linesize)

		new_pos = pos - pagesize + _linesize;

	return Set(new_pos);

}

	int a = HeaderCtrl::GetStdHeight();

	return Size(a, a);

}

	(IsHorz() ? sz.cy : sz.cx) += ScrollBarSize();

}

	if(IsChild() && InFrame()) {

		Size sz = GetParent()->GetSize();

		if(IsShown())

	return Size(0, 0);

}

	if(IsChild() && InFrame()) {

		Size sz = GetParent()->GetSize();

		if(!IsShown())

	return Size(0, 0);

}

	autohide = b;

	if(b)

		SetTotal(totalsize);

	return *this;

}

	autodisable = b;

	if(!b) {

		if(!prev.IsEnabled())

		GuiPlatformGripResize(q);

}

	WhenScroll();

}

	return x.HorzKey(key) || y.VertKey(key);

}

	x.Set(pos.x, page.cx, total.cx);

	y.Set(pos.y, page.cy, total.cy);

}

	bool b = x.Set(_x) | y.Set(_y);

	return b;

}

	return Set(pos.x, pos.y);

}

	x.SetPage(cx);

	y.SetPage(cy);

}

	SetPage(page.cx, page.cy);

}

	x.SetTotal(cx);

	y.SetTotal(cy);

}

	SetTotal(total.cx, total.cy);

}

	return x.ScrollInto(pos.x, linesize.cx) | y.ScrollInto(pos.y, linesize.cy);

}

	return x.ScrollInto(pos.x) | y.ScrollInto(pos.y);

}

	x.SetLine(linex);

	y.SetLine(liney);

	return *this;

}

	x.Track(b);

	y.Track(b);

	return *this;

}

	x.Jump(b);

	y.Jump(b);

	return *this;

}

	x.AutoHide(b);

	y.AutoHide(b);

	return *this;

}

	x.AutoDisable(b);

	y.AutoDisable(b);

	return *this;

}

	box->Remove();

	box = &_box;

	if(x.GetParent() && x.GetParent() != box->GetParent())

	return *this;

}

	p.Add(x);

	p.Add(y);

	if(box->GetParent() != &p)

		p.Add(*box);

}

	x.Remove();

	y.Remove();

	box->Remove();

}

	if(x.IsShown() && y.IsShown() && !box) {

		int h = ScrollBarSize();

		w.DrawRect(r.right - h, r.bottom - h, h, h, SColorFace);

	}

}

	int h = ScrollBarSize();

	int by = 0;

	int bx = x.IsShown() && y.IsShown() ? h : 0;

	r.bottom -= dx;

}

	int h = ScrollBarSize();

	sz.cy += x.IsShown() * h;

	sz.cx += y.IsShown() * h;

}

	return Size(y.GetViewSize().cx, x.GetViewSize().cy);

}

	return Size(y.GetReducedViewSize().cx, x.GetReducedViewSize().cy);

}

	return *this;

}

	box = &the_box;

//	the_box.NoTransparent();

	x.WhenScroll = y.WhenScroll = callback(this, &ScrollBars::Scroll);

class ScrollBar : public FrameCtrl<Ctrl> {

public:

	virtual void Layout();

	virtual Size GetStdSize() const;

	virtual void Paint(Draw& draw);

	virtual void LeftDown(Point p, dword);

	virtual void MouseMove(Point p, dword);

	virtual void MouseEnter(Point p, dword);

	virtual void MouseLeave();

	struct Style : ChStyle<Style> {

		int barsize, arrowsize, thumbmin, overthumb;

		bool through;

		Value vupper[4], vthumb[4], vlower[4];

		Value hupper[4], hthumb[4], hlower[4];

		Button::Style up, down, left, right;

	};

private:

	int     thumbpos;

	int     thumbsize;

	bool    horz:1;

	void    Position();

	void    Uset(int a);

	int     ScrollBarSize() const                 { return style->barsize; }

public:

	Callback WhenScroll;

	Callback WhenVisibility;