diff --git a/bazaar/CMeter/CMeter.cpp b/bazaar/CMeter/CMeter.cpp
new file mode 100644
index 000000000..b194a0187
--- /dev/null
+++ b/bazaar/CMeter/CMeter.cpp
@@ -0,0 +1,1029 @@
+#include "CMeter.h"
+
+CH_STYLE(CMeter, Style, StyleDefault)
+{
+	backcol = SColorFace();
+	textcol = SColorText();
+	forecol = LtBlue();
+	forecol2 = LtRed();
+	cmarksize = 3;
+}
+
+CMeter::CVMark::CVMark(float _v, String _name, Color _col)
+	:  v(_v)
+	, col(_col)
+	, name(_name)
+{
+}
+
+//CMeter
+
+CMeter::CMeter(float _min, float _max, bool _vertical, bool _reverse)
+	: min(_min)
+	, max(_max)
+	, val(min)
+	, inc(0.1f)
+
+	, vertical(_vertical)
+	, reverse(_reverse)
+	, stepping(false)
+	, steplin(false)
+	, showvalue(true)
+	, showpercent(false)
+	, clickincdec(true)
+	, incdectostep(false)
+	, drawmode(IMGCACHE)
+	, increment(0)
+	, incv(0.0f)
+	, inci(0)
+	, __val(min)
+	, __ii(-1)
+
+	, px(0)
+	, py(0)
+	, _px(0)
+	, _py(0)
+	
+{
+	Transparent();
+
+	vsteps.Add(max); //max needs to be there for sure
+	cvmarks.Add(CVMark(0.0f));
+
+	SetStyle(StyleDefault());
+
+	Set((max-min)/2.0f);		
+}
+
+CMeter& CMeter::SetStyle(const Style& s)
+{
+	style = &s;
+	RefreshLayout();
+	return *this;
+}
+
+int CMeter::FindStep(float v) const
+{
+	float _v = min;
+	
+	int i = vsteps.GetCount()-1;
+	while(i>=0)
+	{
+		if(vsteps[i] <= v)
+		{
+			_v = vsteps[i];
+			break;
+		}
+		--i;
+	}
+	return i;
+}
+
+CMeter & CMeter::Set(float _val)
+{
+	val = _val; //first try the desired value
+	
+	if(val < min)
+		val = min;
+	if(val > max)
+		val = max;
+
+	__val = val; //for cache
+
+	//determine the val
+	if(stepping)
+	{
+		int i = FindStep(val);
+		val = min;
+		pp = 0;
+		__ii = i; //needed for inc dec, NO oszillates
+		if(i>=0)
+		{
+			val = vsteps[i];
+			if(steplin)
+				pp = (float)(i+1)/(float)vsteps.GetCount();
+			else
+				pp = (val - min) / (max - min);
+		}
+	}
+	else
+	{
+		pp = (val - min) / (max - min);
+	}
+	
+	Update();
+
+	Refresh();	
+	return *this;
+}
+
+CMeter & CMeter::Min(float _min)
+{
+	min = _min;
+
+	if(val < min)
+		val = min;
+	
+	Update();
+
+	return *this;
+}
+
+CMeter & CMeter::Max(float _max)
+{
+	max = _max;
+
+	if(val > max)
+		val = max;
+
+	Update();
+
+	return *this;
+}
+
+CMeter & CMeter::MinMax(float _min, float _max)
+{
+	min = _min;
+	max = _max;
+
+	Update();
+
+	return *this;
+}
+
+CMeter & CMeter::Reverse(bool _reverse)
+{
+	reverse = _reverse;
+
+	CreateBack();
+
+	return *this;
+}
+
+CMeter & CMeter::Vertical(bool _vertical)
+{
+	vertical = _vertical;
+
+	Layout();
+
+	return *this;
+}
+
+CMeter & CMeter::Stepping(bool _stepping)
+{
+	stepping = _stepping;
+
+	Set(Get());
+
+	return *this;
+}
+
+CMeter & CMeter::StepLinear(bool _steplin)
+{
+	steplin = _steplin;
+
+	Set(Get());
+
+	return *this;
+}
+
+CMeter & CMeter::Steps(const Vector<float> & _vsteps, bool reverse)
+{
+	vsteps <<= _vsteps;
+	
+	if(vsteps.IsEmpty())
+		vsteps << max; //at least
+
+	if(!reverse)
+		return *this;
+	
+	int i = 0, j = vsteps.GetCount()-1;
+	while(i<j)
+		vsteps.Swap(i++, j--);
+
+	return *this;
+}
+
+CMeter & CMeter::ShowValue(bool _showvalue)
+{
+	showvalue = _showvalue;
+
+	return *this;
+}
+
+CMeter & CMeter::ShowPercent(bool _showpercent)
+{
+	showpercent = _showpercent;
+
+	Update();
+
+	return *this;
+}
+
+CMeter & CMeter::SetMode(int mode)
+{
+	drawmode = mode;
+	
+	return *this;
+}
+
+//updates all local cache info, depends on correct layout, uses already set val / min / max
+void CMeter::Update()
+{
+	if(showpercent)
+	{
+		(s = Format("%0n", (100.0f * pp))) << " %";
+		tlen = GetTextSize(s,StdFont(),s.GetLength());
+	}
+	else
+	{
+		s = Format("%1!n", val);
+		tlen = GetTextSize(s,StdFont(),s.GetLength());
+	}
+
+	Size size = GetSize();
+
+	//drawing will use waht it needs
+	dx = (int)(size.cx * pp);
+	lx = (int)(size.cx - dx);
+	dy = (int)(size.cy * pp);
+	ly = (int)(size.cy - dy);
+}
+
+void CMeter::Layout()
+{
+	Size size = GetSize();
+
+	if(cvmarks.GetCount()>0)
+	{
+		if(vertical)
+		{
+			py = 0; _px = 0;
+			px = style->cmarksize;
+			_py = px;
+		}
+		else
+		{
+			px = 0; _py = 0;
+			_px = style->cmarksize;
+			py = _px;
+		}
+	}
+	else
+	{
+		px = 0; py = 0;
+		_px = 0; _py = 0;	
+	}
+
+	Update();
+
+	CreateBack();
+}
+
+void CMeter::PaintBarGradient(Painter & sw, bool staticgradient)
+{
+	Size size = GetSize();
+
+	if(vertical)
+	{
+		if(!reverse)
+		{
+			sw.DrawRect(px,py,size.cx,ly, style->backcol);//.Fill(px,py, backcol, px+size.cx,py+ly,backcol);
+			sw.Rectangle(px,py+ly,size.cx,dy);
+			if(staticgradient)
+				sw.Fill(px,py   ,style->forecol2,px/*+size.cx*/,py+size.cy,style->forecol);
+			else
+				sw.Fill(px,py+ly,style->forecol2,px/*+size.cx*/,py+size.cy,style->forecol);
+		}
+		else
+		{
+			sw.DrawRect(px,py+dy,size.cx,ly,style->backcol);
+			sw.Rectangle(px,py,size.cx,dy);
+			if(staticgradient)
+				sw.Fill(px,py,style->forecol,px/*+size.cx*/,py+size.cy,style->forecol2);
+			else
+				sw.Fill(px,py,style->forecol,px/*+size.cx*/,py+dy,style->forecol2);
+		}
+	}
+	else //horizontal
+	{
+		if(!reverse)
+		{
+			sw.DrawRect(px+dx,py,lx,size.cy, style->backcol);//.Fill(px+dx,py,backcol,px+size.cx,py+size.cy,backcol);
+			sw.Rectangle(px,py,dx,size.cy);
+			if(staticgradient)
+				sw.Fill(px,py,style->forecol,px+size.cx,py/*+size.cy*/,style->forecol2);
+			else
+				sw.Fill(px,py,style->forecol,px+dx,py/*+size.cy*/,style->forecol2);
+		}
+		else
+		{
+			sw.DrawRect(px,py,lx,size.cy,style->backcol);
+			sw.Rectangle(px+lx,py,dx,size.cy);
+			if(staticgradient)
+				sw.Fill(px   ,py,style->forecol2,px+size.cx,py/*+size.cy*/,style->forecol);
+			else
+				sw.Fill(px+lx,py,style->forecol2,px+size.cx,py/*+size.cy*/,style->forecol);
+		}
+	}
+}
+
+void CMeter::PaintBarStatic(Painter & sw)
+{
+	Size size = GetSize();
+
+	if(vertical)
+	{
+		if(!reverse)
+		{
+			sw.DrawRect(px,py   ,size.cx,ly,style->backcol);
+			sw.DrawRect(px,py+ly,size.cx,dy,style->forecol);
+		}
+		else
+		{
+			sw.DrawRect(px,py+dy,size.cx,ly,style->backcol);
+			sw.DrawRect(px,py   ,size.cx,dy,style->forecol);
+		}
+	}
+	else //horizontal
+	{
+		if(!reverse)
+		{
+			sw.DrawRect(px+dx,py,lx,size.cy,style->backcol);
+			sw.DrawRect(px,py   ,dx,size.cy,style->forecol);
+		}
+		else
+		{
+			sw.DrawRect(px,py   ,lx,size.cy,style->backcol);
+			sw.DrawRect(px+lx,py,dx,size.cy,style->forecol);
+		}
+	}
+}
+
+void CMeter::CreateBack()
+{
+	Size size = GetSize();
+	ImageDraw ddraw(size); //create a background image that will be shown
+	//ddraw.DrawRect(0,0,size.cx,size.cy,LtGreen);
+
+	if(vertical)
+	{
+		if(!reverse)
+			for(int i = 0; i < size.cy; i++)
+			{
+				Color col = Blend(style->forecol2, style->forecol, (256 * i / size.cy));
+				ddraw.DrawLine(0,i,size.cx,i,1,((i%2)?(style->backcol):(col)));
+			}
+		else	
+			for(int i = 0; i < size.cy; i++)
+			{
+				Color col = Blend(style->forecol, style->forecol2, (256 * i / size.cy));
+				ddraw.DrawLine(0,i,size.cx,i,1,((i%2)?(style->backcol):(col)));
+			}
+	}
+	else
+	{
+		if(!reverse)
+			for(int i = 0; i < size.cx; i++)
+			{
+				Color col = Blend(style->forecol, style->forecol2, (256 * i / size.cx));
+				ddraw.DrawLine(i,0,i,size.cy,1,((i%2)?(style->backcol):(col)));
+			}
+		else	
+			for(int i = 0; i < size.cx; i++)
+			{
+				Color col = Blend(style->forecol2, style->forecol, (256 * i / size.cx));
+				ddraw.DrawLine(i,0,i,size.cy,1,((i%2)?(style->backcol):(col)));
+			}
+	}
+	
+	draw = ddraw; //make the image
+}
+
+void CMeter::PaintBarImage(Painter & sw)
+{
+	Size size = GetSize();
+
+	if(draw.GetSize() != size)
+		CreateBack();
+	
+	if(vertical)
+	{
+		if(!reverse)
+		{
+			sw.DrawRect(px,py   ,size.cx,ly,style->backcol);
+
+			//sw.DrawRect(px,py+ly,size.cx,dy,forecol);
+			Point p(px, py+ly);
+			Size s(size.cx, dy);
+			Rect r(p,s);
+			sw.ClipOp(r);
+			sw.DrawImage(0,0, draw);
+			sw.End();
+		}
+		else
+		{
+			sw.DrawRect(px,py+dy,size.cx,ly,style->backcol);
+
+			//sw.DrawRect(px,py   ,size.cx,dy,forecol);
+			Point p(px, py);
+			Size s(size.cx, dy);
+			Rect r(p,s);
+			sw.ClipOp(r);
+			sw.DrawImage(0,0, draw);
+			sw.End();
+		}
+	}
+	else //horizontal
+	{
+		if(!reverse)
+		{
+			sw.DrawRect(px+dx,py,lx,size.cy,style->backcol);
+
+			//sw.DrawRect(px,py   ,dx,size.cy,forecol);
+			Point p(px, py);
+			Size s(dx, size.cy);
+			Rect r(p,s);
+			sw.ClipOp(r);
+			sw.DrawImage(0,0, draw);
+			sw.End();
+		}
+		else
+		{
+			sw.DrawRect(px,py   ,lx,size.cy,style->backcol);
+
+			//sw.DrawRect(px+lx,py,dx,size.cy,forecol);
+			Point p(px+lx, py);
+			Size s(dx, size.cy);
+			Rect r(p,s);
+			sw.ClipOp(r);
+			sw.DrawImage(0,0, draw);
+			sw.End();
+		}
+	}
+}
+
+void CMeter::PaintCVMarks(Painter & sw)
+{
+	Size size = GetSize();
+
+	if(cvmarks.GetCount()>0)
+	{
+		Vector<Point> p;
+		if(vertical)
+		{
+			sw.DrawRect(0,0,px,size.cy,style->backcol);
+			for(int i = 0; i<cvmarks.GetCount(); i++)
+			{
+				CVMark & cm = cvmarks[i];
+				if(cm.v > max || cm.v < min) continue;
+				int pos;
+				if(stepping && steplin)
+				{
+					//pos = ValToPix((float)i);
+				}
+				else
+					pos = ValToPix(cm.v);
+				p.Clear(); p << Point(px, pos) << Point(0, pos-(_py>>1) ) << Point(0, pos-(_py>>1)+_py);
+				sw.DrawPolygon(p, cm.col);
+			}
+		}
+		else
+		{
+			sw.DrawRect(0,0,size.cx,py,style->backcol);
+			for(int i = 0; i<cvmarks.GetCount(); i++)
+			{
+				CVMark & cm = cvmarks[i];
+				if(cm.v > max || cm.v < min) continue;
+				int pos;
+				if(stepping && steplin)
+				{
+					//pos = ValToPix((float)i);
+				}
+				else
+					pos = ValToPix(cm.v);
+				p.Clear(); p << Point(pos, py) << Point(pos-(_px>>1), 0) << Point(pos-(_px>>1)+_px, 0);
+				sw.DrawPolygon(p, cm.col);
+			}
+		}
+		
+	}
+}
+
+void CMeter::PaintValue(Painter & sw)
+{
+	Size size = GetSize();
+
+	if(showpercent)
+	{
+		if(size.cx >= tlen.cx && size.cy >= tlen.cy) //only if fits into window
+		{
+			sw.DrawText(px+(size.cx>>1)-(tlen.cx>>1),py+(size.cy>>1)-(tlen.cy>>1),s, font, style->textcol);
+		}
+		else
+		{
+			sw.DrawText(2, py+(size.cy>>1)-(tlen.cy>>1),s, font, style->textcol);
+		}
+	}
+	else
+	{
+		if(size.cx >= tlen.cx && size.cy >= tlen.cy) //only if fits into window
+		{
+			sw.DrawText(px+(size.cx>>1)-(tlen.cx>>1),py+(size.cy>>1)-(tlen.cy>>1),s, font, style->textcol);
+		}
+		else
+		{
+			sw.DrawText(2, py+(size.cy>>1)-(tlen.cy>>1),s, font, style->textcol);
+		}
+	}
+}
+
+void CMeter::DoPaint0(Painter& sw)
+{
+	PaintCVMarks(sw);
+
+	switch(drawmode)
+	{
+		case IMGCACHE:
+			PaintBarImage(sw);
+			break;
+		case STATIC:
+			PaintBarStatic(sw);	
+			break;
+		case GRADIENT:
+			PaintBarGradient(sw, true);
+			break;
+		default:
+		case DYNGRADIENT:
+			PaintBarGradient(sw, false);
+			break;
+	}
+	
+	if(showvalue)
+		PaintValue(sw);
+}
+
+void CMeter::DoPaint(Painter& sw)
+{
+	//sw.Translate(~ctrl.translate_x, ~ctrl.translate_y);
+	//sw.Rotate(~ctrl.rotate);
+	//sw.Scale(~ctrl.scale, (double)~ctrl.scale * (double)~ctrl.scale_x);
+	//sw.Opacity(~ctrl.opacity);
+	//sw.LineCap(~ctrl.linecap);
+	//sw.LineJoin(~ctrl.linejoin);
+	{ 
+	//	//PAINTER_TIMING("FILL");
+	//	if(ctrl.transparent)
+	//		sw.Clear(RGBAZero());
+	//	else
+			//sw.Clear(White());
+	}
+
+	DoPaint0(sw);
+}
+
+void CMeter::Paint(Draw& w)
+{
+	Size sz = GetSize();
+/*
+	ImageBuffer ib(sz);
+	BufferPainter sw(ib, 0);
+	DoPaint(sw);
+	w.DrawImage(0, 0, ib);
+*/
+	DrawPainter dp(w, sz);
+	DoPaint(dp);
+	
+	if(HasFocus())
+		DrawFocus(w, sz);
+}
+
+void CMeter::GotFocus()
+{
+	Refresh();
+}
+
+void CMeter::LostFocus()
+{
+	Refresh();
+}
+
+//controlling
+
+int CMeter::ValToPix(float _val)
+{
+	float pix = 0; 
+	Size s = GetSize();
+
+	if(stepping && steplin)
+	{
+		if(vertical)
+		{
+			if(!reverse)
+			{
+				pix = (float)s.cy - (_val+1) * (float)(s.cy)/(vsteps.GetCount());
+			}
+			else
+			{
+				pix = (_val+1) * (float)(s.cy)/(vsteps.GetCount());
+			}
+		}
+		else
+		{
+			if(!reverse)
+			{
+				pix = (_val+1) * (float)(s.cx)/(vsteps.GetCount());
+			}
+			else
+			{
+				pix = (float)s.cx - (_val+1) * (float)(s.cx)/(vsteps.GetCount());
+			}
+		}
+		return fround(pix);
+	}
+
+	if(vertical)
+	{
+		if(!reverse)
+		{
+			pix = (float)s.cy - (_val - min) * (float)(s.cy)/(max - min);
+		}
+		else
+		{
+			pix = (_val - min) * (float)(s.cy)/(max - min);
+		}
+	}
+	else
+	{
+		if(!reverse)
+		{
+			pix = (_val - min) * (float)(s.cx)/(max - min);
+		}
+		else
+		{
+			pix = (float)s.cx - (_val - min) * (float)(s.cx)/(max - min);
+		}
+	}
+	
+	return fround(pix);
+}
+
+float CMeter::PointToVal(Point & p)
+{
+	Size s = GetSize();
+	
+	if(stepping && steplin)
+	{
+		float _i = 0;
+		if(vertical)
+		{
+			if(!reverse)
+			{
+				_i = -1 + (float)vsteps.GetCount() * (float)(s.cy - p.y)/(float)s.cy;
+			}
+			else
+			{
+				_i = -1 + (float)vsteps.GetCount() * (float)p.y/(float)s.cy;
+			}
+		}
+		else
+		{
+			if(!reverse)
+			{
+				_i = -1 + (float)vsteps.GetCount() * (float)p.x/(float)s.cx;
+			}
+			else
+			{
+				_i = -1 + (float)vsteps.GetCount() * (float)(s.cx - p.x)/(float)s.cx;
+			}
+		}
+		return _i;
+	}
+
+	float _val = min;
+	if(vertical)
+	{
+		if(!reverse)
+		{
+			_val = min + (max - min) * (float)(s.cy - p.y)/(float)s.cy;
+		}
+		else
+		{
+			_val = min + (max - min) * (float)p.y/(float)s.cy;
+		}
+	}
+	else
+	{
+		if(!reverse)
+		{
+			_val = min + (max - min) * (float)p.x/(float)s.cx;
+		}
+		else
+		{
+			_val = min + (max - min) * (float)(s.cx - p.x)/(float)s.cx;
+		}
+	}
+	
+	return _val;
+}
+
+bool CMeter::SetDirect(Point p, dword keyflags)
+{
+	float newval = PointToVal(p);
+	if(stepping && steplin)
+	{
+		int i = (int)newval;//fround(newval);
+		if(i<0)
+			Set(min);
+		else
+		if(i>=vsteps.GetCount())
+			Set(max);
+		else
+			Set(vsteps[i]);
+	}
+	else
+		Set(newval);
+	return true;
+}
+
+bool CMeter::SetFollow(float _val)
+{
+	float newval;
+	
+	if(stepping && steplin)
+	{
+//		if(steplin)
+//		{
+			int _ii = fround(_val);
+			int newii;
+			
+			if(__ii < _ii)
+			{
+				//inc
+				newii = __ii + inci;
+				if(newii>_ii) { newii = _ii; increment = 1; }
+			}
+			else
+			if(__ii > _ii)
+			{
+				//dec
+				newii = __ii - inci;
+				if(newii<_ii) { newii = _ii; increment = 1; }
+			}
+			else
+				return false;
+			__ii = newii; //cache
+
+			if(newii<0)
+				newval = min;
+			else
+			if(newii>=vsteps.GetCount())
+				newval = max;
+			else
+			newval = vsteps[newii];	
+//		}
+/*		else
+		{
+			if(__val < _val)
+			{
+				//inc
+				ii += inci;
+				if(ii>=vsteps.GetCount()) { ii = vsteps.GetCount()-1; increment = 1; }
+			}
+			else
+			if(__val > _val)
+			{
+				//dec
+				ii -= inci;
+				if(ii<-1) { ii = -1; increment = 1; }
+			}
+			else
+				return false;
+			__val = newval; //cache against oszillation, save unstepped, desired value, compared against in SetFollow
+
+			if(ii<0)
+				newval = min;
+			else
+			if(ii>=vsteps.GetCount())
+				newval = max;
+			else
+			newval = vsteps[ii];	
+		}
+*/
+	}
+	else
+	{
+		//normal
+		if(__val < _val)
+		{
+			//inc
+			newval = __val + incv;
+			if(newval > _val) { newval = _val; increment = 1; } //dont pass target, leave repeat active
+		}
+		else
+		if(__val > _val)
+		{
+			//dec
+			newval = __val - incv;
+			if(newval < _val) { newval = _val; increment = 1; } //dont pass target, leave repeat active
+		}
+		else
+			return false;
+		//__val verwendung hier nur wegen stepping gemeinsam
+		__val = newval; //cache against oszillation, save unstepped, desired value, compared against in SetFollow
+
+	}
+
+	Set(newval); //set ourselves again, so refreshing is done
+	return true;
+}
+
+bool CMeter::SetFollow(Point p, dword keyflags)
+{
+	//stepping but need to set the stepped values
+	float _val = PointToVal(p); //targetet value
+	return SetFollow(_val);
+}
+void CMeter::LeftDown(Point p, dword keyflags)
+{
+	if(!IsEditable()) return;
+	if(!HasFocus())
+		SetFocus();
+	SetCapture();
+}
+
+float CMeter::CalcIncV()
+{
+	switch(increment++)
+	{
+		//case 5: increment = -1; //stop
+		//	return;
+		case 0:
+			incv = (float)(max - min) * (float)1 / 1000.0f;
+			inci = 1;
+			break;
+		case 10:
+			incv = (float)(max - min) * (float)increment / 1000.0f;
+			inci = 2;
+			break;
+		case 20:
+			incv = (float)(max - min) * (float)increment *2.0f / 1000.0f;
+			inci = 3;
+			break;
+		default:
+			break; //keep last
+	}
+	return incv;	
+}
+
+void CMeter::LeftRepeat(Point p, dword keyflags)
+{
+	if(!IsEditable()) return;
+	//here we increment
+
+	if(increment < 0)
+		return; //we finished inc already
+
+	CalcIncV();
+
+	if(SetFollow(p, keyflags))
+		Action();
+}
+
+void CMeter::LeftUp(Point p, dword keyflags)
+{
+	ReleaseCapture();
+	if(!IsEditable()) return;
+	if(increment==0) //we had no inc, so we just set
+	{
+		if(clickincdec && !(keyflags & K_CTRL))
+		{
+			LeftRepeat(p, keyflags);			
+		}
+		else
+		{
+			if(SetDirect(p, keyflags))
+				Action();
+		}
+	}
+	else
+	{
+		//is incing or has finished, we may not change the value	
+	}
+	increment = 0; //may start another one
+}
+
+void CMeter::MouseMove(Point p, dword keyflags)
+{
+	//calculate value and set it, will cause a repaint
+	if(!HasFocus()) return;
+	if(!IsEditable()) return;
+	if(!(keyflags & K_MOUSELEFT)) return;
+	
+	if(clickincdec) return;
+	
+	if(increment <=0) //had no inc or is done or we desabled it here due to early move
+	{
+		increment = -1; //once we move, we dont inc
+		if(SetDirect(p, keyflags))
+			Action();
+		return;
+	}
+	//else //inc already started, no action then, keep incing
+}
+
+void CMeter::MouseWheel(Point p, int zdelta, dword keyflags)
+{
+	if(!IsEditable()) return;
+	if(increment != 0) //inc in progress, ignore
+	{
+		return;
+	}
+
+	//if(!HasFocus()) SetFocus();
+	
+	if(zdelta>0)
+		Key(keyflags | K_UP, zdelta/120);
+	else
+		Key(keyflags | K_DOWN, -zdelta/120); //always needs positive repeat
+}
+
+bool CMeter::Key0(dword key, int rep)
+{
+	if(!IsEditable()) return false;
+	if(increment != 0) //inc in progress, ignore
+	{
+		return false;
+	}
+
+	bool select = key & K_SHIFT;
+	bool incb = true;
+
+	incv = inc * rep;
+	inci = rep;
+	if(select)
+	{
+		incv *= 10.0f;
+		inci *= 2;
+	}
+
+	switch(key & ~K_SHIFT)
+	{
+	case K_RIGHT:
+	case K_ADD:
+	case K_UP:
+		incb = true;
+		break;
+	case K_SUBTRACT:
+	case K_LEFT:
+	case K_DOWN:
+		incb = false;
+		break;
+	case K_PAGEUP:
+		incv *= 10.0f;
+		inci *= 2;
+		incb = true;
+		break;
+	case K_PAGEDOWN:
+		incv *= 10.0f;
+		inci *= 2;
+		incb = false;
+		break;
+	default:
+		return false;
+	}
+
+	if(incb)
+	{
+	if(stepping && steplin)
+		return SetFollow((float)0);
+	else
+		return SetFollow(min);
+	}
+	else
+	{
+	if(stepping && steplin)
+		return SetFollow((float)vsteps.GetCount());
+	else
+		return SetFollow(max);
+	}
+	return true;
+}
+
+bool CMeter::Key(dword key, int rep)
+{
+	bool ret = Key0(key, rep);
+	if(ret)
+		Action();
+	return ret;
+}
+
+void CMeter::Inc()
+{
+	Key0(K_UP, 1);
+}
+
+void CMeter::Dec()
+{
+	Key0(K_DOWN, 1);
+}
diff --git a/bazaar/CMeter/CMeter.h b/bazaar/CMeter/CMeter.h
new file mode 100644
index 000000000..59d7161d6
--- /dev/null
+++ b/bazaar/CMeter/CMeter.h
@@ -0,0 +1,211 @@
+#ifndef __METER_H
+#define __METER_H
+
+#include <CtrlLib/CtrlLib.h>
+#include <Painter/Painter.h>
+
+using namespace Upp;
+
+class CMeter : public Ctrl
+{
+	typedef CMeter CLASSNAME;
+	
+public:
+	struct Style : public ChStyle<Style>
+	{
+		Color backcol;
+		Color textcol;
+		Color forecol;
+		Color forecol2;
+
+		int cmarksize;
+
+		enum MODES
+		{
+			STATIC = 0, //static rect
+			GRADIENT,
+			LINES,
+		};
+		int mode; //one of the MODES
+	};
+
+	class CVMark 
+		: Moveable<CVMark>
+	{
+	public:
+		typedef CVMark CLASSNAME;
+		
+		CVMark(float v = 0.0f, String name = "", Color col = LtRed() );
+
+	public:
+	
+		Color			col;
+		String			name; //place some name here to display
+		float			v;
+	};
+
+	enum
+	{
+		IMGCACHE = 0,
+		STATIC,
+		GRADIENT,
+		DYNGRADIENT,	
+	};
+
+	CMeter(float min = 0.0f, float max = 1.0f, bool vertical = false, bool reverse = false);
+	virtual ~CMeter() {}
+	
+public:
+
+	void CreateBack();
+
+	virtual Value GetData() const { return (double)val; }
+	virtual void SetData(const Value& data) { Set((float)(double)data); }
+	Value GetMin() const { return (double)min; }
+	Value GetMax() const { return (double)max; }
+	CMeter & MinMax(const Value& min = 0.0, const Value& max = 1.0) { return MinMax((float)(double)min, (float)(double)max); }
+
+	CMeter & Set(float val);
+	float Get() const { return val; }
+
+	CMeter & Val(float val) { return Set(val); }
+	float Val() const { return val; }
+
+	CMeter & Percent(float percent) { Set(min + percent * (max-min) / 100.0f); }
+	float Percent() const { return 100.0f * (val-min)/(max-min); }
+
+	CMeter & Min(float min);
+	float Min() const { return min; }
+
+	CMeter & Max(float max);
+	float Max() const { return max; }
+
+	CMeter & MinMax(float min = 0.0f, float max = 1.0f);
+
+	CMeter & Reverse(bool reverse = true);
+	float IsReverse() const { return reverse; }
+
+	CMeter & Vertical(bool vertical = true);
+	bool IsVertical() const { return vertical; }
+
+	CMeter & Stepping(bool stepping = true);
+	bool IsStepping() const { return stepping; }
+
+	CMeter & StepLinear(bool steplin = true);
+	bool IsStepLinear() { return steplin; }
+
+	CMeter & IncDecToStep(bool b = true) { incdectostep = b; return *this; }
+	bool IsIncDecToStep() { return incdectostep; }
+
+	CMeter & Steps(const Vector<float> & vsteps, bool reverse = false);
+	void GetSteps(Vector<float> & vstep) { vsteps <<= this->vsteps; }
+
+	int FindStep(float v) const;
+
+	CMeter & ShowValue(bool showvalue = true);
+	CMeter & HideValue() { return ShowValue(false); }
+	bool IsShowValue() { return showvalue; }
+
+	CMeter & ShowPercent(bool showpercent = true);
+	bool IsShowPercent() { return showpercent; }
+
+	CMeter & SetMode(int mode);
+	int GetMode() const { return drawmode; }
+
+	void Inc();
+	void Dec();
+
+	CMeter& SetInc(float _inc = 0.1) { inc = _inc; return *this; }
+	double GetInc() const { return inc; }
+
+	CMeter& SetStyle(const Style& s);
+	static const Style& StyleDefault();
+
+protected:
+	const Style *style;
+
+	virtual void Layout();
+	virtual void Paint(Draw& w);
+	virtual void Update();
+	
+	virtual void LeftRepeat(Point p, dword keyflags);
+	virtual void LeftDown(Point p, dword keyflags);			
+	virtual void LeftUp(Point p, dword keyflags) ;	
+	virtual void MouseMove(Point p, dword keyflags);
+	virtual void   MouseWheel(Point p, int zdelta, dword keyflags);
+
+	virtual void GotFocus();
+	virtual void LostFocus();
+
+	virtual bool Key(dword key, int rep);
+	bool Key0(dword key, int rep);
+	
+	virtual int ValToPix(float _val);
+	virtual float PointToVal(Point & p);
+
+	bool SetFollow(float _val);
+	bool SetFollow(Point p, dword keyflags);
+	bool SetDirect(Point p, dword keyflags);
+	float CalcIncV();
+
+	void PaintBarGradient(Painter & sw, bool staticgradient = true);
+	void PaintBarStatic(Painter & sw);
+	void PaintBarImage(Painter & sw);
+	void PaintCVMarks(Painter & sw);
+	void PaintValue(Painter & sw);
+	
+	void DoPaint0(Painter& sw);
+	void DoPaint(Painter& sw);
+
+public:
+
+	Vector<CVMark> cvmarks; //here we can set some marking
+
+protected:
+	
+	//cached data
+	
+	int px; //some offsets from top left, used as offset where to start drawinf bar, no matter horz or vert
+	int py;
+
+	int _px; //some helpers to draw cvmarks, are extension of the cvmarks
+	int _py;
+	
+	float pp; //cached [0:1] of drawn size
+	int dx, lx, dy, ly; //some cache for painting, d barsize, l emtpy size
+
+	int increment; //a state helper for repeating counts
+	float incv; //for value following if not stepping
+	int inci; //for value following if stepping
+	float __val; //cached desired value for inc compare against oszillation when stepping
+	int __ii; //cached current step index
+
+	String s; //the printed value
+	Size tlen; //text len
+
+	//vital data
+
+	float min;
+	float max;
+	float val;
+
+	float inc; //for keys
+	
+	bool vertical:1;
+	bool reverse:1;
+	bool stepping:1;
+	bool steplin:1;
+	bool showvalue:1;
+	bool showpercent:1;
+	bool clickincdec:1;
+	bool incdectostep:1;
+
+	int drawmode;
+
+
+	Font font;
+	Image draw;
+	Vector<float> vsteps;
+};
+
+#endif
\ No newline at end of file
diff --git a/bazaar/CMeter/CMeter.upp b/bazaar/CMeter/CMeter.upp
new file mode 100644
index 000000000..642528df1
--- /dev/null
+++ b/bazaar/CMeter/CMeter.upp
@@ -0,0 +1,11 @@
+description "a Meter Drawing control, more versatile than the Upp progress stuff\377";
+
+uses
+	CtrlLib,
+	Painter;
+
+file
+	CMeter.h,
+	CMeter.cpp,
+	src.tpp;
+
diff --git a/bazaar/CMeter/init b/bazaar/CMeter/init
new file mode 100644
index 000000000..7f9f8368d
--- /dev/null
+++ b/bazaar/CMeter/init
@@ -0,0 +1,5 @@
+#ifndef _CMeter_icpp_init_stub
+#define _CMeter_icpp_init_stub
+#include "CtrlLib/init"
+#include "Painter/init"
+#endif
diff --git a/bazaar/CMeter/src.tpp/CMeter$en-us.tpp b/bazaar/CMeter/src.tpp/CMeter$en-us.tpp
new file mode 100644
index 000000000..ee72b7838
--- /dev/null
+++ b/bazaar/CMeter/src.tpp/CMeter$en-us.tpp
@@ -0,0 +1,37 @@
+topic "";
+[ $$0,0#00000000000000000000000000000000:Default]
+[H6;0 $$1,0#05600065144404261032431302351956:begin]
+[i448;a25;kKO9;2 $$2,0#37138531426314131252341829483370:codeitem]
+[l288;2 $$3,0#27521748481378242620020725143825:desc]
+[0 $$4,0#96390100711032703541132217272105:end]
+[i448;a25;kKO9; $$5,0#37138531426314131252341829483380:structitem]
+[{_} 
+[s1; &]
+[s5;:CMeter`:`:CVMark`:`:class: [@(0.0.255) class]_[* CVMark]_:_[@(0.0.255) private]_[*@3 Move
+able]<[* CVMark]>_&]
+[s3;%% markers shown at side of the meter, independant from meter 
+value&]
+[s4; &]
+[s2;:CMeter`:`:FindStep`(float`)const: [@(0.0.255) int]_[* FindStep]([@(0.0.255) float]_[*@3 v
+])_[@(0.0.255) const]&]
+[s3;%% find value [%-*@3 v].in the steps vector and return index if 
+found&]
+[s4;%% &]
+[s1; &]
+[s2;:CMeter`:`:GRADIENT: [@(0.0.255) enum]_[* GRADIENT]&]
+[s3;%% a static gradient, a lice of which is displayed&]
+[s4; &]
+[s1; &]
+[s2;:CMeter`:`:STATIC: [@(0.0.255) enum]_[* STATIC]&]
+[s3;%% static color bar&]
+[s4; &]
+[s1; &]
+[s2;:CMeter`:`:IMGCACHE: [@(0.0.255) enum]_[* IMGCACHE]_`=_[@3 0]&]
+[s3;%% a fancy bar gradient with 2 colors, actually generated and 
+stored in an Image&]
+[s4; &]
+[s1; &]
+[s2;:CMeter`:`:DYNGRADIENT: [@(0.0.255) enum]_[* DYNGRADIENT]&]
+[s3;%% a gradient drawn over currently applied bar&]
+[s4; &]
+[s0; ]
\ No newline at end of file
diff --git a/bazaar/CMeterTest/CMeterTest.h b/bazaar/CMeterTest/CMeterTest.h
new file mode 100644
index 000000000..7541fd66b
--- /dev/null
+++ b/bazaar/CMeterTest/CMeterTest.h
@@ -0,0 +1,32 @@
+#ifndef _CMeterTest_CMeterTest_h
+#define _CMeterTest_CMeterTest_h
+
+#include <CtrlLib/CtrlLib.h>
+
+using namespace Upp;
+
+#define LAYOUTFILE <CMeterTest/CMeterTest.lay>
+#include <CtrlCore/lay.h>
+
+#include <CMeter/CMeter.h>
+
+class CMeterTest : public WithCMeterTestLayout<TopWindow> {
+public:
+	typedef CMeterTest CLASSNAME;
+	CMeterTest();
+
+	void metersl_CB();
+	void meterrev_CB();
+	void metervert_CB();
+	void meterstep_CB();
+	void meterperc_CB();
+	void metersteplin_CB();
+
+	void meterCB();
+	void metermodeCB();
+
+	CMeter meter;
+};
+
+#endif
+
diff --git a/bazaar/CMeterTest/CMeterTest.lay b/bazaar/CMeterTest/CMeterTest.lay
new file mode 100644
index 000000000..9c12dbba9
--- /dev/null
+++ b/bazaar/CMeterTest/CMeterTest.lay
@@ -0,0 +1,11 @@
+LAYOUT(CMeterTestLayout, 596, 352)
+	ITEM(SliderCtrl, metersl, RightPosZ(68, 288).TopPosZ(4, 20))
+	ITEM(Option, PERC, SetLabel(t_("percent")).RightPosZ(4, 64).TopPosZ(72, 16))
+	ITEM(Option, STEPLIN, SetLabel(t_("steplin")).RightPosZ(0, 64).TopPosZ(224, 16))
+	ITEM(Option, STEP, SetLabel(t_("stepping")).RightPosZ(8, 64).TopPosZ(204, 16))
+	ITEM(Option, VERT, SetLabel(t_("vertical")).RightPosZ(4, 64).TopPosZ(40, 16))
+	ITEM(Option, REV, SetLabel(t_("reverse")).RightPosZ(4, 64).TopPosZ(24, 16))
+	ITEM(EditInt, sledit, SetEditable(false).RightPosZ(4, 64).TopPosZ(4, 19))
+	ITEM(Switch, mode, LeftPosZ(520, 72).TopPosZ(92, 108))
+END_LAYOUT
+
diff --git a/bazaar/CMeterTest/CMeterTest.upp b/bazaar/CMeterTest/CMeterTest.upp
new file mode 100644
index 000000000..fe9a9e64d
--- /dev/null
+++ b/bazaar/CMeterTest/CMeterTest.upp
@@ -0,0 +1,12 @@
+uses
+	CtrlLib,
+	CMeter;
+
+file
+	CMeterTest.h,
+	main.cpp,
+	CMeterTest.lay;
+
+mainconfig
+	"" = "GUI";
+
diff --git a/bazaar/CMeterTest/init b/bazaar/CMeterTest/init
new file mode 100644
index 000000000..1c9bd9d46
--- /dev/null
+++ b/bazaar/CMeterTest/init
@@ -0,0 +1,5 @@
+#ifndef _CMeterTest_icpp_init_stub
+#define _CMeterTest_icpp_init_stub
+#include "CtrlLib/init"
+#include "CMeter/init"
+#endif
diff --git a/bazaar/CMeterTest/main.cpp b/bazaar/CMeterTest/main.cpp
new file mode 100644
index 000000000..7fa13828c
--- /dev/null
+++ b/bazaar/CMeterTest/main.cpp
@@ -0,0 +1,83 @@
+#include "CMeterTest.h"
+
+CMeterTest::CMeterTest()
+{
+	CtrlLayout(*this, "Window title");
+
+	metersl.MinMax(-100,100).SetData(0);
+	metersl <<= THISBACK(metersl_CB);
+	REV <<= THISBACK(meterrev_CB);
+	VERT <<= THISBACK(metervert_CB);
+	STEP <<= THISBACK(meterstep_CB);
+	STEPLIN <<= THISBACK(metersteplin_CB);
+	PERC <<= THISBACK(meterperc_CB);
+
+	mode.Add(CMeter::IMGCACHE, "IMGCACHE");
+	mode.Add(CMeter::STATIC, "STATIC");
+	mode.Add(CMeter::GRADIENT, "GRADIENT");
+	mode.Add(CMeter::DYNGRADIENT, "DYNGRADIENT");
+	mode <<= THISBACK(metermodeCB);
+
+	float min = (float)metersl.GetMin();
+	float max = (float)metersl.GetMax();
+	
+	//setup the marks
+	Vector<float> vmarks;
+	vmarks.Add(max);
+	vmarks.Add(max-(max-min)*0.1f);
+	vmarks.Add(max-(max-min)*0.2f);
+	vmarks.Add(max-(max-min)*0.3f);
+	vmarks.Add(max-(max-min)*0.4f);
+	vmarks.Add(max-(max-min)*0.7f);
+
+	meter <<= THISBACK(meterCB);
+	meter.Min(min).Max(max).Steps(vmarks, true).Set(min);  //use reverse order, meter needs starting vector with min
+	Add(meter.LeftPos(10,50).TopPos(10,200));
+}
+
+void CMeterTest::meterCB()
+{
+	double f = meter.GetData();
+	metersl.SetData(f);
+}
+
+void CMeterTest::metersl_CB()
+{
+	sledit.SetData(metersl.GetData());
+	meter.Set((float)(double)metersl.GetData());
+}
+
+void CMeterTest::meterrev_CB()
+{
+	meter.Reverse(REV.GetData()).Refresh();
+}
+
+void CMeterTest::metervert_CB()
+{
+	meter.Vertical(VERT.GetData()).Refresh();
+}
+
+void CMeterTest::meterstep_CB()
+{
+	meter.Stepping(STEP.GetData()).Refresh();
+}
+void CMeterTest::metersteplin_CB()
+{
+	meter.StepLinear(STEPLIN.GetData()).Refresh();
+}
+void CMeterTest::meterperc_CB()
+{
+	meter.ShowPercent(PERC.GetData()).Refresh();
+}
+
+void CMeterTest::metermodeCB()
+{
+	int m = mode.GetData();
+	meter.SetMode(m).Refresh();
+}
+
+GUI_APP_MAIN
+{
+	CMeterTest().Run();
+}
+