// CObjectWin.cpp
// Author: A.Fombaron / I-Maginer
// Version: v1.00 - SVoyager v5.01
// Date: 070925

#include "CObjectWindow.h"
#include "lib2Dconf.h"


#ifdef USE_WINDOWS

//$BLG - Add
//#include "Windows.h"
//#include "WinUser.h"

#include "Macro.h"
#include "CObjectBitmap.h"
#include "CObjMessageMove.h"			//pour la classe CObjMessageMove et les directions prédéfinies
#include "CObjMessageHideAndSHow.h"
#include "../x/Objstr.h"
#include "utils.h"
#include "container.h"
#include "colors.h"

extern int OBJNODE;
extern mmachine mm;

#define ALPHA	0

//$BLG - Add
typedef UINT (CALLBACK *PROCINTERNALGETWINDOWTEXT)(HWND, LPWSTR, int);
typedef UINT (WINAPI *PROCINTERNALSETFOCUS)(HWND);



//$BLG - Modif
//CObjectWindow::CObjectWindow(container * cont,Layer *layer,int fatx,int faty,int x_inbitmap,int y_inbitmap,int w,int h,int bmpwidth, int bmpheight, int flags,int contflags, int transp):CObjectBase(cont,layer,fatx,faty,w,h,flags,contflags,transp)
//CObjectWindow::CObjectWindow(container * cont,Layer *layer,int fatx,int faty,int w, int h, int flags,int contflags, int transp, PtrObjWindow window, HWND hwndAX, int timerFR):CObjectBase(cont, layer, fatx, faty, w, h, flags, contflags, transp)
CObjectWindow::CObjectWindow(container * cont,Layer *layer,int fatx,int faty,int w, int h, int flags,int contflags, int transp, HWND hwndCP, HWND hwndAX, int timerFR):CObjectBase(cont, layer, fatx, faty, w, h, flags, contflags, transp)
{
//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\nCObjectWindow::CObjectWindow");
#endif
//***********************************

	//$BLG - Modif
	/*
	BMPx_inbitmap=x_inbitmap;
	BMPy_inbitmap=y_inbitmap;
	BMPheight = bmpheight;
	BMPwidth = bmpwidth;
	*/
	BMPx_inbitmap = 0;
	BMPy_inbitmap = 0;
	BMPwidth = w;
	BMPheight = h;
	
	//$BLG - Add
	//CWin_winCP = window;
	CWin_hwndCP = hwndCP;
	CWin_tmrFR = timerFR;
	CWin_tmrID = NO_TIMER;
	CWin_w = w;
	CWin_h = h;
	CWin_hwndAX = hwndAX;
	CWin_container = cont;

//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\nCObjectWindow::CObjectWindow end");
#endif
//***********************************

}




CObjectWindow::~CObjectWindow()
{
	this->Container()->Unregister(this->CWin_tmrID);
	0;
}



int CObjectWindow::IsMouseOnObject(int x,int y, int p_tab)
{
	int colorpix;
	unsigned char r, g, b;
	int idx;

//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\nCObjectWindow::IsMouseOnObject");
#endif
//***********************************

	PtrObjBitmap bmp=GET_PTR_OBJ_BITMAP(GET_BMP(MTOP(MMfetch(mm,p_tab,ALPHA))));
	if ( bmp == NULL )
		return false;
	// on determine si il est dans la zone non transparente ou non
	idx = (BMPx_inbitmap+x-ObjX) * bmp->BytesPP  +  (BMPy_inbitmap+y-ObjY) * bmp->BPL;
	b = bmp->bits[ idx   ];
	g = bmp->bits[ idx+1 ];
	r = bmp->bits[ idx+2 ];
	colorpix = _COLOR_BGR_TO_I (b, g, r);


//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\nCObjectWindow::IsMouseOnObject end");
#endif
//***********************************

	return ((ObjTransparency==-1)||(colorpix!=ObjTransparency));
}





int CObjectWindow::CursorMove(int x,int y,int keyFlags, int p_tab,int redrawobject)
{
	int k,tmp_res,mask;

	//$BLG - Add
	HWND fthr, chld;
	int fthr_l, fthr_t, chld_l, chld_t;
	POINT pt0, pt1;
	PWINDOWINFO pwi;

//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\nCObjectWindow::CursorMove");
#endif
//***********************************

	k=OBJbeginreflex(mm,OBJNODE,(int)this,RFLOBJNODE_CURSORMOVE);
	if (k>0) return 1; 
	if (k==0)
	{
			mask=keyFlags&(MK_CONTROL|MK_LBUTTON|MK_MBUTTON|MK_RBUTTON|MK_SHIFT);

			pt1.x = pt0.x = x-ObjX;
			pt1.y = pt0.y = y-ObjY;

			fthr = CWin_hwndCP;
			
			pwi = (PWINDOWINFO)malloc(sizeof(WINDOWINFO));
			GetWindowInfo(fthr, pwi);
			fthr_l = pwi->rcWindow.left;
			fthr_t = pwi->rcWindow.top;
			
			chld = NULL;
			
			while (chld != fthr)
			{
				chld = ChildWindowFromPoint(fthr, pt1);
				if (chld != fthr)
				{
					GetWindowInfo(chld, pwi);
					chld_l = pwi->rcWindow.left;
					chld_t = pwi->rcWindow.top;
					pt1.x = pt0.x - (chld_l - fthr_l);
					pt1.y = pt0.y - (chld_t - fthr_t);
					fthr = chld;
					chld = (HWND)(-1);
				}
			}

			SendMessage(chld, WM_MOUSEMOVE, 0, (LPARAM)(MAKELONG(pt1.x, pt1.y)));
			
			free(pwi);

			CHECK(MMpush(mm,ITOM(x)));
			CHECK(MMpush(mm,ITOM(y)));
			CHECK(MMpush(mm,ITOM(mask)));
			return OBJcallreflex(mm,3);
	}

//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\nCObjectWindow::CursorMove end");
#endif
//***********************************

	return 0;
}

int CObjectWindow::CursorMoveIn(int x,int y,int keyFlags, int p_tab,int redrawobject)
{
	return 0;
}

int CObjectWindow::CursorMoveInWithBtnPushed(int x,int y,int keyFlags, int p_tab,int redrawobject)
{
	return 0;
}

int CObjectWindow::CursorMoveOut(int x,int y,int keyFlags, int p_tab,int redrawobject)
{
	return 0;
}

int CObjectWindow::CursorMoveOutWithBtnPushed(int x,int y,int keyFlags, int p_tab,int redrawobject)
{
	return 0;
}

int CObjectWindow::CursorMoveOutsideWithBtnPushed(int x,int y,int keyFlags, int p_tab,int redrawobject)
{
	return 0;
}

int CObjectWindow::ClickIn(int x,int y,int btn,int keyFlags, int p_tab,int redrawobject)
{
	int k,tmp_res,mask;
	
	//$BLG - Add
	HWND fthr, chld, fcs;
	int fthr_l, fthr_t, chld_l, chld_t;
	POINT pt0, pt1;
	PWINDOWINFO pwi;
	WCHAR str[256];
	UINT msgDn, msgUp;


//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\nCObjectWindow::ClickIn");
#endif
//***********************************

	//MMechostr(0, "ClickIn\n");

	k=OBJbeginreflex(mm,OBJNODE,(int)this,RFLOBJNODE_CLICK);
	if (k>0) return 1; 
	if (k==0)
	{
			mask=keyFlags&(MK_CONTROL|MK_LBUTTON|MK_MBUTTON|MK_RBUTTON|MK_SHIFT);
			
			//$BLG - Add
			MMechostr(0, "ClickIn\n");
	    HMODULE hUser32 = GetModuleHandle("user32");
	    PROCINTERNALSETFOCUS InternalSetFocus;
	    InternalSetFocus = (PROCINTERNALSETFOCUS)GetProcAddress(hUser32, "SetFocus");
			pt1.x = pt0.x = x-ObjX;
			pt1.y = pt0.y = y-ObjY;
			/*
			fcs = GetForegroundWindow();
			fthr = CWin_winCP->WHandler;
			SetForegroundWindow(fthr);
			InternalSetFocus(fthr);
			*/
			//fthr = CWin_winCP->WHandler;
			fthr = CWin_hwndCP;
			fcs = SetActiveWindow(fthr);
			
			/*
			chld = ChildWindowFromPoint(fthr, pt);
			flsh = ChildWindowFromPoint(chld, pt);
			if (chld == flsh) MMechostr(0, "Same\n"); else MMechostr(0, "Diff\n");
			if (ChildWindowFromPoint(flsh, pt)) MMechostr(0, "Cont\n"); else MMechostr(0, "End\n");
			pwi = (PWINDOWINFO)malloc(sizeof(WINDOWINFO));
			MMechostr(0, "GWI:\n");
			GetWindowInfo(fthr, pwi);
			MMechostr(0, "F %d %d %d %d\n", pwi->rcWindow.left, pwi->rcWindow.top, pwi->rcWindow.right, pwi->rcWindow.bottom);
			GetWindowInfo(chld, pwi);
			MMechostr(0, "C %d %d %d %d\n", pwi->rcWindow.left, pwi->rcWindow.top, pwi->rcWindow.right, pwi->rcWindow.bottom);
			GetWindowInfo(flsh, pwi);
			MMechostr(0, "C %d %d %d %d\n", pwi->rcWindow.left, pwi->rcWindow.top, pwi->rcWindow.right, pwi->rcWindow.bottom);
			GetCursorPos(&csr);
			MMechostr(0, "%d %d\n", csr.x, csr.y);
			SendMessage((flsh), WM_LBUTTONDOWN, (WPARAM)(mask), (LPARAM)((x-ObjX) + ((y-ObjY)<<16)));
			*/
			
			pwi = (PWINDOWINFO)malloc(sizeof(WINDOWINFO));
			GetWindowInfo(fthr, pwi);
			fthr_l = pwi->rcWindow.left;
			fthr_t = pwi->rcWindow.top;
			
			chld = NULL;

	    //HMODULE hUser32 = GetModuleHandle("user32");
	    PROCINTERNALGETWINDOWTEXT InternalGetWindowText;
	    InternalGetWindowText = (PROCINTERNALGETWINDOWTEXT)GetProcAddress(hUser32, "InternalGetWindowText");
			
			//MMechostr(0, "PT: %d %d\n",pt0.x, pt0.y);
			InternalGetWindowText(fcs, (LPWSTR)str, 256);
	    MMechostr(0,"Fcs: %d %S<\n", (long)(fcs), str);
	    InternalGetWindowText(fthr, (LPWSTR)str, 256);
	    MMechostr(0,"Fthr: %d %S<\n", (long)(fthr), str);
			
			while (chld != fthr)
			{
				chld = ChildWindowFromPoint(fthr, pt1);
				if (chld != fthr)
				{
					GetWindowInfo(chld, pwi);
					//MMechostr(0, "C %d %d %d %d\n", pwi->rcWindow.left, pwi->rcWindow.top, pwi->rcWindow.right, pwi->rcWindow.bottom);
			    InternalGetWindowText(chld, (LPWSTR)str, 256);
			    MMechostr(0,"Child: %d %S<\n", (long)(chld), str);
					chld_l = pwi->rcWindow.left;
					chld_t = pwi->rcWindow.top;
					pt1.x = pt0.x - (chld_l - fthr_l);
					pt1.y = pt0.y - (chld_t - fthr_t);
					//MMechostr(0, "PT: %d %d\n",pt1.x, pt1.y);
					//fthr_l = chld_l;
					//fthr_t = fthr_t;
					fthr = chld;
					chld = (HWND)(-1);
				}
			}

			//chld = GetAncestor(chld, GA_PARENT);

			/*
			SetForegroundWindow(chld);
			InternalSetFocus(chld);
			*/
			SetActiveWindow(chld);
			
			//Sleep(50);

	    InternalGetWindowText(chld, (LPWSTR)str, 256);
	    MMechostr(0,"Child: %d %S<\n", (long)(chld), str);
			
			//MMechostr(0, "btn: %d\n", btn);
			if (btn == LBUTTON)
			{
				msgDn = WM_LBUTTONDOWN;
				msgUp = WM_LBUTTONUP;
			}
			else if (btn == MBUTTON)
			{
				msgDn = WM_MBUTTONDOWN;
				msgUp = WM_MBUTTONUP;
			}
			else
			{
				msgDn = WM_RBUTTONDOWN;
				msgUp = WM_RBUTTONUP;
			}
			
			//SendMessage(chld, WM_LBUTTONDOWN, (WPARAM)(mask), (LPARAM)((pt.x) + ((pt.y)<<16)));
			//SendMessage(chld, BM_CLICK, (WPARAM)(mask), (LPARAM)((pt.x) + ((pt.y)<<16)));
			SendMessage(chld, WM_SETCURSOR, (WPARAM)(0), (LPARAM)(MAKELONG(HTCLIENT, msgDn)));
			//SendMessage(chld, WM_LBUTTONDOWN, (WPARAM)(mask), (LPARAM)((pt1.x) + ((pt1.y)<<16)));
			SendMessage(chld, msgDn, (WPARAM)(msgDn), (LPARAM)(MAKELONG(pt1.x, pt1.y)));
			//SendMessage(chld, WM_LBUTTONUP, (WPARAM)(mask), (LPARAM)((pt1.x) + ((pt1.y)<<16)));
			//SendMessage(chld, WM_LBUTTONUP, (WPARAM)(mask), (LPARAM)(MAKELONG(pt1.x, pt1.y)));
			SendMessage(chld, WM_SETCURSOR, (WPARAM)(0), (LPARAM)(MAKELONG(HTCLIENT, msgUp)));
			//SendMessage(chld, WM_LBUTTONUP, (WPARAM)(WM_LBUTTONUP), (LPARAM)(MAKELONG(pt1.x, pt1.y)));
			SendMessage(chld, msgUp, (WPARAM)(msgUp), (LPARAM)(MAKELONG(pt1.x, pt1.y)));
			
			// The SetActiveWindow() call seems to take some time. It seems to be asynchronous, probably posting messages.
			// On ActiveX windows, this seems to be a problem as the sent msgs most of the time are handled before the 
			// Window is fully activated. And they thus are lost... Dupplicating the Click event seems to be a "bad"
			// Workaround for this issue ... Although it may sometimes trigger a dbl click ...
			if (chld == CWin_hwndAX)
			{
				SendMessage(chld, msgDn, (WPARAM)(msgDn), (LPARAM)(MAKELONG(pt1.x, pt1.y)));
				SendMessage(chld, msgUp, (WPARAM)(msgUp), (LPARAM)(MAKELONG(pt1.x, pt1.y)));
			}
			
			/*
			SetForegroundWindow(fcs);
			InternalSetFocus(fcs);
			*/
			//SetActiveWindow(fcs);
			//SetFocus(0, NULL, 1);
			CWin_container->SetFocus(this);
			SetActiveWindow(fcs);
			
			free(pwi);
			
			CHECK(MMpush(mm, ITOM(x)));
			CHECK(MMpush(mm, ITOM(y)));
			CHECK(MMpush(mm, ITOM(btn)));
			CHECK(MMpush(mm, ITOM(mask)));
			return OBJcallreflex(mm, 4);
	}

//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\nCObjectWindow::ClickIn end");
#endif
//***********************************

	return 0;
}




int CObjectWindow::UnClickIn(int x,int y,int btn,int keyFlags, int p_tab,int redrawobject)
{
	int k,tmp_res,mask;

	//$BLG - Add
	HWND fthr, chld, fcs;
	int fthr_l, fthr_t, chld_l, chld_t;
	POINT pt;
	PWINDOWINFO pwi;

//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\nCObjectWindow::UnClickIn");
#endif
//***********************************

	MMechostr(0, "UnClickIn\n");

	k=OBJbeginreflex(mm,OBJNODE,(int)this,RFLOBJNODE_UNCLICK);
	if (k>0) return 1; 
	if (k==0)
	{
			mask=keyFlags&(MK_CONTROL|MK_LBUTTON|MK_MBUTTON|MK_RBUTTON|MK_SHIFT);

			//$BLG - Add
			MMechostr(0, "UnClickIn\n");
	    HMODULE hUser32 = GetModuleHandle("user32");
	    PROCINTERNALSETFOCUS InternalSetFocus;
	    InternalSetFocus = (PROCINTERNALSETFOCUS)GetProcAddress(hUser32, "SetFocus");
			pt.x = x-ObjX;
			pt.y = y-ObjY;
			fcs = GetForegroundWindow();
			//fthr = CWin_winCP->WHandler;
			fthr = CWin_hwndCP;
			SetForegroundWindow(fthr);
			InternalSetFocus(fthr);
			/*
			chld = ChildWindowFromPoint(fthr, pt);
			flsh = ChildWindowFromPoint(chld, pt);
			SendMessage((flsh), WM_LBUTTONUP, (WPARAM)(mask), (LPARAM)(((x-ObjX)) + ((y-ObjY)<<16)));
			*/
			
			pwi = (PWINDOWINFO)malloc(sizeof(WINDOWINFO));
			GetWindowInfo(fthr, pwi);
			fthr_l = pwi->rcWindow.left;
			fthr_t = pwi->rcWindow.top;
			
			chld = NULL;
			
			while (chld != fthr)
			{
				chld = ChildWindowFromPoint(fthr, pt);
				if (chld != fthr)
				{
					GetWindowInfo(chld, pwi);
					MMechostr(0, "C %d %d %d %d\n", pwi->rcWindow.left, pwi->rcWindow.top, pwi->rcWindow.right, pwi->rcWindow.bottom);
					chld_l = pwi->rcWindow.left;
					chld_t = pwi->rcWindow.top;
					pt.x -= (fthr_l - chld_l);
					pt.y -= (fthr_t - chld_t);
					fthr_l = chld_l;
					fthr_t = fthr_t;
					fthr = chld;
					chld = NULL;
				}
			}
			
			SendMessage(chld, WM_LBUTTONUP, (WPARAM)(mask), (LPARAM)((pt.x) + ((pt.y)<<16)));
			
			SetForegroundWindow(fcs);
			InternalSetFocus(fcs);

			CHECK(MMpush(mm,ITOM(x)));
			CHECK(MMpush(mm,ITOM(y)));
			CHECK(MMpush(mm,ITOM(btn)));
			CHECK(MMpush(mm,ITOM(mask)));
			return OBJcallreflex(mm,4);
	}
	return 0;
}
	
int CObjectWindow::ClickOut(int x,int y,int btn,int keyFlags, int p_tab,int redrawobject)
{
	return 0;
}

int CObjectWindow::UnClickOut(int x,int y,int btn,int keyFlags, int p_tab,int redrawobject)
{
	return 0;
}

int CObjectWindow::DblClickIn(int x,int y,int btn,int keyFlags, int p_tab,int redrawobject)
{
	int k,tmp_res,mask;

	//$BLG - Add
	HWND fthr, chld, fcs;
	int fthr_l, fthr_t, chld_l, chld_t;
	POINT pt;
	PWINDOWINFO pwi;

//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\nCObjectWindow::DblClickIn");
#endif
//***********************************

	MMechostr(0, "DblClickIn\n");

	k=OBJbeginreflex(mm,OBJNODE,(int)this,RFLOBJNODE_DBLCLICK);
	if (k>0) return 1; 
	if (k==0)
	{
			mask=keyFlags&(MK_CONTROL|MK_LBUTTON|MK_MBUTTON|MK_RBUTTON|MK_SHIFT);
			
			//$BLG - Add
			MMechostr(0, "DblClickIn\n");
	    HMODULE hUser32 = GetModuleHandle("user32");
	    PROCINTERNALSETFOCUS InternalSetFocus;
	    InternalSetFocus = (PROCINTERNALSETFOCUS)GetProcAddress(hUser32, "SetFocus");
			pt.x = x-ObjX;
			pt.y = y-ObjY;
			fcs = GetForegroundWindow();
			//fthr = CWin_winCP->WHandler;
			fthr = CWin_hwndCP;
			SetForegroundWindow(fthr);
			InternalSetFocus(fthr);
			/*
			chld = ChildWindowFromPoint(fthr, pt);
			flsh = ChildWindowFromPoint(chld, pt);
			SendMessage((flsh), WM_LBUTTONDBLCLK, (WPARAM)(mask), (LPARAM)(((x-ObjX)) + ((y-ObjY)<<16)));
			*/
			
			pwi = (PWINDOWINFO)malloc(sizeof(WINDOWINFO));
			GetWindowInfo(fthr, pwi);
			fthr_l = pwi->rcWindow.left;
			fthr_t = pwi->rcWindow.top;
			
			chld = NULL;
			
			while (chld != fthr)
			{
				chld = ChildWindowFromPoint(fthr, pt);
				if (chld != fthr)
				{
					GetWindowInfo(chld, pwi);
					MMechostr(0, "C %d %d %d %d\n", pwi->rcWindow.left, pwi->rcWindow.top, pwi->rcWindow.right, pwi->rcWindow.bottom);
					chld_l = pwi->rcWindow.left;
					chld_t = pwi->rcWindow.top;
					pt.x -= (fthr_l - chld_l);
					pt.y -= (fthr_t - chld_t);
					fthr_l = chld_l;
					fthr_t = fthr_t;
					fthr = chld;
					chld = NULL;
				}
			}
			
			SendMessage(chld, WM_LBUTTONDBLCLK, (WPARAM)(mask), (LPARAM)((pt.x) + ((pt.y)<<16)));
			
			SetForegroundWindow(fcs);
			InternalSetFocus(fcs);
			
			CHECK(MMpush(mm,ITOM(x)));
			CHECK(MMpush(mm,ITOM(y)));
			CHECK(MMpush(mm,ITOM(btn)));
			CHECK(MMpush(mm,ITOM(mask)));
			return OBJcallreflex(mm,4);
	}
	return 0;
}

int CObjectWindow::MouseWheel(int delta,int x,int y,int keyFlags,int p_tab,int redrawobject)
{
	return 0;
}

int CObjectWindow::KeyUp(UINT vk,int cRepeat, UINT flags, int p_tab)
{
	return 0;
}

int CObjectWindow::KeyDown(UINT vk,int keysys,int cRepeat, UINT flags, int p_tab)
{
	return 0;
}

int CObjectWindow::SetFocus(int reset,int p_tab,int redraw)
{
	if (reset)
	{
		//Some parameters to reset ? Then do it here
	}
	
	//Example from CObjectEditText.cpp
	//int p_font=MTOP(MMfetch(mm,p_tab,FONT));	
	//EvalCursorPosition(p_font);	
	
	if (redraw)
	{
		Redraw();
	}
	
	return 0;
}

int CObjectWindow::KillFocus(int p_tab,int redraw)
{
	return 0;
}


int CObjectWindow::Timer(int timerID)
{
	//$BLG - Add
	//MMechostr(0,"Tick\n");
	
	HDC hSrcDC, /*hDstDC,*/ hMemDC;
	HGDIOBJ hOldBitmap;
	

	//RedrawWindow((CWin_winCP->WHandler), NULL, NULL, RDW_INVALIDATE|/*RDW_UPDATENOW|*/RDW_ALLCHILDREN);
	//RedrawWindow((CWin_hwndAX), NULL, NULL, RDW_INVALIDATE|/*RDW_UPDATENOW|*/RDW_ALLCHILDREN);
	//RedrawWindow((CWin_hwndAX), NULL, NULL, RDW_INVALIDATE);

	// Get the DC from the Window and create a compatible memory DC
	//hSrcDC = GetDC(CWin_winCP->WHandler);
	hSrcDC = GetDC(CWin_hwndCP);
	//hDstDC = CreateCompatibleDC(hSrcDC);
	hMemDC = CreateCompatibleDC(hSrcDC);
	
	// Drawing window content to sDstDC
	//SendMessage ((CWin_winCP->WHandler), WM_PRINTCLIENT, (WPARAM)(hDstDC), (LPARAM)(PRF_ERASEBKGND|PRF_CLIENT));
	
	// Select new bitmap into memory DC 
	hOldBitmap = SelectObject(hMemDC, ObjLayer->RGBbitmap->DIBhandler);


	// Bitblt window DC to memory DC     
	//BitBlt(hMemDC, 0, 0, CWin_w, CWin_h, hSrcDC, 0, 0, SRCCOPY);     
	//BitBlt(hMemDC, 0, 0, CWin_w, CWin_h, hDstDC, 0, 0, SRCCOPY);     
	//SendMessage((CWin_winCP->WHandler), WM_PRINTCLIENT, (WPARAM)(hMemDC), (LPARAM)(PRF_CHILDREN|PRF_CLIENT/*|PRF_OWNED|PRF_ERASEBKGND*/));
	//SendMessage((CWin_winCP->WHandler), WM_PAINT, (WPARAM)(hMemDC), (LPARAM)(PRF_CHILDREN|PRF_CLIENT/*|PRF_OWNED|PRF_ERASEBKGND*/));
	
	//DefWindowProc((CWin_winCP->WHandler), WM_PRINT, (WPARAM)(hMemDC), (LPARAM)(PRF_CHILDREN|PRF_CLIENT/*|PRF_OWNED|PRF_ERASEBKGND*/));
	DefWindowProc(CWin_hwndCP, WM_PRINT, (WPARAM)(hMemDC), (LPARAM)(PRF_CHILDREN|PRF_CLIENT/*|PRF_OWNED|PRF_ERASEBKGND*/));
	//DefWindowProc((CWin_winCP->WHandler), WM_PAINT, (WPARAM)(hMemDC), (LPARAM)(PRF_CHILDREN|PRF_CLIENT));
	if (CWin_hwndAX != NULL)
		SendMessage((CWin_hwndAX), WM_PAINT, (WPARAM)(hMemDC), (LPARAM)(NULL));
	
	// Select old bitmap back into memory DC and get handle to bitmap of the window
	ObjLayer->RGBbitmap->DIBhandler = (HBITMAP)SelectObject(hMemDC, hOldBitmap);
	ObjLayer->RGBbitmap->handler = (int)ObjLayer->RGBbitmap->DIBhandler;				// To "synchronize" with code in ObjBitmap_NewDIBSection()
	
	// Clean up      
	DeleteDC(hMemDC);  			
	// DeleteDC(hDstDC);
	//ReleaseDC(CWin_winCP->WHandler, hSrcDC);
	ReleaseDC(CWin_hwndCP, hSrcDC);

	//RedrawWindow((CWin_winCP->WHandler), NULL, NULL, RDW_VALIDATE|RDW_UPDATENOW|RDW_ALLCHILDREN); 
	
	Redraw();
	
	return 0;
}


Layer *CObjectWindow::GetLayer(mmachine m,int p_tab)
{
//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\nCObjectWindow::GetLayer");
#endif
//***********************************

	if (ObjLayer==NULL) return NULL;
	
	// m a j des ptr Scol
	ObjLayer->RGBbitmap   = GET_PTR_OBJ_BITMAP(GET_BMP(MTOP(MMfetch(mm,p_tab,ALPHA))));
	ObjLayer->AlphaBitmap = GET_PTR_OBJ_BITMAP(GET_ABMP(MTOP(MMfetch(mm,p_tab,ALPHA))));
	ObjLayer->sourceRect = Rect2D( BMPx_inbitmap, BMPy_inbitmap, BMPx_inbitmap+ObjW, BMPy_inbitmap+ObjH );
	return ObjLayer;
}



Layer *CObjectWindow::GetLayerPart(mmachine m,Rect2D *paintrect,int p_tab)
{

//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\nCObjectWindow::GetLayerPart");
#endif
//***********************************


	if (ObjLayer==NULL) return NULL;

	// m a j des ptr Scol
	ObjLayer->RGBbitmap   = GET_PTR_OBJ_BITMAP(GET_BMP(MTOP(MMfetch(mm,p_tab,ALPHA))));
	ObjLayer->AlphaBitmap = GET_PTR_OBJ_BITMAP(GET_ABMP(MTOP(MMfetch(mm,p_tab,ALPHA))));
	// on cherche quelle est la sous-bitmap de l'objet	
	ObjLayer->sourceRect = IntersectionRectangle( Rect2D(BMPx_inbitmap, BMPy_inbitmap, BMPx_inbitmap+ObjW, BMPy_inbitmap+ObjH ),
												  MoveRectangleByVecteur( *paintrect,
																		  Point2D( BMPx_inbitmap, BMPy_inbitmap ) ) );

	return ObjLayer;
}



int CObjectWindow::DestroyAllLayers()
{
//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\nCObjectWindow::DestroyAllLayers");
#endif
//***********************************

	// un seul layer
	if (ObjLayer!=NULL)
		delete(ObjLayer);
	ObjLayer=NULL;
	return 0;
}



int CObjectWindow::ResizeLayer(int w,int h,int p_tab)
{
	int k,tmp_res;
//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\nCObjectWindow::ResizeLayer");
#endif
//***********************************

	k=OBJbeginreflex(mm,OBJNODE,(int)this,RFLOBJNODE_RESIZE_RESSOURCE);
	if (k==0)
	{
		// execution du reflexe de redimensionnemnt du layer
		CHECK(MMpush(mm,ITOM(w)));
		CHECK(MMpush(mm,ITOM(h)));
		CHECK(MMpush(mm,ITOM(BMPx_inbitmap)));
		CHECK(MMpush(mm,ITOM(BMPy_inbitmap)));
		CHECK(MMpush(mm,ITOM(BMPwidth)));
		CHECK(MMpush(mm,ITOM(BMPheight)));
		CHECK(MMpush(mm,ITOM(4)));
		CHECK(MBdeftab(mm));
		CHECK(OBJcallreflex(mm,3));
		
		/* prevent from destruction of container or object in user callback */
		if (GetObjectBase(mm,FindObjNodeFromHdlSys(mm,(int)this))==NULL) 
			return 0;

		// pile : [AlphaBitmap [I I I I]]
		int p_ret,p_param;
		int p_abmp=NIL;
		if ((p_ret=MTOP(MMget(mm,-2)))==NIL)
		{   // valeur de retour nil
			MMechostr(1,"_CBcompWindowResizeResource: return value is nil\n");
			ChangeResource(mm,ALPHA,NIL);		
			return 0;
		}

		if ((p_abmp=MTOP(MMfetch(mm,p_ret,0)))==NIL)
		{
			MMechostr(1,"_CBcompWindowResizeResource: alphabitmap is nil\n");
			ChangeResource(mm,ALPHA,NIL);		
			return 0;
		}	
				
		// recuperation de l'alphabitmap utilisateur 
		// et creation du nouveau layer
		int transparency;
		PtrObjBitmap bmp =GET_PTR_OBJ_BITMAP(GET_BMP(p_abmp));
		PtrObjBitmap abmp=GET_PTR_OBJ_BITMAP(GET_ABMP(p_abmp));
		if ((transparency = GET_TRANSP(p_abmp))==NIL) transparency = NO_TRANSPARENCY;

		// mise à jour des parametres du CompWindow
		p_param=MTOP(MMfetch(mm,p_ret,1));
		if (p_param==NIL || (BMPx_inbitmap=MTOI(MMfetch(mm,p_param,0)))==NIL) BMPx_inbitmap = 0;
		if (p_param==NIL || (BMPy_inbitmap=MTOI(MMfetch(mm,p_param,1)))==NIL) BMPy_inbitmap = 0;
		if (p_param==NIL || (BMPwidth=MTOI(MMfetch(mm,p_param,2)))==NIL) BMPwidth = 0;
		if (p_param==NIL || (BMPheight=MTOI(MMfetch(mm,p_param,3)))==NIL) BMPheight = 0;
		
		int bmpH = 0;
		int bmpW = 0;
		if (bmp!=NULL)
		{
			
			if (abmp!=NULL)
			{
				bmpH = min( bmp->TailleH, abmp->TailleH );
				bmpW = min( bmp->TailleW, abmp->TailleW );
			}
			else
			{
				bmpH = bmp->TailleH;
				bmpW = bmp->TailleW;
			}
		}
		BMPwidth  = min( BMPwidth, bmpW - BMPx_inbitmap );
		BMPheight = min( BMPheight, bmpH - BMPy_inbitmap );
		
		// creation du nouveau layer
		if (bmp!=NULL)
			if (BMPwidth==w && BMPheight==h)
				ObjLayer = new Layer(bmp,abmp, transparency );
			else
				MMechostr(1,"_CBcompWindowResizeResource: not good format for alphabitmap (requested size:%d %d received size:%d %d)\n",w,h,bmp->TailleW,bmp->TailleH);
		else
			ObjLayer = new Layer( w, h, transparency,abmp!= NULL);
		
		ChangeResource(mm,ALPHA,p_abmp);
		return 0;
	}
	// callback non definie ou invalide et objet doit etre absolument resizé!!
	MMechostr(1,"_CBcompWindowResizeResource not defined and object need to be resized!!!\n");

//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\nCObjectWindow::ResizeLayer end");
#endif
//***********************************

	return 1;
}




// pour les liens entre objets
int CObjectWindow::handle(CObjMessage* msg)
{
	int direction, value, redrawobject;
//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\nCObjectWindow::handle");
#endif
//***********************************


	switch(msg->GetType())
	{
	case LINK_MOVE:
		//recherche les informations du message
		direction = (int)(static_cast <CObjMessageMove*> (msg))->GetDirection();
		value =		(int)(static_cast <CObjMessageMove*> (msg))->GetOffset();
		redrawobject = msg->GetRedrawObject();

		//traite les informations du message
		if ( direction == DIR_VERTICAL )
			BMPy_inbitmap = min( max( 0, BMPy_inbitmap + value ), BMPheight - ObjH );
		else if ( direction == -DIR_VERTICAL )
			BMPy_inbitmap = min( max( 0, BMPy_inbitmap - value ), BMPheight - ObjH );
		else if ( direction == DIR_HORIZONTAL )
			BMPx_inbitmap = min( max( 0, BMPx_inbitmap + value ), BMPwidth - ObjW );
		else if ( direction == -DIR_HORIZONTAL )
			BMPx_inbitmap = min( max( 0, BMPx_inbitmap - value ), BMPwidth - ObjW );

		if ( redrawobject )
			Redraw();
		break;
	case LINK_HIDE_AND_SHOW:
		if ( (int)(static_cast <CObjMessageHideAndShow*> (msg))->GetMode() == SHOW )
		{
			this->ObjFlags -= this->ObjFlags&OBJ_HIDE;
			this->ObjFlags -= this->ObjFlags&OBJ_DISABLE;
			this->ObjFlags |= OBJ_VISIBLE;
			this->ObjFlags |= OBJ_ENABLE;
		}
		else
		{
			this->ObjFlags |= OBJ_HIDE;
			this->ObjFlags |= OBJ_DISABLE;
			this->ObjFlags -= this->ObjFlags&OBJ_VISIBLE;
			this->ObjFlags -= this->ObjFlags&OBJ_ENABLE;
		}

		if ( msg->GetRedrawObject() )
			this->Container()->Redraw(1);

		break;

	default:
		break;
	}


//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\nCObjectWindow::handle end");
#endif
//***********************************

	return 0;
}



int CObjectWindow::supports( int type )
{
	return ( type == LINK_MOVE || type == LINK_HIDE_AND_SHOW );
}



int CALLBACK DBG_EnumChildProc(HWND hwndChild, LPARAM hwnd) 
{ 
    WCHAR str[256];

    HMODULE hUser32 = GetModuleHandle("user32");
    PROCINTERNALGETWINDOWTEXT InternalGetWindowText;
    InternalGetWindowText = (PROCINTERNALGETWINDOWTEXT)GetProcAddress(hUser32, "InternalGetWindowText");
    InternalGetWindowText(hwndChild, (LPWSTR)str, 256);
    MMechostr(0,"Child: %d %S<\n", (long)(hwndChild), str);

    return TRUE;
}


int CALLBACK EnumChildProc(HWND hwndChild, LPARAM hwnd) 
{ 
    //$BLG - Modif
    //This function can only be called once as a Scol ActiveX hosting Window contains only the ActiveX real Window
    //Former version kept as example
    /*
    WCHAR str[256];

    HMODULE hUser32 = GetModuleHandle("user32");
    PROCINTERNALGETWINDOWTEXT InternalGetWindowText;
    InternalGetWindowText = (PROCINTERNALGETWINDOWTEXT)GetProcAddress(hUser32, "InternalGetWindowText");
    InternalGetWindowText(hwndChild, (LPWSTR)str, 256);
    MMechostr(0,"Child: %d %S<\n", (long)(hwndChild), str);
    if (str[0] == '\0') 
    {
    	MMechostr(0,">\n");
    	//*((long *)hwnd) = (long)(hwndChild);
    	*((HWND *)hwnd) = hwndChild;
    	return false;
    }
 
    return TRUE;
    */
    
    *((HWND *)hwnd) = hwndChild;
    return false;
}


/***************************************************************************************************/
/*                           LES FONCTIONS SCOL DU BITMAP										   */
/***************************************************************************************************/
int _CRcompWindow(mmachine m)
{
	int tmp_res;
	int flags,contflags;
	int p_coordinates,p_objpere,p_container;
	int x,y,w,h;
	//$BLG - Del
	//int p_alphabmp
	//int transparency, bmpW, bmpH;
	//int x_inbitmap,y_inbitmap;
	//PtrObjBitmap bmp,abmp;
	CObjectWindow *new_object;
	CObjectBase *obj_root, *obj_father;
	container *co;
	//$BLG - Add
	int iTmrFrq;															// Timer's Refresh Frequenz (ms)
	int iWinCpt;															// VM ObjWin Ptr
	PtrObjVoid O;															// Void Object Ptr
	PtrObjWindow winCpt;											// Window Ptr for "Capture" Window
	HWND hwndCpt;															// Capture Window handler
	int iWinAX;																// VM ActiveX hosting ObjWin Ptr
	PtrObjWindow winAX;												// Window Ptr for ActiveX hosting Window
	HWND hwndAX;															// True ActiveX Window
	PtrObjBitmap B;														// Pointer for rendering bitmap
	int s, s2;																// Pointers used to instantiate the Layer ObjBitmap
	int l;																		// Size for 2 previous pointers


//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\n_CRcompWindow");
#endif
//***********************************


	// les differents tests de non validité
	//$BLG - Modif
	//if ((MMget(m,10))==NIL)
	if ((MMget(m, 8)) == NIL)
	{
		MMechostr(MSKTRACE, "_CRcompWindow: Channel is nil\n");
		//$BLG - Modif
		//m->pp += 10;
		m->pp += 8;
		MMset(m, 0, NIL);
		return 0;	
	}
	//$BLG - Modif
	//if ((MMget(m,9))==NIL)
	if ((MMget(m, 7)) == NIL)
	{
		MMechostr(MSKTRACE, "_CRcompWindow: ObjContainer is nil\n");
		//$BLG - Modif
		//m->pp += 10;
		m->pp += 8;
		MMset(m, 0, NIL);
		return 0;
	}
	//$BLG - Del
	/*
	if ((p_alphabmp=MTOP(MMget(m,4)))==NIL)
	{
		MMechostr(MSKTRACE,"_CRcompWindow: alphabitmap is nil\n");
		m->pp += 10;
		MMset(m,0,NIL);
		return 0;
	}
	if (GET_PTR_OBJ_BITMAP(GET_BMP(p_alphabmp))==NULL)
	{
		MMechostr(MSKTRACE,"_CRcompWindow: alphabitmap already destroyed\n");
		m->pp += 10;
		MMset(m,0,NIL);
		return 0;
	}
	*/
	//$BLG - Add
	if ((MMget(m, 2)) == NIL)
	{
		MMechostr(MSKTRACE,"_CRcompWindow: Host ObjWin is nil\n");
		m->pp += 8;
		MMset(m, 0, NIL);
		return 0;
	}
	

#if DEBUG_OBJNODE
		MMechostr(MSKTRACE,"DEBUG_OBJNODE _CRcompWindow\n");
#endif

	//$BLG - Modif
	// pile: Chn ObjContainer ObjNode [I I] I I AlphaBitmap I I I I
	// pile: Chn ObjContainer ObjNode [I I] I I ObjWin ObjWin I

	//$BLG - Add
	if ((iTmrFrq = MTOI(MMpull(m))) == NIL) iTmrFrq = 1000;
	
	//$BLG - Del
	/*
	if ((h=MTOI(MMpull(m)))==NIL) h = 0;
	if ((w=MTOI(MMpull(m)))==NIL) w = 0;
	if ((y_inbitmap=MTOI(MMpull(m)))==NIL) y_inbitmap = 0;
	if ((x_inbitmap=MTOI(MMpull(m)))==NIL) x_inbitmap = 0;
	*/
	
	//$BLG - Add
	// pile: Chn ObjContainer ObjNode [I I] I I ObjWin ObjWin
	iWinAX = MTOP(MMpull(m));
	O = (PtrObjVoid) MMstart(m, (iWinAX));
	winAX = (PtrObjWindow) MMstart(m, (O->Buffer>>1));
	hwndAX = NULL;
	if (winAX != NULL)
		EnumChildWindows((winAX->WHandler), (EnumChildProc), (long)(&hwndAX));
	
	//$BLG - Modif
	// pile: Chn ObjContainer ObjNode [I I] I I AlphaBitmap
	// pile: Chn ObjContainer ObjNode [I I] I I ObjWin
	
	//$BLG - Add
	iWinCpt = MTOP(MMpull(m));
	O = (PtrObjVoid) MMstart(m, (iWinCpt));
	winCpt = (PtrObjWindow) MMstart(m, (O->Buffer>>1));
	// pile: Chn ObjContainer ObjNode [I I] I I
	if (winCpt == NULL)
	{
		MMechostr(MSKTRACE, "_CRcompWindow: PtrObjWindow is null\n");
		m->pp += 5;
		MMset(m, 0, NIL);
		return 0;
	}
	hwndCpt = winCpt->WHandler;
	w = winCpt->TailleW - 2;		//Note: -2 is for Window capture adjustement
	h = winCpt->TailleH - 2;
	
	//$BLG - Del
	// on inverse l'AlphaBitmap et les coordonnees
	//INVERT( m, 0, 3 );

	//$BLG - Moved below (no invert)
	/*
	if ((p_coordinates=MTOP(MMpull(m)))==NIL)
	{
		x=0;
		y=0;
	}
	else
	{
		x=MTOI(MMfetch(m,p_coordinates,0));
		y=MTOI(MMfetch(m,p_coordinates,1));
	}
	*/
	
	if ((contflags = MTOI(MMpull(m))) == NIL) contflags = 0;
	
	if ((flags = MTOI(MMpull(m))) == NIL) flags = OBJ_ENABLE|OBJ_VISIBLE;
	
	//$BLG - Moved from above (no invert)
	if ((p_coordinates = MTOP(MMpull(m))) == NIL)
	{
		x = 0;
		y = 0;
	}
	else
	{
		x = MTOI(MMfetch(m, p_coordinates, 0));
		y = MTOI(MMfetch(m, p_coordinates, 1));
	}

	//$BLG - Modif
	// pile: Chn ObjContainer ObjNode AlphaBitmap
	// pile: Chn ObjContainer ObjNode
	
	//$BLG - Del
	/*
	p_alphabmp = MTOP( MMget( m, 0 ) );
	bmp =GET_PTR_OBJ_BITMAP(GET_BMP(p_alphabmp));
	abmp=GET_PTR_OBJ_BITMAP(GET_ABMP(p_alphabmp));

	if ((transparency = GET_TRANSP(p_alphabmp))==NIL) transparency = NO_TRANSPARENCY;
	
	// clip sur la taille reelle du bitmap
	bmpH = 0;
	bmpW = 0;
	if (bmp!= NULL)
	{
		if (abmp!=NULL)
		{
			bmpH = min( bmp->TailleH, abmp->TailleH );
			bmpW = min( bmp->TailleW, abmp->TailleW );
		}
		else
		{
			bmpH = bmp->TailleH;
			bmpW = bmp->TailleW;
		}
	}
	h = min( h, bmpH - y_inbitmap );
	w = min( w, bmpW - x_inbitmap );
	*/

	//$BLG - Modif
	//p_objpere = MTOP(MMget(m,1));
	//p_container = MTOP(MMget(m,2));
	//obj_father = GetObjectBase(m,p_objpere);
	p_objpere = MTOP(MMget(m, 0));
	p_container = MTOP(MMget(m, 1));
	obj_father = GetObjectBase(m, p_objpere);

	//$BLG - Modif
	// on inverse p_objpere et channel
	//INVERT( m, 1, 3 );
	INVERT(m, 0, 2);
	
	//$BLG - Modif
	// pile ObjNode ObjContainer Chn AlphaBitmap
	// pile: ObjNode ObjContainer Chn
	
	if ((p_objpere != NIL) && (obj_father == NULL))
	{
		MMechostr(MSKTRACE, "_CRcompWindow: object father already destroyed\n");
		//$BLG - Modif
		//m->pp += 3;
		m->pp += 2;
		MMset(m, 0, NIL);
		return 0;
	}
	else if ((co = RetrievePtrContainer(m, p_container)) == NULL)
	{
		MMechostr(MSKTRACE, "_CRcompWindow: container already destroyed\n");
		//$BLG - Modif
		//m->pp += 3;
		m->pp += 2;
		MMset(m, 0, NIL);
		return 0;
	}
	else if (!co->OwnsObject(obj_father))
	{
		MMechostr(MSKTRACE, "_CRcompWindow: father object was not created in this container!\n");
		//$BLG - Modif
		//m->pp += 3;
		m->pp += 2;
		MMset(m, 0, NIL);
		return 0;
	}
	else
	{
		// evaluation de l'Image
		Layer *layer;
		
		//$BLG - Modif
		/*
		if (bmp!=NULL)
			layer = new Layer(bmp,abmp,transparency);
		else
			layer = new Layer( w, h, transparency, abmp != NULL );
		*/

    l = (sizeof(struct ObjVoid) + 3) >> 2;
    s = MMmallocCLR(m, l, TYPETAB);
    if (s == NIL) return MERRMEM;
    if (MMpush(m, (s<<1)+1)) return MERRMEM;
    l = (sizeof(struct ObjBitmap) + 3) >> 2;
    s2 = MMmalloc(m, l, TYPEBUF);
    if (s2 == NIL) return MERRMEM;
    s = MMpull(m);
    O = (PtrObjVoid)MMstart(m, (s>>1));
    B = (PtrObjBitmap)MMstart(m, s2);
    O->Buffer = (s2<<1)+1;
    O->Tab = NIL ;
    O->Father = NIL ;
    O->Type = OBJ_TYPE_BITMAP << 1 ;	
		layer = new Layer(w, h, B);
		layer->fillLayer(0xffffff);
		MMpush(m, s);			// ObjBitmap
		//OBJcreate(m, OBJTYPBITMAP, (int)(layer->RGBbitmap->DIBhandler), 0, (int)NULL);   //Doesn't seem to be usefull ... not compilable ... maybe some memory flow ...

		obj_root = co->Root();
	
		//$BLG - Modif
		// creation du nouvel objet
		//new_object = new CObjectWindow(co, layer, x, y, x_inbitmap, y_inbitmap, w, h, bmp->TailleW, bmp->TailleH, flags, contflags, transparency);
		//new_object = new CObjectWindow(co, layer, x, y, w, h, flags, contflags, NO_TRANSPARENCY, winCpt, hwndAX, iTmrFrq);
		new_object = new CObjectWindow(co, layer, x, y, w, h, flags, contflags, NO_TRANSPARENCY, hwndCpt, hwndAX, iTmrFrq);
	
		//$BLG - Modif
		// ajout de l'objet et creation du nouvel OBJNODE
		//CHECK(AddNode(m, obj_root, obj_father, new_object, 1));
		//MMpush(m, NIL);  // <- ABMP required !!!! & not NIL !!!
		//MMpush(m, ITOM((int)(layer->RGBbitmap)));
		MMpush(m, NIL);		// AlphaBitmap
		MMpush(m, NIL);		// Bckgrd color
		MMpush(m, NIL);		// Transparency
		MMpush(m, ITOM(4));
		MBdeftab(m);
		CHECK(AddNode(m, obj_root, obj_father, new_object, 1));

		//$BLG - Modif
		// pile Pere Container ObjNode
		//$BLG Note: Etat précédent: ObjNode ObjContainer Chn AlphaBitmap, la pile ci dessus se décrypte: ObjNode Container NewObjNode
		// pile: ObjNode ObjContainer NewObjNode
		tmp_res = MMpull(m);
		MMpull(m);
		MMpull(m);
		CHECK(MMpush(m, tmp_res));

		//$BLG - Add
		//Previous version - kept as example and debug

		char str[256];
		HMODULE hUser32 = GetModuleHandle("user32");
    PROCINTERNALGETWINDOWTEXT InternalGetWindowText;
    InternalGetWindowText = (PROCINTERNALGETWINDOWTEXT)GetProcAddress(hUser32, "InternalGetWindowText");
    //InternalGetWindowText(winCpt->WHandler, (LPWSTR)str, 256);
    InternalGetWindowText(hwndCpt, (LPWSTR)str, 256);
    //MMechostr(0,"Host: %d %S<\n", (long)(winCpt->WHandler), str);
    MMechostr(0,"Host: %d %S<\n", (long)(hwndCpt), str);
		
		MMechostr(0,">> %d\n", (new_object->CWin_hwndAX));
		//EnumChildWindows((winCpt->WHandler), (DBG_EnumChildProc), (long)(&(new_object->CWin_hwndAX))); 
		EnumChildWindows((hwndCpt), (DBG_EnumChildProc), (long)(&(new_object->CWin_hwndAX))); 
		MMechostr(0,"<< %d\n", (new_object->CWin_hwndAX));
		
		new_object->CWin_tmrID = new_object->Container()->Register(new_object->CWin_tmrFR, new_object);
		new_object->Timer(new_object->CWin_tmrID);

#if DEBUG_OBJNODE
	PrintTree(m,0,FindObjNodeFromHdlSys(m,(int)obj_root));
#endif


	}

//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\n_CRcompWindow end");
#endif
//***********************************

	return 0;
}




int _DScompWindow(mmachine m)
{
	int p, tmp_res;

//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\n_DScompWindow");
#endif
//***********************************


	if ((p = MTOP(MMpull(m))) != NIL)
	{
		DsNode(m, p);
		CHECK(MMpush(m, MTOI(0)));
	}
	else
		CHECK(MMpush(m, NIL));

//***********************************
#if DEBUG_LIB2D
MMechostr (0, "\n_DScompWindow end");
#endif
//***********************************

	return 0;
}




int _CONVERTcompWindowToObjNode(mmachine m)
{
	return 0;
}

int _CBcompWindowCursorMove(mmachine m)
{
	return OBJaddreflex(m,OBJNODE,RFLOBJNODE_CURSORMOVE);
}

int _CBcompWindowClick(mmachine m)
{
	return OBJaddreflex(m,OBJNODE,RFLOBJNODE_CLICK);
}

int _CBcompWindowUnClick(mmachine m)
{
	return OBJaddreflex(m,OBJNODE,RFLOBJNODE_UNCLICK);
}

int _CBcompWindowDblClick(mmachine m)
{
	return OBJaddreflex(m,OBJNODE,RFLOBJNODE_DBLCLICK);
}

int _CBcompWindowResizeResource(mmachine m)
{
	return OBJaddreflex(m,OBJNODE,RFLOBJNODE_RESIZE_RESSOURCE);
}

int _CBcompWindowResize(mmachine m)
{
	return OBJaddreflex(m,OBJNODE,RFLOBJNODE_RESIZE);
}


#endif //USE_WINDOWS