C#

POINT pt;
::ClientToScreen(hwndchild,pt);
::ScreenToClient(hwndparent,pt);

Point pt;
Control.FromHandle(hWndchild).PointToScreen(pt);
Control.FromHandle(hWndparent).ScreenToClient(pt);

Email: theeclypse@hotmail.com   URL: http://www.onyeyiri.co.uk
"All programmers are playwrights and all computers are lousy actors."

Email: theeclypse@hotmail.com   URL: http://www.onyeyiri.co.uk
"All programmers are playwrights and all computers are lousy actors."

---

"When the only tool you have is a hammer, a sore thumb you will have."

public override Size Size 
{
   get 
   {
       if (bordertype =! BorderType.None)
       {
           return new Size(base.Size.X + borderwidth*2, base.Size.Y + borderwidth*2);
       } else return base.Size;
   }
   set {....same as get, just in reverse...}
}

Stupidity dies.
The end of future offspring.
Evolution wins.
- A Darwin Awards Haiku

// declaration
public delegate bool EnumThreadProc(IntPtr hwnd, IntPtr lParam);
[DllImport("user32.dll", CharSet=CharSet.Auto)]
    public static extern bool EnumThreadWindows(int threadId, EnumThreadProc pfnEnum, IntPtr lParam);


// use
EnumThreadProc callbackProc = new EnumThreadProc(MyEnumThreadWindowsProc);
EnumThreadWindows(threadId, callbackProc, IntPtr.Zero /*lParam*/);

bool MyEnumThreadWindowsProc(IntPtr hwnd, IntPtr lParam)
{
 ...
}

delegate void GetSyncCallBack(IntPtr handle, int channel, int data, int user); //internal

void OnGetSyncCallBack(IntPtr handle, int channel, int data, int user) //internal
{
  //here we trigger the event, this is only a test to trigger
  OnStreamEnd();
}

IntPtr HSYNC;
GetSyncCallBack getSync;

public event EventHandler StreamEnd 
{
  add 
  {
     getSync += new GetSyncCallBack( OnGetSyncCallBack );
     HSYNC = _SetSync(base.Handle, 0, 0, getSync , 0); //platform invoke
  }
  remove
  {
     getSync -= new GetSyncCallBack(OnGetSyncCallBack);
     _RemoveSync(base.Handle, HSYNC); //platform invoke
  }
}

protected virtual void OnStreamEnd()
{
   if (StreamEnd != null) //this is not allowed, why? we do events like this...
   {
      StreamEnd(this, null); //this is not allowed, why?
   }
}

delegate void GetSyncCallBack(IntPtr handle, int channel, int data, int user); //internal

void OnGetSyncCallBack(IntPtr handle, int channel, int data, int user) //internal
{
	//here we handle what is returned, for now just raise event
	OnStreamEnd();
}

IntPtr HSYNC;
GetSyncCallBack getSync;

EventHandler streamendstore; //implement a delegate storage (not sure about these terms)

public event EventHandler StreamEnd 
{
	add 
	{
		streamendstore += value; // add to store
		getSync += new GetSyncCallBack( OnGetSyncCallBack );
		HSYNC = _SetSync(base.Handle, 2, 0, getSync , 0);
	}
	remove
	{
		streamendstore -= value; //remove from store
		getSync -= new GetSyncCallBack(OnGetSyncCallBack);
		_RemoveSync(base.Handle, HSYNC);
	}
}

protected virtual void OnStreamEnd()
{
	if( streamendstore != null)streamendstore(this, null); //raise event via the store
}