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);
		// ...
	}