#include <CtrlLib/CtrlLib.h>

using namespace Upp;

class Testcase5 : public TopWindow {
public:
	typedef Testcase5 CLASSNAME;
	
	Rect loc;
	
	Testcase5(){
		loc.SetNull();
	}

	void Paint(Draw &w){
		w.DrawRect(Rect(GetSize()),White());
		loc.SetNull();
	}
	
	void MouseMove(Point p, dword keyflags){
		ImageBuffer sb(32,32);
		BufferPainter sbp(sb);
		sbp.Clear(RGBAZero());
		sbp.Move(0,0).Line(31,31);
		sbp.Move(0,31).Line(31,0);
		sbp.Stroke(5,Gray());
		
		ViewDraw draw(this);
		if(!loc.IsNullInstance()) draw.DrawRect(loc,White());
		loc.Set(p.x-16,p.y-16,p.x+16,p.y+16);
		draw.DrawImage(loc.left,loc.top,Image(sb));
	}
};


GUI_APP_MAIN
{
	Testcase5().Run();
}

#include <CtrlLib/CtrlLib.h>

using namespace Upp;

class Testcase5 : public TopWindow {
public:
	typedef Testcase5 CLASSNAME;
	
	Rect loc;
	
	ImageBuffer map;
	
	Testcase5(){
		loc.SetNull();
	}

	void Paint(Draw &w){
		int64 t0=usecs();
		
		SetSurface(w,Rect(map.GetSize()),map,map.GetSize(),Point(0,0));
		loc.SetNull();
		
		int64 t1=usecs();
		Title(Format("Paint took %lld us",t1-t0));
	}
	
	void Layout(){
		Size sz=GetSize();
		map.Create(sz);
		BufferPainter bp(map);
		bp.RectPath(Rect(sz));
		bp.Fill(Pointf(0,0),Green(),Pointf(sz.cx-1,sz.cy-1),Yellow());
		bp.Move(0,0).Line(Pointf(sz.cx-1,sz.cy-1)).Stroke(1,Black());
		bp.Move(0,sz.cy-1).Line(Pointf(sz.cx-1,0)).Stroke(1,Black());
	}
	
	void MouseMove(Point p, dword keyflags){
		int64 t0=usecs();
		
		Rect area;
		area.SetNull();
		if(!loc.IsNullInstance()) area.Union(loc);
		loc.Set(p.x-16,p.y-16,p.x+16,p.y+16);
		area.Union(loc);
		area.Inflate(2);
		area.Intersect(Rect(GetSize()));
		
		ImageBuffer sb(area.GetSize());
		for(int y=0;y<area.Height();y++) memcpy(sb[y],&map[y+area.top][area.left],sizeof(RGBA)*area.Width());

		BufferPainter sbp(sb);
		sbp.Translate(loc.left-area.left,loc.top-area.top);
		sbp.Move(0,0).Line(31,31);
		sbp.Move(0,31).Line(31,0);
		sbp.Stroke(5,Black());
		
		ViewDraw draw(this,area);
		SetSurface(draw,area.GetSize(),sb,sb.GetSize(),Point(0,0));
		
		int64 t1=usecs();
		Title(Format("Move took %lld us",t1-t0));
		
	}
};


GUI_APP_MAIN
{
	Testcase5().Sizeable().MaximizeBox().MinimizeBox().Run();
}

		int64 t0=usecs();
		w.DrawImage(0,0,image);
		int64 t1=usecs();
		Title(Format("Paint took %lld us",t1-t0));

void SystemDraw::SysDrawImageOp(int x, int y, const Image& img, Color color)
{
...
//	cache.Shrink(4 * 1024 * 768, 1000); // Cache must be after Paint because of PaintOnly!
	cache.Shrink(4 * 3840 * 2160, 1000); // Cache must be after Paint because of PaintOnly!
}

	//Size sz = Ctrl::GetPrimaryScreenArea().GetSize();
	Size sz(3840,2160); // Twice as fast compared to the above... why?
	cache.Shrink(4 * sz.cx * sz.cy, 1000); // Cache must be after Paint because of PaintOnly!

Ctrl::GetPrimaryScreenArea() = [0, 0] - [3840, 2080] : (3840, 2080)

void ImageSysData::Paint(SystemDraw& w, int x, int y, const Rect& src, Color c)

#include <CtrlLib/CtrlLib.h>

using namespace Upp;

GUI_APP_MAIN
{
	DDUMP(GetDeviceCaps(GetDC(NULL), SHADEBLENDCAPS) & SB_PIXEL_ALPHA);
}

	if(0 && fnAlphaBlend() && IsNull(c) && !ImageFallBack &&

void SystemDraw::SysDrawImageOp(int x, int y, const Image& img, Color color)
{
...
	static Size sz;
	if(!sz.cx) sz = Ctrl::GetPrimaryScreenArea().GetSize();
	cache.Shrink(4 * sz.cx * sz.cy, 1000); // Cache must be after Paint because of PaintOnly!
}

ImageBuffer(Size sz, int kind=IMAGE_UNKNOWN)

ImageBuffer::Create(Size sz, int kind=IMAGE_UNKNOWN)...

void SystemDraw::SysDrawImageOp(int x, int y, const Image& img, const Rect& src, Color color)
{
	GuiLock __;
	if(img.GetLength() == 0)
		return;
	LLOG("SysDrawImageOp " << img.GetSerialId() << ' ' << img.GetSize());

// Insert this optimization here:
	int kind = img.GetKindNoScan();
	if(kind == IMAGE_OPAQUE && !IsNull(color)) {
		Size sz=img.GetSize();
		DrawRect(x, y, sz.cx, sz.cy, color);
		return;
	}
	if(kind == IMAGE_OPAQUE && (GetDeviceCaps(GetHandle(), RASTERCAPS) & RC_DIBTODEV)) {
		LTIMING("Image Opaque direct set");
		Size sz=img.GetSize();
		SetSurface(*this, x, y, sz.cx, sz.cy, ~img);
		return;
	}
// End of insertion

	ImageSysDataMaker m;
	...

struct ImageSysData {
	Image            img;
	cairo_surface_t *surface = NULL;
	
	void Init(const Image& m, cairo_surface_t *other);
	~ImageSysData();
};

cairo_surface_t *CreateCairoSurface(const Image& img, cairo_surface_t *other)
{
	Size isz = img.GetSize();
	cairo_format_t fmt = CAIRO_FORMAT_ARGB32;
	cairo_surface_t *surface = other && 0 ? cairo_surface_create_similar_image(other, fmt, isz.cx, isz.cy)
	                                 : cairo_image_surface_create(fmt, isz.cx, isz.cy);
	cairo_surface_flush(surface);
	byte *a = (byte *)cairo_image_surface_get_data(surface);
	int stride = cairo_format_stride_for_width(fmt, isz.cx);
	for(int yy = 0; yy < isz.cy; yy++) {
		Copy((RGBA *)a, img[yy], isz.cx);
		a += stride;
	}
	cairo_surface_mark_dirty(surface);
	return surface;
}

cairo_surface_t *CreateCairoSurface(const Image& img)
{
	return CreateCairoSurface(img, NULL);
}

void ImageSysData::Init(const Image& m, cairo_surface_t *other)
{
	img = m;
	surface = CreateCairoSurface(m, other);
	SysImageRealized(img);
}

ImageSysData::~ImageSysData()
{
	SysImageReleased(img);
	cairo_surface_destroy(surface);
}

struct ImageSysDataMaker : LRUCache<ImageSysData, int64>::Maker {
	Image img;
	cairo_surface_t *other;

	virtual int64  Key() const                      { return img.GetSerialId(); }
	virtual int    Make(ImageSysData& object) const { object.Init(img, other); return img.GetLength(); }
};

void SystemDraw::SysDrawImageOp(int x, int y, const Image& img, Color color)
{
	GuiLock __;
	FlushText();
	if(img.GetLength() == 0)
		return;
	LLOG("SysDrawImageOp " << img.GetSerialId() << ' ' << x << ", " << y << ", "<< img.GetSize());
	ImageSysDataMaker m;
	static LRUCache<ImageSysData, int64> cache;
	static int Rsz;
	Rsz += img.GetLength();
	if(Rsz > 200 * 200) { // we do not want to do this for each small image painted...
		Rsz = 0;
		cache.Remove([](const ImageSysData& object) {
			return object.img.GetRefCount() == 1;
		});
	}
	LLOG("SysImage cache pixels " << cache.GetSize() << ", count " << cache.GetCount());
	m.img = img;
	m.other = cairo_get_target(cr);
	ImageSysData& sd = cache.Get(m);
	if(!IsNull(color)) {
		SetColor(color);
		cairo_mask_surface(cr, sd.surface, x, y);
	}
	else {
		RTIMESTOP("cairo_paint");
		if(img.GetKindNoScan() == IMAGE_OPAQUE)
			cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
		cairo_set_source_surface(cr, sd.surface, x, y);
		cairo_paint(cr);
		cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
	}
	static Size ssz;
	if(ssz.cx == 0)
		ssz = Ctrl::GetVirtualScreenArea().GetSize();
	cache.Shrink(4 * ssz.cx * ssz.cy, 1000); // Cache must be after Paint because of PaintOnly!
}

class LineTracker: public RectTracker{
public:
	int mode;
	Vector<Point> route;

	Vector<Point> TrackLine(const Point& p){
		mode=1;
		route.Clear();
		route.Add(p);
		Track(Rect(p,p),0,0);
		return clone(route);
	}
	
	Vector<Point> TrackRoute(const Point& p){
		mode=2;
		route.Clear();
		route.Add(p);
		Track(Rect(p,p),0,0);
		return clone(route);
	}

	void MouseMove(Point p, dword){
		if(mode==2 || route.GetCount()<2){
			route.Add(p);
		}
		else route[1]=p;
		Refresh();
		sync(Rect(route[0],route[route.GetCount()-1]));
	}

	void Paint(Draw& w){
		w.DrawImage(0, 0, master_image);
		w.Clip(clip & GetMaster().GetSize());
		int style=width;
		if(pattern!=DRAWDRAGRECT_SOLID){
			Color color2 = IsDark(color) ? White() : Black();
			w.DrawPolyline(route,width,color2);
			switch(pattern){
				case DRAWDRAGRECT_NORMAL:
					style=PEN_DOT;
					break;
				case DRAWDRAGRECT_DASHED:
					style=PEN_DASHDOT;
					break;
			}
		}
		w.DrawPolyline(route,style,color);
		w.End();
	}
	
	LineTracker(Ctrl &master): RectTracker(master){
		MinSize(Size(-100000,-100000));
		mode=1;
	}
};

	void LeftDown(Point p, dword flags){
		LineTracker tracker(*this);
		tracker.Solid();
		tracker.Width(3);
		tracker.SetColor(Blue());

		Vector<Point> res;

		if(flags&K_CTRL) res = tracker.TrackRoute(p);
		else res = tracker.TrackLine(p);
		// ...
	}