@ycheung5/pi-computer-use 0.0.0-stage → 0.1.0

package/assets/controls.cs

@@ -0,0 +1,249 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+using System.Runtime.InteropServices;
+using System.Windows.Automation;
+
+partial class WindowsBridge {
+  [StructLayout(LayoutKind.Sequential)] struct ControlPoint { public int X,Y; }
+  [StructLayout(LayoutKind.Sequential)] struct ControlGuiInfo { public uint Size,Flags; public IntPtr Active,Focus,Capture,MenuOwner,MoveSize,Caret; public Rect CaretRect; }
+  [DllImport("user32.dll")] static extern bool GetCursorPos(out ControlPoint point);
+  [DllImport("user32.dll",EntryPoint="GetWindowLongPtrW")] static extern IntPtr ControlStyle(IntPtr window,int index);
+  [DllImport("user32.dll")] static extern IntPtr GetWindow(IntPtr window,uint command);
+  [DllImport("user32.dll")] static extern bool GetGUIThreadInfo(uint thread,ref ControlGuiInfo info);
+  [DllImport("user32.dll",EntryPoint="PostMessageW",SetLastError=true)] static extern bool ControlPost(IntPtr window,uint message,IntPtr wParam,IntPtr lParam);
+  [DllImport("user32.dll",EntryPoint="SendMessageTimeoutW",CharSet=CharSet.Unicode,SetLastError=true)] static extern IntPtr ControlText(IntPtr window,uint message,UIntPtr wParam,string text,uint flags,uint timeout,out UIntPtr result);
+  [DllImport("user32.dll")] static extern int GetScrollPos(IntPtr window,int bar);
+
+  // Shared in-process observer: never calls UIA and never captures text.
+  // Tagged agent input and physically suppressed input are excluded.
+  // Foreign injected input still invalidates the action and restoration.
+  static readonly UIntPtr OwnedInputMarker=new UIntPtr(0x50494355);
+  sealed class InteractionGuard {
+    delegate IntPtr Hook(int code,IntPtr message,IntPtr data);
+    [StructLayout(LayoutKind.Sequential)] struct Mouse {public ControlPoint Point;public uint Data,Flags,Time;public UIntPtr Extra;}
+    [StructLayout(LayoutKind.Sequential)] struct Key {public uint Code,Scan,Flags,Time;public UIntPtr Extra;}
+    [StructLayout(LayoutKind.Sequential)] struct Message {public IntPtr Window;public uint Id;public UIntPtr W;public IntPtr L;public uint Time;public ControlPoint Point;public uint Private;}
+    [DllImport("user32.dll",SetLastError=true)] static extern IntPtr SetWindowsHookEx(int kind,Hook callback,IntPtr module,uint thread);
+    [DllImport("user32.dll")] static extern bool UnhookWindowsHookEx(IntPtr hook);
+    [DllImport("user32.dll")] static extern IntPtr CallNextHookEx(IntPtr hook,int code,IntPtr message,IntPtr data);
+    [DllImport("user32.dll")] static extern int GetMessage(out Message message,IntPtr window,uint first,uint last);
+    [DllImport("user32.dll")] static extern bool TranslateMessage(ref Message message);
+    [DllImport("user32.dll")] static extern IntPtr DispatchMessage(ref Message message);
+    [DllImport("kernel32.dll",CharSet=CharSet.Unicode)] static extern IntPtr GetModuleHandle(string name);
+    static readonly object gate=new object();
+    static readonly ManualResetEvent ready=new ManualResetEvent(false);
+    static readonly Hook mouseCallback=OnMouse,keyCallback=OnKey;
+    static bool started;static volatile bool available;static long activity;
+    readonly long baseline;
+    readonly bool requiresProtection;
+    static EventWaitHandle protection,cancellation;
+    static Process protector;
+    static string protectionName;
+    static bool Protected() {lock(gate)return protection!=null && !protector.HasExited && protection.WaitOne(0);}
+    static IntPtr OnMouse(int code,IntPtr message,IntPtr data) {
+      IntPtr consumed=CallNextHookEx(IntPtr.Zero,code,message,data);
+      if(code>=0) {
+        Mouse input=(Mouse)Marshal.PtrToStructure(data,typeof(Mouse));bool ours=(input.Flags & 1)!=0 && input.Extra==OwnedInputMarker;
+        if((input.Flags & 1)==0 && consumed!=IntPtr.Zero && Protected())ours=true;
+        if(!ours)Interlocked.Increment(ref activity);
+      }
+      return consumed;
+    }
+    static IntPtr OnKey(int code,IntPtr message,IntPtr data) {
+      IntPtr consumed=CallNextHookEx(IntPtr.Zero,code,message,data);
+      if(code>=0){Key input=(Key)Marshal.PtrToStructure(data,typeof(Key));if(!((input.Flags & 0x10)!=0 && input.Extra==OwnedInputMarker) && !((input.Flags & 0x10)==0 && consumed!=IntPtr.Zero && Protected()))Interlocked.Increment(ref activity);}
+      return consumed;
+    }
+    static void Ensure() {
+      lock(gate)if(!started){started=true;Thread thread=new Thread(delegate(){
+        IntPtr mouse=SetWindowsHookEx(14,mouseCallback,GetModuleHandle(null),0),key=SetWindowsHookEx(13,keyCallback,GetModuleHandle(null),0);
+        available=mouse!=IntPtr.Zero && key!=IntPtr.Zero;ready.Set();
+        try {if(available){Message message;while(GetMessage(out message,IntPtr.Zero,0,0)>0){TranslateMessage(ref message);DispatchMessage(ref message);}}}
+        finally {available=false;if(mouse!=IntPtr.Zero)UnhookWindowsHookEx(mouse);if(key!=IntPtr.Zero)UnhookWindowsHookEx(key);}
+      });thread.IsBackground=true;thread.Start();}
+      if(!ready.WaitOne(1000) || !available)throw new InvalidOperationException("USER_ACTIVITY_OBSERVER_UNAVAILABLE: no input sent");
+    }
+    public InteractionGuard(string cancelName="",int listenerPid=0){
+      if(cancelName.Length>0)lock(gate){
+        if(protectionName!=cancelName){
+          EventWaitHandle next=EventWaitHandle.OpenExisting(cancelName+"-exclusive");
+          EventWaitHandle nextCancellation=null;Process nextProcess=null;
+          try {nextCancellation=EventWaitHandle.OpenExisting(cancelName);nextProcess=Process.GetProcessById(listenerPid);IntPtr identity=nextProcess.Handle;}
+          catch{next.Dispose();if(nextCancellation!=null)nextCancellation.Dispose();if(nextProcess!=null)nextProcess.Dispose();throw;}
+          if(protection!=null)protection.Dispose();if(cancellation!=null)cancellation.Dispose();if(protector!=null)protector.Dispose();
+          protection=next;cancellation=nextCancellation;protector=nextProcess;protectionName=cancelName;
+        }
+        requiresProtection=true;
+      }
+      Ensure();baseline=Interlocked.Read(ref activity);
+    }
+    public bool Undisturbed {get {return available && (!requiresProtection || Protected()) && baseline==Interlocked.Read(ref activity);}}
+    public void Check(){if(requiresProtection && cancellation.WaitOne(0))throw new InvalidOperationException("COMPUTER_USE_STOPPED");if(requiresProtection && !Protected())throw new InvalidOperationException("EXCLUSIVE_CONTROL_LOST: no further input");if(!Undisturbed)throw new InvalidOperationException("USER_INPUT_CHANGED: intervening input stopped automation");}
+    public static bool Move(int x,int y) {
+      int left=GetSystemMetrics(76),top=GetSystemMetrics(77),width=GetSystemMetrics(78),height=GetSystemMetrics(79);
+      if(width<=0 || height<=0 || x<left || x>=left+width || y<top || y>=top+height)return false;
+      PointerInput input=new PointerInput {Type=0,Data=new InputUnion {Mouse=new MouseInput {
+        // Choose the first normalized coordinate for the pixel, not its midpoint:
+        // Windows can round the midpoint into the next physical pixel.
+        X=Math.Max(1,(int)(((long)(x-left)*65536+width-1)/width)),Y=Math.Max(1,(int)(((long)(y-top)*65536+height-1)/height)),
+        Flags=0xC001,Extra=OwnedInputMarker}}};
+      ControlPoint observed;
+      return SendInput(1,new PointerInput[]{input},Marshal.SizeOf(typeof(PointerInput)))==1 && GetCursorPos(out observed) && observed.X==x && observed.Y==y;
+    }
+  }
+
+  static HashSet<long> ControlPopups(uint owner,IntPtr target) {
+    HashSet<long> found=new HashSet<long>();
+    EnumWindows(delegate(IntPtr window,IntPtr ignored) { if(window!=target && IsWindowVisible(window) && WindowOwner(window)==owner && (GetWindow(window,4)!=IntPtr.Zero || (ControlStyle(window,-16).ToInt64() & 0x80000000L)!=0))found.Add(window.ToInt64());return true; },IntPtr.Zero);
+    return found;
+  }
+  static void RestoreControlState(Dictionary<string,object> result,IntPtr before,ControlPoint pointer,IntPtr window,HashSet<long> popups,bool keep,InteractionGuard interaction) {
+    ControlPoint now;
+    result["pointer"]=GetCursorPos(out now) && now.X==pointer.X && now.Y==pointer.Y?"unchanged":"left: movement was not proven to be ours";
+    if(!CurrentReferenceIntact()){result["foreground"]="left: lifetime proof lost";return;}
+    IntPtr after=GetForegroundWindow();
+    if(after==before){result["foreground"]="unchanged";return;}
+    if(window==IntPtr.Zero || after!=window){result["foreground"]="left: another window is in front";return;}
+    if(keep){result["foreground"]="kept (activate:true)";return;}
+    if(interaction==null || !interaction.Undisturbed){result["foreground"]="left: user activity or unavailable movement evidence";return;}
+    uint ignoredOwner;uint thread=GetWindowThreadProcessId(window,out ignoredOwner);
+    ControlGuiInfo info=new ControlGuiInfo {Size=(uint)Marshal.SizeOf(typeof(ControlGuiInfo))};
+    bool menu=GetGUIThreadInfo(thread,ref info) && (info.Flags & 0x1C)!=0;
+    HashSet<long> opened=ControlPopups(WindowOwner(window),window);opened.ExceptWith(popups);
+    if(menu || opened.Count>0){result["foreground"]="kept: action opened menu or dialog";return;}
+    if(before!=IntPtr.Zero && IsWindow(before) && interaction.Undisturbed && SetForegroundWindow(before))result["foreground"]="returned (provider activated intended target)";
+    else result["foreground"]="kept: restoration refused or prior window disappeared";
+  }
+  static bool NativeButton(AutomationElement element) {
+    IntPtr handle=new IntPtr(element.Current.NativeWindowHandle);if(handle==IntPtr.Zero)return false;
+    string name=element.Current.ClassName;
+    bool button=element.Current.ControlType==ControlType.Button || element.Current.ControlType==ControlType.CheckBox || element.Current.ControlType==ControlType.RadioButton;
+    if(!button || !(name.Equals("Button",StringComparison.OrdinalIgnoreCase) || name.StartsWith("WindowsForms10.BUTTON",StringComparison.OrdinalIgnoreCase)))return false;
+    BeginWindowDispatch();
+    if(!ControlPost(handle,0xF5,IntPtr.Zero,IntPtr.Zero))throw new InvalidOperationException("NATIVE_DISPATCH_FAILED: button message was refused");
+    UIntPtr ignored;SendMessageTimeout(handle,0,UIntPtr.Zero,IntPtr.Zero,2,500,out ignored);return true;
+  }
+  static bool NativeValue(AutomationElement element,string value) {
+    IntPtr handle=new IntPtr(element.Current.NativeWindowHandle);if(handle==IntPtr.Zero || element.Current.ControlType!=ControlType.Edit)return false;
+    string name=element.Current.ClassName;
+    if(!(name.Equals("Edit",StringComparison.OrdinalIgnoreCase) || name.StartsWith("WindowsForms10.EDIT",StringComparison.OrdinalIgnoreCase) || name.StartsWith("RichEdit",StringComparison.OrdinalIgnoreCase)))return false;
+    if((ControlStyle(handle,-16).ToInt64() & 0x800)!=0)throw new InvalidOperationException("READ_ONLY: control does not accept value changes");
+    UIntPtr ignored;
+    BeginWindowDispatch();
+    if(SendMessageTimeout(handle,0xB1,UIntPtr.Zero,new IntPtr(-1),2,500,out ignored)==IntPtr.Zero)throw new InvalidOperationException("NATIVE_DISPATCH_FAILED: edit selection was not confirmed");
+    BeginWindowDispatch();
+    if(ControlText(handle,0xC2,new UIntPtr(1),value,2,1000,out ignored)==IntPtr.Zero)throw new InvalidOperationException("NATIVE_DISPATCH_FAILED: edit message was not confirmed");
+    return true;
+  }
+  static Dictionary<string,object> ScrollPosition(IntPtr handle) {return new Dictionary<string,object>{{"vertical",GetScrollPos(handle,1)},{"horizontal",GetScrollPos(handle,0)}};}
+  // Match the reference's Windows wheel-lines setting and midpoint-to-even
+  // rounding and line-mode cap. Page mode retains reference step semantics;
+  // the stop lease is checked between calls rather than pretending a step cap
+  // bounds a synchronous provider call.
+  static int ScrollSteps(int delta,int lines,bool byPage) {
+    if(delta==0)return 0;
+    double scaled=Math.Abs((double)delta)*(byPage?1.0:lines)/120.0;
+    return (int)(byPage?Math.Max(1,Math.Round(scaled)):Math.Min(100,Math.Max(1,Math.Round(scaled))));
+  }
+  static bool NativeScroll(AutomationElement element,int x,int y,int countX,int countY,bool byPage,Dictionary<string,object> result,Action check) {
+    IntPtr handle=new IntPtr(element.Current.NativeWindowHandle);if(handle==IntPtr.Zero)return false;
+    long style=ControlStyle(handle,-16).ToInt64();
+    if((y!=0 && (style & 0x200000)==0) || (x!=0 && (style & 0x100000)==0))return false;
+    result["before"]=ScrollPosition(handle);
+    foreach(int axis in new int[]{1,0}) {
+      int delta=axis==0?x:y;if(delta==0)continue;
+      uint message=axis==0?0x114U:0x115U;int count=axis==0?countX:countY;
+      uint command=(delta>0?1U:0U)+(byPage?2U:0U);
+      for(int step=0;step<count;step++) { check();BeginWindowDispatch();UIntPtr dispatched;if(SendMessageTimeout(handle,message,new UIntPtr(command),IntPtr.Zero,2,500,out dispatched)==IntPtr.Zero)throw new InvalidOperationException("NATIVE_DISPATCH_UNCONFIRMED: scroll handler did not complete; observe before retrying");check(); }
+      check();BeginWindowDispatch();UIntPtr completed;SendMessageTimeout(handle,message,new UIntPtr(8),IntPtr.Zero,2,500,out completed);
+    }
+    UIntPtr ignored;SendMessageTimeout(handle,0,UIntPtr.Zero,IntPtr.Zero,2,500,out ignored);
+    result["after"]=ScrollPosition(handle);result["method"]="native_scroll";return true;
+  }
+  static void ControlScroll(AutomationElement element,IntPtr window,int x,int y,Dictionary<string,object> result,Action check) {
+    int lines=System.Windows.Forms.SystemInformation.MouseWheelScrollLines;
+    bool byPage=lines<0;int countX=ScrollSteps(x,lines,byPage),countY=ScrollSteps(y,lines,byPage);
+    AutomationElement candidate=element;
+    for(int level=0;candidate!=null && level<64;level++) {
+      check();if(candidate.Current.ProcessId!=(int)WindowOwner(window))break;
+      if(NativeScroll(candidate,x,y,countX,countY,byPage,result,check))return;
+      object raw;
+      if(candidate.TryGetCurrentPattern(ScrollPattern.Pattern,out raw)) {
+        ScrollPattern scroll=(ScrollPattern)raw;
+        if((x==0 || scroll.Current.HorizontallyScrollable) && (y==0 || scroll.Current.VerticallyScrollable)) {
+          result["before"]=new Dictionary<string,object>{{"vertical",scroll.Current.VerticalScrollPercent},{"horizontal",scroll.Current.HorizontalScrollPercent}};
+          ScrollAmount vertical=y>0?(byPage?ScrollAmount.LargeIncrement:ScrollAmount.SmallIncrement):(byPage?ScrollAmount.LargeDecrement:ScrollAmount.SmallDecrement);
+          ScrollAmount horizontal=x>0?(byPage?ScrollAmount.LargeIncrement:ScrollAmount.SmallIncrement):(byPage?ScrollAmount.LargeDecrement:ScrollAmount.SmallDecrement);
+          for(int step=0;step<countY;step++){check();BeginWindowDispatch();scroll.Scroll(ScrollAmount.NoAmount,vertical);check();}
+          for(int step=0;step<countX;step++){check();BeginWindowDispatch();scroll.Scroll(horizontal,ScrollAmount.NoAmount);check();}
+          result["after"]=new Dictionary<string,object>{{"vertical",scroll.Current.VerticalScrollPercent},{"horizontal",scroll.Current.HorizontalScrollPercent}};result["method"]="uia_scroll";return;
+        }
+      }
+      candidate=TreeWalker.ControlViewWalker.GetParent(candidate);
+    }
+    throw new InvalidOperationException("WCU_NEEDS_INPUT: no background scrolling pattern is available");
+  }
+  static object ExecuteControl(string action,Dictionary<string,object> args) {
+    Dictionary<string,object> result=Result(true,action);
+    IntPtr before=IntPtr.Zero,window=IntPtr.Zero;ControlPoint pointer=new ControlPoint();
+    AutomationElement element=null;HashSet<long> popups=new HashSet<long>();InteractionGuard interaction=null;
+    EventWaitHandle cancel=null;Process listener=null;bool quietScroll=action=="scroll" && Option(args,"_quietScroll",false);
+    Action check=delegate {CheckReferenceBeforeDispatch();if(cancel!=null && (cancel.WaitOne(0) || listener.HasExited))throw new InvalidOperationException("COMPUTER_USE_STOPPED: in-flight app effects cannot be undone; observe before further input");};
+    try {
+      if(quietScroll) {
+        listener=Process.GetProcessById(NumberOption(args,"_stopProcessId",0));IntPtr identity=listener.Handle;
+        cancel=EventWaitHandle.OpenExisting(TextOption(args,"_cancelEvent",""));check();
+      }
+      interaction=new InteractionGuard();before=GetForegroundWindow();GetCursorPos(out pointer);
+      PruneElements();element=ResolveObservedElement(TextOption(args,"elementId",""),args,out window);popups=ControlPopups(WindowOwner(window),window);
+      if(!element.Current.IsEnabled)throw new InvalidOperationException("ELEMENT_DISABLED: control is disabled");
+      ApplyVisibleIntent(args,window);
+      if(Option(args,"activate",false) && !ManagementActivate(window,WindowOwner(window)))throw new InvalidOperationException("TARGET_ACTIVATION_REFUSED: Windows did not grant foreground access");
+      object raw;check();
+      if(action=="focus") {ForgetTextFocus();BeginWindowDispatch();element.SetFocus();RememberTextFocus(window,new IntPtr(element.Current.NativeWindowHandle));result["method"]="uia_focus";}
+      else if(action=="set_value") {
+        if(element.TryGetCurrentPattern(ValuePattern.Pattern,out raw) && ((ValuePattern)raw).Current.IsReadOnly)throw new InvalidOperationException("READ_ONLY: control does not accept value changes");
+        if(NativeValue(element,TextOption(args,"value","")))result["method"]="native_edit";
+        else if(element.TryGetCurrentPattern(ValuePattern.Pattern,out raw)) {BeginWindowDispatch();((ValuePattern)raw).SetValue(TextOption(args,"value",""));result["method"]="uia_value";}
+        else throw new InvalidOperationException(Option(args,"fallbackType",true)?"WCU_NEEDS_INPUT: value pattern unavailable; guarded typing required":"UNSUPPORTED_PATTERN: value pattern unavailable");
+      } else if(action=="scroll") ControlScroll(element,window,NumberOption(args,"deltaX",0),NumberOption(args,"deltaY",480),result,check);
+      else {
+        string requested=TextOption(args,"action","default");
+        if(requested=="scroll_into_view") {if(!element.TryGetCurrentPattern(ScrollItemPattern.Pattern,out raw))throw new InvalidOperationException("UNSUPPORTED_PATTERN: ScrollItem unavailable");BeginWindowDispatch();((ScrollItemPattern)raw).ScrollIntoView();result["method"]="uia_scroll_into_view";}
+        else if(requested=="expand" || requested=="collapse") {if(!element.TryGetCurrentPattern(ExpandCollapsePattern.Pattern,out raw))throw new InvalidOperationException("UNSUPPORTED_PATTERN: ExpandCollapse unavailable");ExpandCollapsePattern expand=(ExpandCollapsePattern)raw;ExpandCollapseState desired=requested=="expand"?ExpandCollapseState.Expanded:ExpandCollapseState.Collapsed;if(expand.Current.ExpandCollapseState!=desired){BeginWindowDispatch();if(requested=="expand")expand.Expand();else expand.Collapse();}result["method"]="uia_"+requested;}
+        else if(NativeButton(element))result["method"]="native_button";
+        else if(element.TryGetCurrentPattern(InvokePattern.Pattern,out raw)){BeginWindowDispatch();((InvokePattern)raw).Invoke();result["method"]="uia_invoke";}
+        else if(element.TryGetCurrentPattern(TogglePattern.Pattern,out raw)){BeginWindowDispatch();((TogglePattern)raw).Toggle();result["method"]="uia_toggle";}
+        else if(element.TryGetCurrentPattern(SelectionItemPattern.Pattern,out raw)){BeginWindowDispatch();((SelectionItemPattern)raw).Select();result["method"]="uia_select";}
+        else if(element.TryGetCurrentPattern(ExpandCollapsePattern.Pattern,out raw)){BeginWindowDispatch();((ExpandCollapsePattern)raw).Expand();result["method"]="uia_expand";}
+        else {
+          // A semantic invoke is not permission to bypass a read-only control.
+          // The pointer click path has no semantic action option and can still
+          // select/focus read-only text with its ordinary click contract.
+          if(args.ContainsKey("action") && element.TryGetCurrentPattern(ValuePattern.Pattern,out raw) && ((ValuePattern)raw).Current.IsReadOnly)throw new InvalidOperationException("READ_ONLY: semantic invoke cannot escalate on a read-only control");
+          throw new InvalidOperationException(Option(args,"fallbackClick",true)?"WCU_NEEDS_INPUT: no supported background action; guarded click required":"UNSUPPORTED_PATTERN: no supported background action");
+        }
+      }
+      result["inputTargetHandle"]=window.ToInt64();result["inputTargetProcessId"]=WindowOwner(window);
+      result["verification"]="sent";result["verificationNote"]="Action dispatched; use a fresh observation or explicit wait to verify its effect.";
+    } catch(Exception error) {
+      result["ok"]=false;
+      if(error is ElementNotAvailableException || error.HResult==unchecked((int)0x80040201)) {observed.Remove(TextOption(args,"elementId",""));result["error"]="STALE_ELEMENT: control disappeared; observe again";}
+      else result["error"]=error.Message;
+      if(error.Message.StartsWith("WCU_NEEDS_INPUT",StringComparison.Ordinal))result["inputRequired"]=true;
+    }
+    finally {
+      try {
+        if(cancel!=null && (cancel.WaitOne(0) || listener.HasExited)) {result["pointer"]="unchanged";result["foreground"]="left: operation stopped";}
+        else RestoreControlState(result,before,pointer,window,popups,Option(args,"activate",false),interaction);
+      } finally {if(cancel!=null)cancel.Dispose();if(listener!=null)listener.Dispose();}
+      // This acknowledges settlement of synchronous native/UIA calls, never
+      // reversal of a previously dispatched app effect. Quiet scroll holds no
+      // physical key/button and never announces physical input presentation.
+      if(quietScroll)result["cleanupConfirmed"]=true;
+    }
+    return result;
+  }
+}

package/assets/indicators.cs

@@ -0,0 +1,252 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+
+partial class StopBridge {
+  class IndicatorWindow : Form {
+    readonly bool frame;
+    [StructLayout(LayoutKind.Sequential)] struct LayerPoint { public int X,Y; }
+    [StructLayout(LayoutKind.Sequential)] struct LayerSize { public int Width,Height; }
+    [StructLayout(LayoutKind.Sequential,Pack=1)] struct BlendFunction { public byte Operation,Flags,Alpha,Format; }
+    [DllImport("gdi32.dll",SetLastError=true)] static extern IntPtr CreateCompatibleDC(IntPtr dc);
+    [DllImport("gdi32.dll",SetLastError=true)] static extern IntPtr SelectObject(IntPtr dc,IntPtr value);
+    [DllImport("gdi32.dll",SetLastError=true)] static extern bool DeleteObject(IntPtr value);
+    [DllImport("gdi32.dll",SetLastError=true)] static extern bool DeleteDC(IntPtr dc);
+    [DllImport("user32.dll",SetLastError=true)] static extern bool UpdateLayeredWindow(IntPtr window,IntPtr screen,ref LayerPoint destination,ref LayerSize size,IntPtr source,ref LayerPoint origin,uint colorKey,ref BlendFunction blend,uint flags);
+    IntPtr frameDc,frameBitmap,framePrevious;
+    public bool IsFrame {get{return frame;}}
+    public string FrameError="";
+    public string Caption="";
+    public float DpiScale=1;
+    public IndicatorWindow(bool isFrame) {
+      frame=isFrame;FormBorderStyle=FormBorderStyle.None;ShowInTaskbar=false;TopMost=true;
+      StartPosition=FormStartPosition.Manual;AutoScaleMode=AutoScaleMode.None;
+      BackColor=Color.FromArgb(20,44,70);ForeColor=Color.White;Enabled=false;
+      SetStyle(ControlStyles.AllPaintingInWmPaint|ControlStyles.OptimizedDoubleBuffer|ControlStyles.UserPaint,true);
+    }
+    protected override bool ShowWithoutActivation { get { return true; } }
+    protected override CreateParams CreateParams { get { CreateParams value=base.CreateParams;value.ExStyle|=0x08000000|0x00000080|0x00000020|0x00080000;return value; } }
+    public void LayoutAt(Rectangle bounds,float scale) {
+      if(Bounds==bounds && DpiScale==scale)return;
+      DpiScale=scale;Bounds=bounds;
+      if(frame)BuildFrame();
+      Invalidate();
+    }
+    void ReleaseFrame() {
+      if(frameDc!=IntPtr.Zero) {if(framePrevious!=IntPtr.Zero)SelectObject(frameDc,framePrevious);if(frameBitmap!=IntPtr.Zero)DeleteObject(frameBitmap);DeleteDC(frameDc);}
+      else if(frameBitmap!=IntPtr.Zero)DeleteObject(frameBitmap);
+      frameDc=IntPtr.Zero;frameBitmap=IntPtr.Zero;framePrevious=IntPtr.Zero;
+    }
+    void BuildFrame() {
+      ReleaseFrame();FrameError="";
+      if(Width<2 || Height<2){FrameError="Indicator frame has invalid dimensions";return;}
+      try {
+      using(Bitmap image=new Bitmap(Width,Height,System.Drawing.Imaging.PixelFormat.Format32bppPArgb)) {
+        using(Graphics graphics=Graphics.FromImage(image)) {
+        graphics.Clear(Color.Transparent);
+        graphics.CompositingMode=System.Drawing.Drawing2D.CompositingMode.SourceCopy;
+        float scale=Math.Max(1f,Math.Min(2f,Width/1920f));
+        int core=(int)Math.Round(3*scale),glow=core+(int)Math.Round(27*scale);
+        for(int inset=0;inset<glow && Width-2*inset>1 && Height-2*inset>1;inset++) {
+          Color color=inset<core?Color.FromArgb(235,150,184,255):Color.FromArgb((int)(175*Math.Pow(1-(inset-core)/(double)(glow-core),2.2)),77,124,254);
+          using(Pen pen=new Pen(color,1))graphics.DrawRectangle(pen,inset,inset,Width-2*inset-1,Height-2*inset-1);
+        }
+        }
+        frameBitmap=image.GetHbitmap(Color.FromArgb(0));
+      }
+      frameDc=CreateCompatibleDC(IntPtr.Zero);
+      if(frameDc==IntPtr.Zero){FrameError="Indicator frame DC creation failed: "+Marshal.GetLastWin32Error();ReleaseFrame();return;}
+      framePrevious=SelectObject(frameDc,frameBitmap);
+      if(framePrevious==IntPtr.Zero || framePrevious==new IntPtr(-1)){FrameError="Indicator frame bitmap selection failed: "+Marshal.GetLastWin32Error();framePrevious=IntPtr.Zero;ReleaseFrame();}
+      } catch(Exception error) {FrameError="Indicator frame preparation failed: "+error.Message;ReleaseFrame();}
+    }
+    public bool PresentFrame() {
+      if(!frame || frameDc==IntPtr.Zero)return false;
+      LayerPoint destination=new LayerPoint{X=Left,Y=Top},origin=new LayerPoint();
+      LayerSize size=new LayerSize{Width=Width,Height=Height};
+      BlendFunction blend=new BlendFunction{Operation=0,Flags=0,Alpha=255,Format=1};
+      bool presented=UpdateLayeredWindow(Handle,IntPtr.Zero,ref destination,ref size,frameDc,ref origin,0,ref blend,2);
+      if(!presented)FrameError="Indicator frame presentation failed: "+Marshal.GetLastWin32Error();
+      else FrameError="";
+      return presented;
+    }
+    protected override void OnPaint(PaintEventArgs e) {
+      if(frame)return;
+      using(Pen pen=new Pen(Color.FromArgb(62,156,255),Math.Max(1,2*DpiScale)))e.Graphics.DrawRectangle(pen,1,1,Width-3,Height-3);
+      using(Font font=new Font("Segoe UI",Math.Max(9,10*DpiScale),FontStyle.Bold,GraphicsUnit.Point))
+        TextRenderer.DrawText(e.Graphics,Caption,font,ClientRectangle,ForeColor,TextFormatFlags.HorizontalCenter|TextFormatFlags.VerticalCenter|TextFormatFlags.EndEllipsis|TextFormatFlags.NoPrefix);
+    }
+    protected override void Dispose(bool disposing) {if(disposing)ReleaseFrame();base.Dispose(disposing);}
+
+  }
+  class Presentation : IDisposable {
+    [StructLayout(LayoutKind.Sequential)] struct Point { public int X,Y; }
+    [StructLayout(LayoutKind.Sequential)] struct CursorInfo { public int Size,Flags;public IntPtr Cursor;public Point Position; }
+    [StructLayout(LayoutKind.Sequential)] struct IconInfo { public bool Icon;public uint HotX,HotY;public IntPtr Mask,Color; }
+    [StructLayout(LayoutKind.Sequential)] struct BitmapInfo { public int Type,Width,Height,WidthBytes;public ushort Planes,BitsPixel;public IntPtr Bits; }
+    [DllImport("user32.dll")] static extern bool EnableWindow(IntPtr window,bool enabled);
+    [DllImport("user32.dll")] static extern bool SetLayeredWindowAttributes(IntPtr window,uint key,byte alpha,uint flags);
+    [DllImport("user32.dll")] static extern bool SetWindowDisplayAffinity(IntPtr window,uint affinity);
+    [DllImport("user32.dll")] static extern IntPtr MonitorFromPoint(Point point,uint flags);
+    [DllImport("shcore.dll")] static extern int GetDpiForMonitor(IntPtr monitor,int type,out uint x,out uint y);
+    [DllImport("user32.dll")] static extern bool GetCursorInfo(ref CursorInfo info);
+    [DllImport("user32.dll")] static extern bool GetIconInfo(IntPtr icon,out IconInfo info);
+    [DllImport("gdi32.dll",CharSet=CharSet.Unicode)] static extern int GetObject(IntPtr value,int bytes,out BitmapInfo info);
+    [DllImport("gdi32.dll")] static extern bool DeleteObject(IntPtr value);
+    [DllImport("user32.dll")] static extern IntPtr WindowFromPoint(Point point);
+    [DllImport("user32.dll")] static extern uint GetWindowThreadProcessId(IntPtr window,out uint process);
+    readonly System.Windows.Forms.Timer timer;
+    readonly List<IndicatorWindow> frames=new List<IndicatorWindow>();
+    readonly List<IndicatorWindow> bars=new List<IndicatorWindow>();
+    IndicatorWindow pointer;
+    bool screenEnabled=true,pointerEnabled=true,remoteVisible=true,held,suspended,preview,renderChecked;
+    int captureSuspensions;
+    string previewPath;
+    bool? affinityApplied=null;
+    string caption="Pi is controlling the computer",position="top",layoutKey="";
+    int endDelay=800;
+    DateTime previewUntil=DateTime.MinValue,lastLayout=DateTime.MinValue;
+    public Presentation() {
+      timer=new System.Windows.Forms.Timer { Interval=40 };
+      timer.Tick+=delegate { Tick(); };timer.Start();
+    }
+    static bool Switch(Dictionary<string,object> values,string name,bool fallback) { object value;return values.TryGetValue(name,out value)?Convert.ToBoolean(value):fallback; }
+    public void Configure(Dictionary<string,object> values) {
+      screenEnabled=Switch(values,"indicatorEnabled",true);pointerEnabled=Switch(values,"cursorIndicatorEnabled",true);remoteVisible=Switch(values,"remoteIndicatorVisible",true);
+      object value;caption=values.TryGetValue("indicatorText",out value)?Convert.ToString(value):"Pi is controlling the computer";
+      position=values.TryGetValue("indicatorPosition",out value)?Convert.ToString(value):"top";
+      endDelay=values.TryGetValue("indicatorIdleMs",out value)?Convert.ToInt32(value):800;
+      layoutKey="";Refresh();
+    }
+    public void Begin() {
+      held=true;preview=false;Refresh();
+      if(!BorderReady)throw new InvalidOperationException("EXCLUSIVE_CONTROL_UNAVAILABLE: control border failed");
+    }
+    public bool BorderReady {get {return held && (suspended || (frames.Count>0 && frames.TrueForAll(frame=>frame.Visible && frame.FrameError.Length==0)));}}
+    public void Stop() { held=false;preview=false;Hide(); }
+    public void Suspend(bool value) { if(value)captureSuspensions++;suspended=value;Refresh(); }
+    public void Preview(bool show) {
+      if(!show) {
+        using(IndicatorWindow sample=new IndicatorWindow(false))
+        using(Bitmap pixels=new Bitmap(320,42)) {
+          sample.Caption=caption+"  ·  Esc to stop";sample.LayoutAt(new Rectangle(0,0,320,42),1);sample.DrawToBitmap(pixels,new Rectangle(0,0,320,42));
+          if(previewPath!=null)try{System.IO.File.Delete(previewPath);}catch(System.IO.IOException){}
+          previewPath=System.IO.Path.Combine(System.IO.Path.GetTempPath(),"pi-cu-indicator-preview-"+Guid.NewGuid().ToString("N")+".png");
+          pixels.Save(previewPath,System.Drawing.Imaging.ImageFormat.Png);
+          renderChecked=true;
+        }
+        return;
+      }
+      preview=true;previewUntil=DateTime.UtcNow.AddMilliseconds(2000);Refresh();
+    }
+    bool Wanted() { return !suspended && (held || preview); }
+    static float MonitorScale(Screen screen) {
+      uint x,y;
+      try {
+        IntPtr monitor=MonitorFromPoint(new Point {X=screen.Bounds.Left+screen.Bounds.Width/2,Y=screen.Bounds.Top+screen.Bounds.Height/2},2);
+        if(GetDpiForMonitor(monitor,0,out x,out y)==0 && x>=48 && x<=768)return x/96f;
+      } catch(EntryPointNotFoundException) { } catch(DllNotFoundException) { }
+      return 1;
+    }
+    List<object> Layout() {
+      List<object> result=new List<object>();
+      foreach(Screen screen in Screen.AllScreens) {
+        float scale=MonitorScale(screen);Rectangle work=screen.WorkingArea;int height=(int)(42*scale),width=Math.Min(work.Width,(int)(600*scale));
+        int x=work.Left+(work.Width-width)/2,y=position=="bottom"?work.Bottom-height-8:work.Top+8;
+        result.Add(new Dictionary<string,object> {
+          {"device",screen.DeviceName},{"x",screen.Bounds.X},{"y",screen.Bounds.Y},{"width",screen.Bounds.Width},{"height",screen.Bounds.Height},
+          {"scale",scale},{"bar",new Dictionary<string,object>{{"x",x},{"y",y},{"width",width},{"height",height}}}
+        });
+      }
+      return result;
+    }
+    void Rebuild() {
+      if(layoutKey.Length>0 && (DateTime.UtcNow-lastLayout).TotalMilliseconds<500)return;
+      lastLayout=DateTime.UtcNow;
+      string key=position+"|"+caption+"|"+remoteVisible;
+      foreach(Screen screen in Screen.AllScreens)key+="|"+screen.DeviceName+screen.Bounds+screen.WorkingArea+MonitorScale(screen);
+      if(key==layoutKey)return;
+      layoutKey=key;
+      foreach(IndicatorWindow form in frames)form.Dispose();frames.Clear();
+      foreach(IndicatorWindow form in bars)form.Dispose();bars.Clear();
+      if(pointer!=null){pointer.Dispose();pointer=null;}
+      affinityApplied=null;
+      foreach(Screen screen in Screen.AllScreens) {
+        float scale=MonitorScale(screen);Rectangle work=screen.WorkingArea;int height=(int)(42*scale),width=Math.Min(work.Width,(int)(600*scale));
+        IndicatorWindow frame=new IndicatorWindow(true);frame.LayoutAt(screen.Bounds,scale);frames.Add(frame);
+        IndicatorWindow bar=new IndicatorWindow(false);bar.Caption=caption+"  ·  Esc to stop";bar.LayoutAt(new Rectangle(work.Left+(work.Width-width)/2,position=="bottom"?work.Bottom-height-8:work.Top+8,width,height),scale);bars.Add(bar);
+      }
+      pointer=new IndicatorWindow(false);pointer.Caption="Pi";
+    }
+    void Apply(IndicatorWindow form,bool visible) {
+      if(!visible) { form.Hide();return; }
+      // A failed frame stays hidden until layout/configuration rebuilds it.
+      // Do not repeatedly show and hide a failing layered window on each tick.
+      if(form.IsFrame && form.FrameError.Length>0)return;
+      if(!form.Visible) {
+        form.Show();EnableWindow(form.Handle,false);
+        if(form.IsFrame) {if(!form.PresentFrame()){form.Hide();return;}}
+        else SetLayeredWindowAttributes(form.Handle,0,255,2);
+        if(!SetWindowDisplayAffinity(form.Handle,remoteVisible?0U:0x11U))affinityApplied=false;
+        else if(!affinityApplied.HasValue)affinityApplied=true;
+      }
+    }
+    static Size CursorExtent() {
+      CursorInfo cursor=new CursorInfo {Size=Marshal.SizeOf(typeof(CursorInfo))};IconInfo icon;
+      if(!GetCursorInfo(ref cursor) || !GetIconInfo(cursor.Cursor,out icon))return new Size(32,32);
+      try {
+        BitmapInfo bitmap;IntPtr source=icon.Color!=IntPtr.Zero?icon.Color:icon.Mask;
+        if(source!=IntPtr.Zero && GetObject(source,Marshal.SizeOf(typeof(BitmapInfo)),out bitmap)>0)
+          return new Size(Math.Max(16,bitmap.Width),Math.Max(16,icon.Color!=IntPtr.Zero?bitmap.Height:bitmap.Height/2));
+      } finally { if(icon.Color!=IntPtr.Zero)DeleteObject(icon.Color);if(icon.Mask!=IntPtr.Zero)DeleteObject(icon.Mask); }
+      return new Size(32,32);
+    }
+    void Refresh() {
+      if(!Wanted()) { Hide();return; }
+      Rebuild();
+      foreach(IndicatorWindow form in frames)Apply(form,screenEnabled || held);
+      foreach(IndicatorWindow form in bars)Apply(form,screenEnabled);
+      if(pointer!=null) {
+        System.Drawing.Point cursor=Cursor.Position;Screen screen=Screen.FromPoint(cursor);float scale=MonitorScale(screen);Size extent=CursorExtent();
+        int width=(int)(64*scale),height=(int)(32*scale),offset=(int)(8*scale);
+        int x=cursor.X+extent.Width+offset,y=cursor.Y+extent.Height+offset;
+        if(x+width>screen.WorkingArea.Right)x=cursor.X-width-offset;
+        if(y+height>screen.WorkingArea.Bottom)y=cursor.Y-height-offset;
+        x=Math.Max(screen.WorkingArea.Left,x);y=Math.Max(screen.WorkingArea.Top,y);
+        pointer.LayoutAt(new Rectangle(x,y,width,height),scale);Apply(pointer,pointerEnabled);
+      }
+    }
+    void Hide() {
+      foreach(IndicatorWindow form in frames)form.Hide();foreach(IndicatorWindow form in bars)form.Hide();if(pointer!=null)pointer.Hide();
+    }
+    void Tick() {
+      DateTime now=DateTime.UtcNow;
+      if(preview && now>=previewUntil)preview=false;
+      if(!Wanted()){Hide();return;}
+      Refresh();
+    }
+    public object Status() {
+      int visible=0;foreach(IndicatorWindow form in frames)if(form.Visible)visible++;foreach(IndicatorWindow form in bars)if(form.Visible)visible++;if(pointer!=null && pointer.Visible)visible++;
+      bool? hitTest=null;
+      foreach(IndicatorWindow form in bars)if(form.Visible) {
+        uint process;GetWindowThreadProcessId(WindowFromPoint(new Point {X=form.Left+form.Width/2,Y=form.Top+form.Height/2}),out process);
+        bool skipped=process!=(uint)System.Diagnostics.Process.GetCurrentProcess().Id;
+        hitTest=hitTest.HasValue?hitTest.Value && skipped:skipped;
+      }
+      return new Dictionary<string,object> {
+        {"held",held},{"renderChecked",renderChecked},{"previewPath",previewPath},{"preview",preview},{"suspended",suspended},{"visible",visible>0},{"visibleWindows",visible},
+        {"screenEnabled",screenEnabled},{"pointerEnabled",pointerEnabled},{"remoteVisible",remoteVisible},{"captureAffinityApplied",affinityApplied},
+        {"text",caption},{"position",position},{"endDelayMs",endDelay},{"operationIdleMs",0},{"previewDurationMs",2000},
+        {"nonActivating",true},{"clickThrough",true},{"layout",Layout()},
+        {"frameErrors",frames.FindAll(frame=>frame.FrameError.Length>0).ConvertAll(frame=>frame.FrameError)}
+        ,{"clickThroughHitTestPassed",hitTest},{"captureSuspensions",captureSuspensions}
+      };
+    }
+    public void Dispose() {
+      timer.Dispose();foreach(IndicatorWindow form in frames)form.Dispose();foreach(IndicatorWindow form in bars)form.Dispose();if(pointer!=null)pointer.Dispose();
+      if(previewPath!=null)try{System.IO.File.Delete(previewPath);}catch(System.IO.IOException){}
+    }
+  }
+}