virtual bool   PenDown(Point p, dword keyflags){ return false; }
	virtual bool   PenUp(Point p, dword keyflags){ return false; }
	virtual bool   PenMove(Point p, dword keyflags){ return false; }

				switch(message) {
				case WM_POINTERDOWN:
					ClickActivateWnd();
					if(PenDown(Point(p), GetMouseFlags())) return 0L;
					break;
				case WM_POINTERUP:
					if(PenUp(Point(p), GetMouseFlags())) return 0L;
					break;
				case WM_POINTERUPDATE:
					if(PenMove(Point(p), GetMouseFlags())) return 0L;
					break;
				}
				break;

#include <CtrlLib/CtrlLib.h>

using namespace Upp;

struct MyApp : TopWindow {
	Point pos;
	
	Vector<Vector<Tuple<double, Pointf>>> drawing;

	PenInfo pen;
	
	virtual bool Pen(Point p, const PenInfo& pn, dword keyflags) {
		if(pn.pressure) {
			if((!!pn.pressure == !!pen.pressure) && drawing.GetCount())
				drawing.Top().Add(MakeTuple(pn.pressure, p));
			else
				drawing.Add().Add(MakeTuple(pn.pressure, p));
		}
		pen = pn;
		Refresh();
		return true;
	}
	
	virtual void Paint(Draw& w0) {
		DrawPainter w(w0, GetSize());
		w.Co();
		w.Clear(SColorPaper());
		
		w.LineCap(LINECAP_ROUND);
		for(const auto& stroke : drawing)
			if(stroke.GetCount())
				for(int i = 0; i < stroke.GetCount() - 1; i++) {
					w.Move(stroke[i].b);
					w.Line(stroke[i + 1].b);
					w.Stroke(DPI(20) * stroke[i].a, Black());
				}
		
		int fcy = GetStdFontCy();
		int y = 10;
		auto Text = [&] (const String& text) {
			w.DrawText(10, y, text);
			y += fcy;
		};
		Text(AsString(pos));
		Text(String() << "Pressure: " << pen.pressure);
		Text(String() << "Rotation: " << pen.rotation);
		Text(String() << "Tilt: " << pen.tilt);
		Text(String() << "Barrel: " << pen.barrel);
		Text(String() << "Inverted: " << pen.inverted);
		Text(String() << "Eraser: " << pen.eraser);
	}
};

GUI_APP_MAIN
{
	MyApp().Run();
}

	virtual bool Pen(Point p, const PenInfo& pn, dword keyflags) {
		if(pn.action==PEN_DOWN){
			if(keyflags&K_SHIFT){
				RectTracker tracker(*this);
				tracker.sync= [=](Rect r) {  };
				tracker.MinSize(Size(-100000,-100000));
				tracker.Track(Rect(p,p));
			}
			else if(keyflags&K_CTRL){
				RectTracker tracker(*this);
				tracker.TrackLine(p.x,p.y);
			}
		}
		
		if(pn.pressure) {
			if((!!pn.pressure == !!pen.pressure) && drawing.GetCount())
				drawing.Top().Add(MakeTuple(pn.pressure, p));
			else
				drawing.Add().Add(MakeTuple(pn.pressure, p));
		}
		pen = pn;
		Refresh();
		return true;
	}

	virtual bool Pen(Point p, const PenInfo& pn, dword keyflags) {
		if(keyflags&K_SHIFT)
			return false;
		if(pn.pressure) {
			if((!!pn.pressure == !!pen.pressure) && drawing.GetCount())
				drawing.Top().Add(MakeTuple(pn.pressure, p));
			else
				drawing.Add().Add(MakeTuple(pn.pressure, p));
		}
		pen = pn;
		Refresh();
		return true;
	}
	
	void LeftDown(Point p, dword keyflags) override {
		if(keyflags & K_SHIFT) {
			RectTracker tracker(*this);
			tracker.MinSize(Size(-100000,-100000));
			tracker.Track(Rect(p,p));
		}
	}

#define PENMOVE		0
#define PENDOWN		1
#define PENUP		2
#define PENHOLD		3
#define PENDRAG		4
#define PENDOUBLE	5
#define PENTRIPLE	6

bool IsNear(Point p, Point o){
	Point delta(p-o);
	if(abs(delta.x)<5 && abs(delta.y)<5) return true;
	return false;
}
	
int PenDecoder(Point p, const PenInfo& pn, dword keyflags){
	static int action=0;
	static int downt=0;
	static Point downp=Null;
	static bool doubleClick=true;
	static bool down=false;
	static bool solved=false;
	int now=msecs();
	int deltat=now-downt;
	
	
	bool isNear=IsNear(p,downp);
	
	switch(pn.action){
		case PEN_DOWN:
			down=true;
			solved=false;
			downp=p;
			downt=now;
			if(isNear){
				if(now-downt < 500){
					if(doubleClick){
						return PENTRIPLE;
					}
					else{
						doubleClick=true;
						return PENDOUBLE;
					}
				}
			}
			doubleClick=false;
			return PENDOWN;

		case PEN_UP:
			down=false;
			return PENUP;

		default:
			if(down && !solved){
				if(isNear){
					if(now-downt > 1000){
						solved=true;
						return PENHOLD;
					}
				}
				else{
					solved=true;
					return PENDRAG;
				}
			}
			return PENMOVE;
	}
}

	virtual bool  Pen(Point p, const PenInfo& pn, dword keyflags);

bool RectTracker::Pen(Point p, const PenInfo& pn, dword keyflags){
	switch(pn.action){
		default:
			MouseMove(p, keyflags);
			break;
		case PEN_UP:
			LeftUp(p, keyflags);
			break;
	}
	return true;
}

...

static bool pendown=false;

bool GetShift()       { return !!(GetKeyStateSafe(VK_SHIFT) & 0x8000); }
bool GetCtrl()        { return !!(GetKeyStateSafe(VK_CONTROL) & 0x8000); }
bool GetAlt()         { return !!(GetKeyStateSafe(VK_MENU) & 0x8000); }
bool GetCapsLock()    { return !!(GetKeyStateSafe(VK_CAPITAL) & 1); }
bool GetMouseLeft()   { return pendown || !!(GetKeyStateSafe(VK_LBUTTON) & 0x8000); }
bool GetMouseRight()  { return !!(GetKeyStateSafe(VK_RBUTTON) & 0x8000); }
bool GetMouseMiddle() { return !!(GetKeyStateSafe(VK_MBUTTON) & 0x8000); }

bool PassWindowsKey(int wParam);

LRESULT Ctrl::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) {
	GuiLock __;
	eventid++;
//	LLOG("Ctrl::WindowProc(" << message << ") in " << ::Name(this) << ", focus " << (void *)::GetFocus());
	Ptr<Ctrl> _this = this;
	HWND hwnd = GetHWND();

	switch(message) {
	case WM_POINTERDOWN:
	case WM_POINTERUPDATE:
	case WM_POINTERUP: {
			pen.action = 0;
			pen.pressure = pen.rotation = Null;
			pen.tilt = Null;
			pen.eraser = pen.barrel = pen.inverted = pen.history = false;

			static BOOL (WINAPI *GetPointerType)(UINT32 pointerId, POINTER_INPUT_TYPE *pointerType);
			static BOOL (WINAPI *GetPointerInfo)(UINT32 pointerId, POINTER_INFO *pointerInfo);
			static BOOL (WINAPI *GetPointerPenInfo)(UINT32 pointerId, POINTER_PEN_INFO *penInfo);
			static BOOL (WINAPI *GetPointerPenInfoHistory)(UINT32 pointerId, UINT32 *entriesCount, POINTER_PEN_INFO *penInfo);

			ONCELOCK {
				DllFn(GetPointerType, "User32.dll", "GetPointerType");
				DllFn(GetPointerInfo, "User32.dll", "GetPointerInfo");
				DllFn(GetPointerPenInfo, "User32.dll", "GetPointerPenInfo");
				DllFn(GetPointerPenInfoHistory, "User32.dll", "GetPointerPenInfoHistory");
			};

			if(!(GetPointerType && GetPointerInfo && GetPointerPenInfo && GetPointerPenInfoHistory))
				break;

			POINTER_INPUT_TYPE pointerType;

			auto ProcessPenInfo = [&] (POINTER_PEN_INFO& ppi) {
				if(ppi.penFlags & PEN_FLAG_BARREL)
					pen.barrel = true;
				if(ppi.penFlags & PEN_FLAG_INVERTED)
					pen.inverted = true;
				if(ppi.penFlags & PEN_FLAG_ERASER)
					pen.eraser = true;
				if(ppi.penMask & PEN_MASK_PRESSURE)
					pen.pressure = ppi.pressure / 1024.0;
				if(ppi.penMask & PEN_MASK_ROTATION)
					pen.rotation = ppi.rotation * M_2PI / 360;
				if(ppi.penMask & PEN_MASK_TILT_X)
					pen.tilt.x = ppi.tiltX * M_2PI / 360;
				if(ppi.penMask & PEN_MASK_TILT_Y)
					pen.tilt.y = ppi.tiltY * M_2PI / 360;
			};

			UINT32 pointerId = GET_POINTERID_WPARAM(wParam);
			if(GetPointerType(pointerId, &pointerType) && pointerType == PT_PEN) {
				UINT32 hc = 256;
				Buffer<POINTER_PEN_INFO> ppit(hc);
				if(message == WM_POINTERUPDATE && GetPointerPenInfoHistory(pointerId, &hc, ppit)) {
					bool processed = false;
					for(int i = hc - 1; i >= 0; i--) {
						ProcessPenInfo(ppit[i]);
						POINT hp = ppit[i].pointerInfo.ptPixelLocation;
						::SetCursorPos(hp.x,hp.y);
						::ScreenToClient(hwnd, &hp);
						pen.history = (bool)i;
						processed = !IsNull(DoMouse(PEN, hp, 0));
					}
					if(processed)
						return 0L;
					else
						break;
				}
				POINTER_PEN_INFO ppi;
				if(GetPointerPenInfo(pointerId, &ppi))
					ProcessPenInfo(ppi);

				POINT p = ppi.pointerInfo.ptPixelLocation;
				::SetCursorPos(p.x,p.y);
				::ScreenToClient(hwnd, &p);

				switch(message) {
				case WM_POINTERDOWN:
					pendown=true;
					pen.action = PEN_DOWN;
					ClickActivateWnd();
					break;
				case WM_POINTERUP:
					pendown=false;
					pen.action = PEN_UP;
					break;
				}
				if(!IsNull(DoMouse(PEN, p, 0)))
					return 0L;
				break;
			}
		}
		break;
...

#define PEN_MOVE 0

/home/buildbot/worker/l-upp/build/uppsrc/CtrlCore/GtkEvent.cpp:429:6: error: no viable overloaded '='
        pen = CurrentEvent.pen;
        ~~~ ^ ~~~~~~~~~~~~~~~~

/home/buildbot/worker/al-upp/build/uppsrc/CtrlCore/GtkEvent.cpp:430:2: error: use of undeclared identifier 'pen_barrel'
        pen_barrel = CurrentEvent.pen_barrel;
        ^
/home/buildbot/worker/al-upp/build/uppsrc/CtrlCore/GtkEvent.cpp:431:2: error: use of undeclared identifier 'pen_inverted'
        pen_inverted = CurrentEvent.pen_inverted;
        ^
/home/buildbot/worker/al-upp/build/uppsrc/CtrlCore/GtkEvent.cpp:432:2: error: use of undeclared identifier 'pen_eraser'
        pen_eraser = CurrentEvent.pen_eraser;
        ^
/home/buildbot/worker/al-upp/build/uppsrc/CtrlCore/GtkEvent.cpp:433:2: error: use of undeclared identifier 'pen_pressure'
        pen_pressure = CurrentEvent.pen_pressure;
        ^
/home/buildbot/worker/al-upp/build/uppsrc/CtrlCore/GtkEvent.cpp:434:2: error: use of undeclared identifier 'pen_rotation'
        pen_rotation = CurrentEvent.pen_rotation;
        ^
/home/buildbot/worker/al-upp/build/uppsrc/CtrlCore/GtkEvent.cpp:435:2: error: use of undeclared identifier 'pen_tilt'
        pen_tilt = CurrentEvent.pen_tilt;
        ^

bool GetPenDown(); // << ADD THIS
... AND ...
class RectTracker : public LocalLoop {
public:
	virtual void  LeftUp(Point, dword);
	virtual void  RightUp(Point, dword);
	virtual void  MouseMove(Point p, dword);
	virtual bool  Pen(Point p, const PenInfo& pn, dword keyflags); // << ADD THIS

...
	if(findarg(e, LEFTUP, RIGHTUP, MIDDLEUP) >= 0)
		KillRepeat();
	Image result = DispatchMouseEvent(e, p, zd);
	if(!GetMouseRight() && !GetMouseMiddle() && !GetMouseLeft() && !GetPenDown())
		ReleaseCtrlCapture();
	return result;
...

bool RectTracker::Pen(Point p, const PenInfo& pn, dword keyflags){
	switch(pn.action){
		case 0:
			MouseMove(p,keyflags);
			break;
		case PEN_UP:
			EndLoop();
			break;
	}
	return true;
}

...
bool Ctrl::ProcessEvent(bool *quit)
{
	ASSERT_(IsMainThread(), "ProcessEvent can only run in the main thread");
	if(!GetMouseLeft() && !GetMouseRight() && !GetMouseMiddle() && !GetPenDown()) // << HERE
		ReleaseCtrlCapture();
...

	bool Pen(Point p, const PenInfo& pn, dword keyflags) override {
		if(keyflags & K_SHIFT)
			return false;
		if(pn.pressure) {
			if((!!pn.pressure == !!pen.pressure) && drawing.GetCount())
				drawing.Top().Add(MakeTuple(pn.pressure, p));
			else
				drawing.Add().Add(MakeTuple(pn.pressure, p));
		}
		pen = pn;
		Refresh();
		return true;
	}
	
	void LeftDown(Point p, dword keyflags) override {
		if(keyflags & K_SHIFT) {
			RectTracker tracker(*this);
			tracker.MinSize(Size(-100000,-100000));
			tracker.Track(Rect(p,p));
		}
	}