aview-app 1.0.2

package/aardio/lib/win/region/bitmap/.res/build.aardio

@@ -0,0 +1,257 @@
+var c = /****   
+#include <windows.h> 
+ 
+/*
+该函数原作者 Jean-Edouard Lachand-Robert 
+http://www.codeguru.com/member.php/Jean-Edouard+Lachand+Robert/
+*/
+
+#include <math.h>
+__declspec(dllexport) HRGN BitmapToRegion (HBITMAP hBmp, BOOL autoTransparent,COLORREF cTransparentColor , COLORREF cTransparentColor2, COLORREF cStepTolerance )
+{ 
+	HRGN hRgn = NULL; 
+	//FILE * stdout2;
+	//freopen_s(&stdout2,"CONOUT$","w+t",stdout); 
+	
+	if (hBmp)
+	{
+		// Create a memory DC inside which we will scan the bitmap content
+		HDC hMemDC = CreateCompatibleDC(NULL);
+		if (hMemDC)
+		{
+			// Get bitmap size
+			BITMAP bm;
+			GetObject(hBmp, sizeof(bm), &bm);
+
+			// Create a 32 bits depth bitmap and select it into the memory DC 
+			BITMAPINFOHEADER RGB32BITSBITMAPINFO = {	
+					sizeof(BITMAPINFOHEADER),	// biSize 
+					bm.bmWidth,					// biWidth; 
+					bm.bmHeight,				// biHeight; 
+					1,							// biPlanes; 
+					32,							// biBitCount 
+					BI_RGB,						// biCompression; 
+					0,							// biSizeImage; 
+					0,							// biXPelsPerMeter; 
+					0,							// biYPelsPerMeter; 
+					0,							// biClrUsed; 
+					0							// biClrImportant; 
+			};
+			VOID * pbits32; 
+			HBITMAP hbm32 = CreateDIBSection(hMemDC, (BITMAPINFO *)&RGB32BITSBITMAPINFO, DIB_RGB_COLORS, &pbits32, NULL, 0);
+			if (hbm32)
+			{
+				HBITMAP holdBmp = (HBITMAP)SelectObject(hMemDC, hbm32);
+
+				// Create a DC just to copy the bitmap into the memory DC
+				HDC hDC = CreateCompatibleDC(hMemDC);
+				if (hDC)
+				{
+					// Get how many bytes per row we have for the bitmap bits (rounded up to 32 bits)
+					BITMAP bm32;
+					GetObject(hbm32, sizeof(bm32), &bm32);
+					while (bm32.bmWidthBytes % 4)
+						bm32.bmWidthBytes++;
+
+					// Copy the bitmap into the memory DC
+					HBITMAP holdBmp = (HBITMAP)SelectObject(hDC, hBmp);
+					BitBlt(hMemDC, 0, 0, bm.bmWidth, bm.bmHeight, hDC, 0, 0, SRCCOPY);
+
+					// For better performances, we will use the ExtCreateRegion() function to create the
+					// region. This function take a RGNDATA structure on entry. We will add rectangles by
+					// amount of ALLOC_UNIT number in this structure.
+					#define ALLOC_UNIT	100
+					DWORD maxRects = ALLOC_UNIT;
+					HANDLE hData = GlobalAlloc(GMEM_MOVEABLE, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects));
+					RGNDATA *pData = (RGNDATA *)GlobalLock(hData);
+					pData->rdh.dwSize = sizeof(RGNDATAHEADER);
+					pData->rdh.iType = RDH_RECTANGLES;
+					pData->rdh.nCount = pData->rdh.nRgnSize = 0;
+					SetRect(&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
+
+					// Keep on hand highest and lowest values for the "transparent" pixels
+					BYTE lrHead = GetRValue(cTransparentColor);
+					BYTE lgHead = GetGValue(cTransparentColor);
+					BYTE lbHead = GetBValue(cTransparentColor);
+					BYTE lrPrev = lrHead;
+					BYTE lgPrev = lgHead;
+					BYTE lbPrev = lbHead;
+					BYTE hrHead = min(0xff, GetRValue(cTransparentColor2));
+					BYTE hgHead = min(0xff, GetGValue(cTransparentColor2));
+					BYTE hbHead = min(0xff, GetBValue(cTransparentColor2));
+					BYTE hrStep = min(0xff, GetRValue(cStepTolerance));
+					BYTE hgStep = min(0xff, GetGValue(cStepTolerance));
+					BYTE hbStep = min(0xff, GetBValue(cStepTolerance));
+					 
+					// Scan each bitmap row from bottom to top (the bitmap is inverted vertically)
+					BYTE *p32 = (BYTE *)bm32.bmBits + (bm32.bmHeight - 1) * bm32.bmWidthBytes;
+					BYTE *pbyte = p32;
+					if( autoTransparent  ){
+						BYTE *p = (BYTE *)bm32.bmBits;
+						lbHead = *pbyte++;
+						hbHead = *p++;
+						lgHead = *pbyte++;
+						hgHead = *p++;
+						lrHead = *pbyte++;
+						hrHead = *p++;
+					}
+					
+					BYTE temp;
+					if( lbHead > hbHead ){
+						temp = lbHead;
+						lbHead =hbHead;
+						hbHead =temp;
+					} 
+					if( lgHead > hgHead ){
+						temp = lgHead;
+						lgHead =hgHead;
+						hgHead =temp;
+					} 
+					if( lrHead > hrHead ){
+						temp = lrHead;
+						lrHead =hrHead;
+						hrHead =temp;
+					}  
+					
+					int y;
+					BYTE r,g,b;  
+					int ncr = cStepTolerance ? 2 : 0;
+					for ( y = 0; y < bm.bmHeight; y++)
+					{ 
+						int x;
+						for ( x = 0; x < bm.bmWidth; x++)
+						{ 
+							int x0 = x;
+							LONG *p = (LONG *)p32 + x;
+						
+							while (x < bm.bmWidth)
+							{   
+							 	if( cStepTolerance ){
+									pbyte = (BYTE *)p;
+									b = *pbyte++; 
+									if ( abs( b - lbPrev ) <= (hbStep)  )
+									{ 
+										g = *pbyte++;
+										if ( abs( g - lgPrev ) <= (hgStep) )
+										{
+											r = *pbyte++;
+											if ( abs( r - lrPrev ) <= (hrStep) ){ 
+												lrPrev = r;
+												lgPrev = g;
+												lbPrev = b;
+												break;
+											}
+										}  
+									} 
+								}
+							  
+								pbyte = (BYTE *)p;
+								b = *pbyte++; 
+								if ( b <=  hbHead+hbStep  && b+hbStep >=  lbHead )
+								{ 
+									g = *pbyte++;
+									if ( g <= hgHead+hgStep  && g+hgStep >=  lgHead )
+									{
+										r = *pbyte++;
+										if ( r <= hrHead+hrStep  && r+hrStep >=  lrHead )
+										{
+											lrPrev = r;
+											lgPrev = g;
+											lbPrev = b;
+											break;
+										}
+									}  
+								} 
+								 
+								p++;
+								x++;
+							}  
+							
+							if ( x > x0 + ncr ) {
+								// Add the pixels (x0, y) to (x, y+1) as a new rectangle in the region
+								if (pData->rdh.nCount >= maxRects)
+								{
+									GlobalUnlock(hData);
+									maxRects += ALLOC_UNIT;
+									hData = GlobalReAlloc(hData, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), GMEM_MOVEABLE);
+									pData = (RGNDATA *)GlobalLock(hData);
+								}
+								RECT *pr = (RECT *)&pData->Buffer;
+								SetRect(&pr[pData->rdh.nCount], x0, y, x, y+1);
+								if (x0 < pData->rdh.rcBound.left)
+									pData->rdh.rcBound.left = x0;
+								if (y < pData->rdh.rcBound.top)
+									pData->rdh.rcBound.top = y;
+								if (x > pData->rdh.rcBound.right)
+									pData->rdh.rcBound.right = x;
+								if (y+1 > pData->rdh.rcBound.bottom)
+									pData->rdh.rcBound.bottom = y+1;
+								pData->rdh.nCount++;
+
+								// On Windows98, ExtCreateRegion() may fail if the number of rectangles is too
+								// large (ie: > 4000). Therefore, we have to create the region by multiple steps.
+								if (pData->rdh.nCount == 2000)
+								{
+									HRGN h = ExtCreateRegion(NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), pData);
+									if (hRgn)
+									{
+										CombineRgn(hRgn, hRgn, h, RGN_OR);
+										DeleteObject(h);
+									}
+									else
+										hRgn = h;
+									pData->rdh.nCount = 0;
+									SetRect(&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
+								}
+							}
+						}
+
+						// Go to next row (remember, the bitmap is inverted vertically)
+						p32 -= bm32.bmWidthBytes;
+					}
+
+					// Create or extend the region with the remaining rectangles
+					HRGN h = ExtCreateRegion(NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), pData);
+					if (hRgn)
+					{
+						CombineRgn(hRgn, hRgn, h, RGN_OR);
+						DeleteObject(h);
+					}
+					else
+						hRgn = h;
+
+					// Clean up
+					SelectObject(hDC, holdBmp);
+					DeleteDC(hDC);
+					
+					GlobalUnlock(hData);
+					GlobalFree(hData);
+				}
+
+				DeleteObject(SelectObject(hMemDC, holdBmp));
+			}
+
+			DeleteDC(hMemDC);
+		}	
+	}
+
+	return hRgn;
+}
+****/
+
+import console;
+import tcc;  
+vm = tcc(); 
+  
+vm.addLib( 
+	"user32",
+	"kernel32",
+	"gdi32"
+)
+
+vm.onError = function(msg){
+ 	console.log( msg )
+}
+vm.output( "/c.dll", c  )//编译C源码,生成DLL  
+vm.close();  
+   

package/aardio/lib/win/region/bitmap/_.aardio

@@ -0,0 +1,108 @@
+import win;
+import com.picture;
+import win.region;
+namespace win.region;
+
+class bitmap { 
+
+	ctor( hBmp,transparentColor1,transparentColor2=0,stepTolerance=0x050505){ {
+	
+		this.updateWindow = function( hwnd,bRedraw = true,copy){
+			if(!this.hRegion) return;
+			
+			hwnd = hwnd || this.hwnd ;
+			if(!hwnd) error("请指定句柄参数",2)
+			
+			if(  ::SetWindowRgn( hwnd || this.hwnd  ,this.hRegion,bRedraw) ){
+				this.hRegion = copy ? ..win.region.getWindowRgn(hwnd) : null;
+			}
+		}  
+		
+		var tArg1 = type(hBmp);
+		if( tArg1 == "string" ){
+			this.hRegion = createFromFile(hBmp,transparentColor1,transparentColor2,stepTolerance);
+			if( type(this.hRegion) != "pointer" ){
+				error("参数@1指定了无效位图",2)
+			}  
+		}
+		elseif( tArg1 == "pointer") {
+			this.hRegion = BitmapToRegion(hBmp,transparentColor1===null
+				,transparentColor1:0,transparentColor2,stepTolerance); 
+				
+			if( type(this.hRegion) != "pointer" ){
+				error("参数@1指定了无效位图",2)
+			}  
+		} 
+		elseif( tArg1 == "table" && hBmp.hwnd ){ 
+			
+			var form = hBmp;
+			if( ..win.getStyle(form.hwnd,0x800000/*_WS_BORDER*/) ) error("请设置窗体属性为无边框样式",2);
+			
+			form.enableDpiScaling("init");
+			var hBmp =  form.background.getCacheBitmap(); 
+			if(!hBmp) error("窗体未设置背景图或已修改默认背景绘图功能",2);
+			 
+    		var pic = ..com.picture.fromBitmap(hBmp,false); 
+    		
+			var hBmp = pic.CopyHandle();
+			this = ..win.region.bitmap( hBmp,transparentColor1,transparentColor2,stepTolerance )
+			::DeleteObject(hBmp);
+			..com.Release(pic);
+
+			if( this.hRegion ){
+				this.hwnd = form.hwnd; 
+				this.updateWindow(); 
+			}
+			
+			return this;
+		} 
+		 
+		..table.gc(this,"delete");
+	} };
+	
+	restore = function(){
+		if(!this.hwnd) return;
+		
+		var hwnd = this.hwnd;
+		if( hwnd ){
+			if(!this.hRegion){
+				this.hRegion = ..win.region.getWindowRgn( hwnd ) 
+				::SetWindowRgn( hwnd ,null ); 
+				::RedrawWindow(hwnd,{},null,0x105 /*_RDW_INVALIDATE | _RDW_UPDATENOW  | _RDW_ERASE*/); 
+			}
+			else {
+				this.updateWindow(); 
+			}
+		}
+	}
+	
+	delete = function(){
+		if(this.hRegion){
+			::DeleteObject( this.hRegion );
+			this.hRegion = null;
+		}
+	}  
+}
+
+namespace bitmap{
+	var dll = ..raw.loadDll( $"~/lib/win/region/bitmap/.res/c.dll","regionBitmap.dll" );   
+	BitmapToRegion = dll.api( "BitmapToRegion","pointer(POINTER hBmp,bool autoTransparent,int transparentColor1,int transparentColor2,int stepTolerance)", "cdecl" );    
+
+	createFromFile = function(path,transparentColor1,transparentColor2,stepTolerance){
+		var pic = ..com.picture.load(path); 
+		if( !pic )  return null,"无效的位图";
+		var hRgn = BitmapToRegion(pic.Handle,transparentColor1===null,transparentColor1:0,transparentColor2,stepTolerance);  
+		..com.Release(pic);
+		return hRgn;
+	} 
+}
+
+/**intellisense()
+win.region.bitmap = 使用位图创建窗体绘图区域
+win.region.bitmap( = 创建窗体显示区域
+win.region.bitmap(.(窗体,透明色,透明色2,容差) = 参数@1也可以是位图或位图句柄,\n参数@1指定窗体时可自动获取运行时绘制的窗口背景图，并支持DPI自动缩放，\n参数透明色,透明色2指定透明范围\n如果不指定透明色则自动获取\n如果是黑白二色的掩码位图,容差请设置为 0
+win.region.bitmap() = !winRgnBitmap.
+!winRgnBitmap.restore() = 恢复最后一次设置绘图区域的窗口到默认值
+!winRgnBitmap.delete() = 删除对象\n不需要调用此函数
+!winRgnBitmap.updateWindow(.(窗体句柄,是否重绘,是否备份HRGN) = 设置为窗体的绘图区域,该函数不可重复调用\n如果创建区域时指定了窗体,可以省略参数1,\n参数2为可选参数,默认为true\n\n默认此函数执行后HRGN交由窗体管理生存期,并清空HRGN句柄,\n如果需要设置多个窗口,必须指定第3个参数为true
+end intellisense**/

package/aardio/lib/win/region/hole.aardio

@@ -0,0 +1,56 @@
+//hole 挖空
+namespace win.region;
+
+class hole{
+	ctor( ctrl ){
+		if(!( ctrl[["hwnd"]] && ctrl.getParent()  ) ){
+			error("参数必须指定控件窗口",2)
+		}
+		
+		ctrl.hide = true;
+		ctrl.adjust = function(){
+			if(this.enabled) diffRectRgn(ctrl.getParent(),ctrl);
+		} 
+		
+		this.enabled = true;
+		diffRectRgn(ctrl.getParent(),ctrl);
+	};
+	enable = function(enabled){
+		this.enabled = enabled;
+		ctrl.hide = enabled;
+		
+		if(enabled){
+			diffRectRgn(ctrl.getParent(),ctrl);
+		}
+		else {
+			::User32.SetWindowRgn(ctrl.getParent().hwnd,null,true);
+		}
+	};
+}
+
+namespace hole{ 
+	
+	diffRectRgn = function (winform,ctrl) {
+    	var rcForm = winform.getRect(true);
+   		var rcCtrl = ctrl.getRect(true);
+   		rcCtrl.offset(-rcForm.left,-rcForm.top);
+   		rcForm.offset(-rcForm.left,-rcForm.top);
+   		
+    	var hRgnForm = ::Gdi32.CreateRectRgn( rcForm.ltrb() );
+    	var hRgnCtrl = ::Gdi32.CreateRectRgn( rcCtrl.ltrb() );
+    	var hRgnNew  = ::Gdi32.CreateRectRgn(0,0,1,1);
+   	
+    	::Gdi32.CombineRgn(hRgnNew,hRgnForm,hRgnCtrl,0x4/*_RGN_DIFF*/);
+    	::User32.SetWindowRgn(winform.hwnd,hRgnNew,true);
+   	
+    	::Gdi32.DeleteObject(hRgnForm);
+    	::Gdi32.DeleteObject(hRgnCtrl);
+	}; 
+}
+
+/**intellisense()
+win.region.hole = 用于挖空控件窗口所在区域
+win.region.hole(__) = 参数指定控件对象,\n自动挖空控件窗口所在区域,\n控件可指定自适应大小、固定边距等参数,\n控件的父窗口建议设为无边框,\n可使用 win.ui.simpleWindow 等创建自定义边框
+win.region.hole() = !winRegionHole.
+!winRegionHole.enable(__) = 参数可使用 true 或 false 指定是否挖空控件窗口所在区域
+end intellisense**/

package/aardio/lib/win/region/png/.res/build.aardio

@@ -0,0 +1,41 @@
+var c = /****
+#include <windows.h>  
+__declspec(dllexport) HRGN PngDataScan0ToRegion (UINT *pDataScan0,INT imgWidth,INT imgHeight)
+{ 
+    HRGN hRgn = CreateRectRgn(0, 0, 0, 0);
+    for (UINT h = 0; h < imgHeight; ++ h)
+    {
+        UINT right = 0;
+        while(right < imgWidth)
+        {
+            UINT left = right;
+            while (left ++ < imgWidth && !(*pDataScan0 ++ & 0xFF000000) );
+
+            right = left; 
+            while (right ++ < imgWidth && (*pDataScan0 ++ & 0xFF000000) ); 
+
+            HRGN hRgnBlock = CreateRectRgn(left, h, right - 1, h + 1);
+            CombineRgn(hRgn, hRgn, hRgnBlock, RGN_OR);
+			DeleteObject(hRgnBlock); 
+        }
+    }
+
+    return hRgn;
+}
+****/
+
+import console;
+import tcc;  
+vm = tcc(); 
+  
+vm.addLib( 
+	"gdi32"
+)
+
+vm.onError = function(msg){
+ 	console.log( msg )
+}
+vm.output( "/c.dll", c  )//编译C源码,生成DLL  
+vm.close();  
+console.pause()
+   

package/aardio/lib/win/region/png/_.aardio

@@ -0,0 +1,108 @@
+import win;
+import win.region;
+
+namespace win.region;
+
+class png { 
+
+	ctor(bmpOrForm,bmpPath){ {
+	
+		this.updateWindow = function( hwnd,bRedraw = true,copy){
+			if(!this.hRegion) return;
+			
+			hwnd = hwnd || this.hwnd ;
+			if(!hwnd) error("请指定句柄参数",2)
+			
+			if(  ::SetWindowRgn( hwnd,this.hRegion,bRedraw) ){
+				this.hRegion = copy ? ..win.region.getWindowRgn(hwnd) : null;
+			}
+		} 
+		
+		if( ..gdip.bitmap.is(bmpOrForm)  ) {
+			this.hRegion = createFromBitmap( bmp ); 
+				
+			if( type(this.hRegion) != "pointer" ){
+				error("参数@1指定了无效位图",2)
+			}  
+		} 
+		elseif( bmpOrForm[["hwnd"]] && bmpOrForm.background){ 
+			var form = bmpOrForm;
+			var bmp = bmpPath ? ..gdip.bitmap(bmpPath) : form.background.getLayeredBitmap();
+			if(!bmp) error("请先设置窗体背景图为png图像",2);
+			
+			if( ..win.getStyle(form.hwnd,0x800000/*_WS_BORDER*/) ) error("请设置窗体属性为无边框样式",2)
+			this.hRegion = createFromBitmap( bmp );
+			this.hwnd = form.hwnd; 
+			
+			//禁止九宫格拉伸
+			form.bkLeft = null;
+			form.bkTop = null;
+			form.bkRight = null;
+			form.bkBottom = null;
+
+			if( this.hRegion ){
+				form.setBitmap(bmp.copyHandle())
+				this.updateWindow(); 
+			}
+		} 
+		else{
+			var bmp = ..gdip.bitmap(bmpOrForm)
+			this.hRegion = createFromBitmap(bmp);
+			if( type(this.hRegion) != "pointer" ){
+				error("参数@1指定了无效位图",2)
+			}  
+		}
+		 
+		..table.gc(this,"delete");
+	} };
+	
+	restore = function(){
+		if(!this.hwnd) return;
+		
+		var hwnd = this.hwnd;
+		if( hwnd ){
+			if(!this.hRegion){
+				this.hRegion = ..win.region.getWindowRgn( hwnd ) 
+				::SetWindowRgn( hwnd ,null ); 
+				::RedrawWindow(hwnd,{},null,0x105 /*_RDW_INVALIDATE | _RDW_UPDATENOW  | _RDW_ERASE*/); 
+			}
+			else {
+				this.updateWindow(); 
+			}
+			
+		}
+	}
+	
+	delete = function(){
+		if(this.hRegion){
+			::DeleteObject( this.hRegion );
+			this.hRegion = null;
+		}
+	}  
+}
+
+namespace png{
+	var dll = ..raw.loadDll( $"~/lib/win/region/png/.res/c.dll","win.region.png.dll" );   
+	PngDataScan0ToRegion = dll.api( "PngDataScan0ToRegion","pointer(ptr pDataScan0,INT imgWidth,INT imgHeight)", "cdecl" );    
+
+	createFromBitmap = function(bmp){  
+		if(!bmp)return;
+		
+		var data  = bmp.lockMemory(,0x26200A/*_PixelFormat32bppARGB*/,1/*_GdipImageLockModeRead*/) 
+		var hRgn  = PngDataScan0ToRegion(data.Scan0,data.Width,data.Height) 
+		bmp.unlockMemory(data);
+		return hRgn;
+	} 
+}
+  
+/**intellisense()
+win.region.png = 使用位图创建窗体绘图区域
+win.region.png( = 创建窗体显示区域
+win.region.png(.(窗体,图像路径) = 创建显示区域并显示png图像,\n如果省略图像路径，窗体必须事先指定背景图像,\n此函数会自动禁用九宫格拉伸,\n仅支持透明或不透明色,不支持半透明色
+win.region.png(.(png图像文件路径或数据) = 创建GDI+位图对象并使用该位图创建显示区域,\n参数用法与gdip.bitmap相同,
+win.region.png(.(位图) = 使用参数传入的gdip.bitmap位图对象创建显示区域
+win.region.png() = !winRgnPng.
+!winRgnPng.restore() = 恢复最后一次设置绘图区域的窗口到默认值
+!winRgnPng.delete() = 删除对象\n不需要调用此函数
+!winRgnPng.updateWindow(.(窗体句柄,是否重绘,是否备份HRGN) = 设置为窗体的绘图区域,该函数不可重复调用\n如果创建区域时指定了窗体,可以省略参数1,\n参数2为可选参数,默认为true\n\n默认此函数执行后HRGN交由窗体管理生存期,并清空HRGN句柄,\n如果需要设置多个窗口,必须指定第3个参数为true
+end intellisense**/

package/aardio/lib/win/region/round.aardio

@@ -0,0 +1,69 @@
+//round 圆角无边框窗口
+import gdi;
+import win.region;
+import win.ui.minmax;
+namespace win.region; 
+
+class round { 
+    ctor(winform,minX,minY,wEllipse,hEllipse){   
+		this = winform
+		var maxminInfo = ..win.ui.minmax(winform,minX,minY);
+		 
+		roundRectRgn(winform,wEllipse,hEllipse);
+		winform.adjust = function(cx,cy,wParam){
+			if(  wEllipse <=0  || hEllipse <=0 ) return;
+			
+			if( wParam != 0x2/*_SIZE_MAXIMIZED*/ ){ 
+				roundRectRgn(winform, wEllipse,hEllipse);
+			}
+			else {
+				::SetWindowRgn( winform.hwnd,  , true );
+			} 
+		}; 
+		
+		if( ! ( winform._layout || winform.hasBackground ) ){
+			winform.onEraseBkgnd = function(hwnd,message,wParam,lParam){
+    			return 0;
+			};
+		};
+    };
+    setEllipse = function(w,h){ 
+    	if( w > 0 && h > 0 ){
+    		wEllipse,hEllipse = w,h;
+    		roundRectRgn(winform, wEllipse,hEllipse);
+    	}
+    	else {
+    		wEllipse,hEllipse = w,h;
+			::SetWindowRgn( winform.hwnd,  , true );
+		} 
+    };
+    setMinTrackSize = function(minX,minY){ 
+    	with maxminInfo.minTrackSize{
+    		x = minX;
+    		y = minY;
+    	} 
+    }; 
+}
+
+namespace round{ 
+	roundRectRgn = function (winform,wEllipse=4,hEllipse=4) {
+		if( ! (wEllipse && hEllipse) ) return;
+		var rc = winform.getRect();
+		var hRgn = ::CreateRoundRectRgn(
+			0, 0, 
+			rc.right - rc.left + 1, 
+			rc.bottom - rc.top + 1,
+			wEllipse, hEllipse
+		);
+		::SetWindowRgn( winform.hwnd, hRgn, 1 );
+	}; 
+}
+
+/**intellisense()
+win.region.round( = 创建一个圆角无边框窗口\n最大化自动取消圆角
+win.region.round(.(winform,窗体最小宽度,高度,圆角宽度,高度)  =  除第一个参数以外,其他参数可选,\n默认取窗体当前大小为最小大小,\n圆角宽高默认都是4个像素
+win.region.round() = !roundform.
+!roundform.setMinTrackSize(.(窗体最小宽度,高度) = 设置窗体最小宽度,高度
+!roundform.setEllipse(.(圆角宽度,圆角高度) = 重新设置圆角大小
+win.region.round = 圆角无边框窗口支持库
+end intellisense**/

package/aardio/lib/win/region/transparent.aardio

@@ -0,0 +1,38 @@
+//transparent 透明控件窗口
+namespace win.region;
+
+class transparent{
+	ctor(ctrl,diff){{
+		var parent = ctrl[["_parentForm"]];
+		if(!parent){
+			error("参数必须指定子窗口",2)
+		}
+		
+		var transparent = function(){
+			var rc = ..win.getRect(parent.hwnd)
+			var rgnParent = ::Gdi32.CreateRectRgn(0,0,rc.width(),rc.height());
+			
+			var rc = ..win.getRect(ctrl.hwnd)
+			var rgChild = ::Gdi32.CreateRectRgn(rc.left,rc.top,rc.width(),rc.height());
+			var rgnNew  = ::Gdi32.CreateRectRgn(0,0,0,0);
+		
+			::Gdi32.CombineRgn(rgnNew,rgnParent,rgChild,(diff===null||diff) ? 4/*_RGN_DIFF*/ : 2/*_RGN_OR*/);
+			::User32.SetWindowRgn(parent.hwnd,rgnNew,true);
+		
+			::Gdi32.DeleteObject(rgnParent);
+			::Gdi32.DeleteObject(rgChild);			
+		}
+			
+		parent.adjust = function(cx,cy,wParam){
+			transparent();
+		}; 
+		
+		transparent();
+	}}; 
+}
+
+/**intellisense(win.region)
+transparent = 透明控件窗口
+transparent(.(ctrl) =  设置控件窗口为透明区域
+transparent(.(ctrl,false) =  恢复控件窗口为不透明区域
+end intellisense**/