aview-app 1.0.2

package/aardio/lib/gdip/imageAttributes.aardio

@@ -0,0 +1,143 @@
+//imageAttributes 图像属性
+import gdip.core;
+namespace gdip;
+var gdip = ..gdip;
+
+class imageAttributes {
+
+	ctor(){ {
+		var ia = {ptr handle}
+		var err  = ::Gdiplus.GdipCreateImageAttributes(ia) 
+		if(err) return null,gdip.errMsg[err]; 
+		this.pImgAttr = ia.handle; 
+		
+		..table.gc(this,"dispose");
+	} }
+
+	@_metaProperty//元表指向属性表
+}
+
+namespace imageAttributes {
+
+	_metaProperty = ..util.metaProperty(
+		setNegativeMatrix = function(){
+			owner.setColorMatrix({
+				-1;0;0;0;0;
+				0;-1;0;0;0;
+				0;0;-1;0;0;
+				0;0;0;1;0;
+				1;1;1;0;1;
+			})	
+		};
+		setAlphaMatrix = function(a){
+			owner.setColorMatrix({
+				1;0;0;0;0;
+				0;1;0;0;0; 
+				0;0;1;0;0;
+				0;0;0;a;0;
+				0;0;0;0;1;
+			})
+		};
+		setRgba = function(r=1,g=1,b=1,a=1){
+			owner.setColorMatrix({
+				r;0;0;0;0;
+				0;g;0;0;0; 
+				0;0;b;0;0;
+				0;0;0;a;0;
+				0;0;0;0;1;
+			})	
+		};
+		setColor = function(c){
+			var r,g,b,a = c>> 16 & 0xFF, c>> 8  & 0xFF,c  & 0xFF,c>> 24 & 0xFF;
+	 
+			owner.setColorMatrix({
+				0;0;0;0;0;
+				0;0;0;0;0; 
+				0;0;0;0;0;
+				0;0;0;a/255;0;
+				r/255;g/255;b/255;0;1;
+			})	
+		};
+		setColorMatrix = function(colorMatrix,grayMatrix,adjustType){
+			var flags = 0;
+			if(grayMatrix){
+				flags = 2/*_ColorMatrixFlagsAltGray*/;
+				if( type(grayMatrix)!="table" || #grayMatrix!=25 ){
+					error("参数@2应指定长度为25的数组",2)
+				}
+				grayMatrix = {float v[25] = grayMatrix }
+			}
+			elseif( grayMatrix === false ){
+				 flags = 1/*_ColorMatrixFlagsSkipGrays*/
+				 grayMatrix = null;
+			}
+			
+			if( type(colorMatrix)!="table" || #colorMatrix!=25 ){
+				if(!colorMatrix){
+					::Gdiplus.GdipSetImageAttributesColorMatrix(owner[["pImgAttr"]],adjustType,false,null,null,0);
+					return;
+				}
+				error("参数@1应指定长度为25的数组",2);
+			}
+			
+			colorMatrix = {float v[25] = colorMatrix }
+			gdip.assert2( ::Gdiplus.GdipSetImageAttributesColorMatrix(owner[["pImgAttr"]],adjustType,true,colorMatrix,grayMatrix,flags) );
+		};
+		setRemapTable = function(map,adjustType){
+			var flags = 0; 
+			
+			if( type(map)!="table" || ( #map/2) < 1  ){
+				if(!map){
+					::Gdiplus.GdipSetImageAttributesRemapTable(owner[["pImgAttr"]],adjustType,false,0,null);
+					return;
+				}
+				error("参数@1应指定为包含成对颜色值的数组",2);
+			}
+			
+			gdip.assert2( ::Gdiplus.GdipSetImageAttributesRemapTable(owner[["pImgAttr"]],adjustType,true,#map/2,{int colors[] = map}) );
+		}; 
+		setColorKey = function(colorLow,colorLowHigh,adjustType){
+			var enable = colorLow!==null ? true  
+			if( colorLowHigh === null ) colorLowHigh = colorLow;
+			gdip.assert2( ::Gdiplus.GdipSetImageAttributesColorKeys(owner[["pImgAttr"]]
+				,adjustType,colorLow!==null ? true,colorLow,colorLowHigh ) );
+		};
+		reset = function(adjustType){
+			gdip.assert2( ::Gdiplus.GdipResetImageAttributes(owner[["pImgAttr"]],adjustType));
+		} 
+		dispose = function(){
+			if( owner[["pImgAttr"]] ){
+				::Gdiplus.GdipDisposeImageAttributes(owner[["pImgAttr"]])
+				owner[["pImgAttr"]] = null;
+			}
+		} 
+		_topointer = function(){
+			return owner[["pImgAttr"]];
+		}
+	)  
+}
+
+/**intellisense()
+gdip.imageAttributes = 图像显示属性控制
+gdip.imageAttributes() = 创建图像显示属性控制对象\n!gdip_imgattr.
+end intellisense**/
+
+/**intellisense(!gdip_imgattr)
+setAlphaMatrix(__) = 设置透明度调色矩阵,\n参数使用表示百分比的小数，例如0.5为Alpha分量调整至50%
+setNegativeMatrix(__) = 设置反相调色矩阵
+setRgba(.(r,g,b,a) = 设置r,g,b,a分量的变化比例,\n参数使用表示百分比的小数，例如0.5表示对应分量调整至50%,\n所有参数可选，默认值都是1
+setColor(.(color) = 替换所有非完全透明的颜色，\参数 @color 指定 RGBA 格式的颜色数值
+setColorMatrix(colorMatrix,grayMatrix,adjustType) = @.setColorMatrix({
+	1;0;0;0;0;
+	0;1;0;0;0;
+	0;0;1;0;0;
+	0;0;0;1;0;
+	0;0;0;0;1__/*colorMatrix为null取消调色矩阵\ngrayMatrix可省略,设为false时忽略灰度,也可以指定一个灰度矩阵\nadjustType使用_GdipColorAdjustType前缀的常量指定,省略则默认为0*/
+})
+setRemapTable(colorMap,adjustType) = @.setRemapTable({
+	0xFF00FFFF;0xFFFF0000__/*ccolorMap为null取消颜色映射表\n颜色映射表包含成对的颜色值数组,每一对颜色值使用后面的颜色替换前面的颜色,\nadjustType使用_GdipColorAdjustType前缀的常量指定,省略则默认为0*/
+})
+setColorKey(.(clr1,clr2,adjustType) = 参数@1指定透明色,\n可选使用参数@2指定另一个透明色以确定透明色范围,\n参数@3可选使用_gdipColorAdjustType前缀的常量指定选项
+reset(.(adjustType) = 清除所有设置,adjustType为可选参数
+dispose() = 释放对象，\n内存回收时会自动调用此函数，\n重复调用此函数将自动忽略
+end intellisense**/

package/aardio/lib/gdip/installedFontCollection.aardio

@@ -0,0 +1,19 @@
+//installedFontCollection 系统字体集合
+import gdip.privateFontCollection;
+namespace gdip;
+
+class installedFontCollection{
+	ctor(){
+		var collect = {ptr p}
+		..gdip.assert2(::Gdiplus.GdipNewInstalledFontCollection(collect));
+		
+		if(collect.p){
+			return ..gdip.privateFontCollection(collect.p);
+		}
+		return null;
+	};
+}
+
+/**intellisense()
+gdip.installedFontCollection() = 创建系统字体集合\n!gdipprvfontcoll.
+end intellisense**/

package/aardio/lib/gdip/lineBrush.aardio

@@ -0,0 +1,114 @@
+//lineBrush 线性渐变笔刷
+import gdip.core;
+namespace gdip;
+
+class lineBrush {
+
+	ctor( ... ){ {
+		var err,handle;
+		var rectf,color1,color2,mode,wrapMd = ...
+		if( type( color1 ) == type.number ){ 
+			wrapMd = wrapMd : 0/*_GdipWrapModeTile*/ 
+			if( rectf.angle !== null ){
+				err,handle = gdip.CreateLineBrushFromRectWithAngle(rectf,color1,color2,rectf.angle,rectf.isAngleScalable,wrapMd);
+				
+			}
+			else {
+				err,handle = gdip.CreateLineBrushFromRect(rectf,color1,color2,mode : 0/*_GdipLinearGradientModeHorizontal*/ ,wrapMd ); 
+			}
+		}
+		else{
+			var pt,pt2,color1,color2,wrapMd  = ...
+			err,handle = gdip.CreateLineBrush(pt,pt2,color1,color2,wrapMd : 0/*_GdipWrapModeTile*/ );
+		}
+		 
+		if(err) return null,gdip.errMsg[err];
+		
+		this.pBrush = handle;
+		..table.gc(this,"delete");
+	} }
+
+	@_metaProperty//元表指向属性表
+}
+
+namespace lineBrush {
+
+	self.gdip = ..gdip;
+	var gdip = gdip; 
+	
+	_metaProperty = ..util.metaProperty(  
+		
+		wrapMode = {
+			_get = function(){ 
+				if( owner[["pBrush"]] ){
+					var mode = { int value }
+					var e = ::Gdiplus.GdipGetLineWrapMode(owner[["pBrush"]],mode)
+					if(!e) return mode.value
+				}
+			} 
+			_set = function(v){ 
+				gdip.assert2( ::Gdiplus.GdipSetLineWrapMode(owner[["pBrush"]], v) );
+			}  	
+		}; 
+		gammaCorrection = {
+			_get = function(){ 
+				if( owner[["pBrush"]] ){
+					var g = { int value }
+					var e = ::Gdiplus.GdipGetLineGammaCorrection(owner[["pBrush"]],g)
+					if(!e) return g.value
+				}
+			} 
+			_set = function(v){ 
+				gdip.assert2( ::Gdiplus.GdipSetLineGammaCorrection(owner[["pBrush"]], v) );
+			}  	
+		}; 
+		getLineColors = function(){
+			if( owner[["pBrush"]] ){
+				var out = { INT clr[2] }
+				var e = ::Gdiplus.GdipGetLineColors(owner[["pBrush"]],out)
+				if(!e) return out.clr[1],out.clr[2]
+			}
+		};
+		setLineColors = function(clr,clr2){
+			var e = ::Gdiplus.GdipSetLineColors(owner[["pBrush"]],clr,clr2)
+			if(e) return null,gdip.errMsg[e];
+			return true;
+		};
+		getRect = function(){
+			if( owner[["pBrush"]] ){
+				var rc = ::RECTF();
+				var e = ::Gdiplus.GdipGetLineRect(owner[["pBrush"]],rc)
+				if(!e) return rc
+			}
+		};
+		delete = function(){
+			if( owner[["pBrush"]] ){
+				::Gdiplus.GdipDeleteBrush(owner[["pBrush"]])
+				owner[["pBrush"]] = null;
+			}
+		};
+		_topointer = function(){
+			return owner[["pBrush"]];
+		}
+	)  
+}
+
+var $ = _dll;  
+/*intellisense(gdip)*/
+CreateLineBrush = $.api("GdipCreateLineBrush","int(struct pt,struct pt2,int c,int c2,int wrap,ptr& lineGd)")
+CreateLineBrushFromRect = $.api("GdipCreateLineBrushFromRect","int(struct rect,int c,int c2,int Mode,int wrap,ptr& lineGd)")
+CreateLineBrushFromRectWithAngle = $.api("GdipCreateLineBrushFromRectWithAngle","int(struct  rect,int c,int c2,float angle,bool scalable,int wrap,ptr& lineGd)")
+/*end intellisense*/
+
+/**intellisense()
+gdip.lineBrush = 线性渐变笔刷
+gdip.lineBrush(.(起始坐标,结束坐标,起始颜色,结束颜色) = 创建线性渐变笔刷\n坐标为::POINTF结构体,\n使用数值表示颜色分量:0xAARRGGBB\n注意与RGB的分量顺序是反过来的
+gdip.lineBrush(.(渐变区块,起始颜色,结束颜色,渐变模式) = 创建线性渐变笔刷\n区块为::RECTF结构体,可增加angle成员指定斜角方向,正值为顺时针\n使用数值表示颜色分量:0xAARRGGBB\n注意与RGB的分量顺序是反过来的\n渐变模式可省略,默认为_GdipLinearGradientModeHorizontal
+!gdiplineBrush.wrapMode = _GdipWrapMode__/*填充的包围模式*/
+!gdiplineBrush.gammaCorrection = 是否启用灰度校正
+!gdiplineBrush.getLineColors() = 返回起始颜色,结束颜色
+!gdiplineBrush.setLineColors(.(起始颜色,结束颜色) = 使用数值表示颜色分量:0xAARRGGBB
+!gdiplineBrush.getRect() = 返回::RECTF结构体\n!rectf.
+!gdiplineBrush.delete() = 释放笔刷对象
+gdip.lineBrush()= !gdiplineBrush.
+end intellisense**/

package/aardio/lib/gdip/path.aardio

@@ -0,0 +1,171 @@
+//path 路径
+import gdip.core;
+namespace gdip;
+
+class path {
+	ctor(brushmode){
+		brushmode = brushmode : 0/*_GdipFillModeAlternate*/;
+		if(type(brushmode) == "number"){
+			this.pPath = gdip.assert2(  gdip.CreatePath (brushmode )  ) 
+		}
+		
+		if(!this.pPath) error("参数错误",2)
+		..table.gc(this,"delete");
+	
+	}
+
+	@_metaProperty
+}
+
+namespace path {
+
+	self.gdip = ..gdip;
+	var gdip = gdip; 
+	
+	_metaProperty = ..util.metaProperty( 
+		addPath = function(ap,connect){
+			if(!ap[["pPath"]]) error("参数@1类型错误",2);
+			gdip.assert2(
+				gdip.AddPathPath( owner[["pPath"]],ap[["pPath"]], connect : 0)
+			);	
+		};
+		addstring = function( str,family,style,emSize,rclayout,strformat ){
+			gdip.assert2(
+				gdip.AddPathString( owner[["pPath"]],..string.toUnicode(str), -1, family, style, emSize, rclayout, strformat)
+			);
+			
+		};
+		addLine = function(x1,y1,x2,y2){
+			gdip.assert2(
+				gdip.AddPathLine( owner[["pPath"]],x1,y1,x2,y2)
+			);
+		};
+		addArc = function(x,y,width,height,startAngle,sweepAngle){
+			gdip.assert2(
+				gdip.AddPathArc( owner[["pPath"]],x,y,width,height,startAngle,sweepAngle)
+			);
+		};
+		addBezier = function(x1,y1,x2,y2,x3,y3,x4,y4){
+			gdip.assert2(
+				gdip.AddPathBezier( owner[["pPath"]],x1,y1,x2,y2,x3,y3,x4,y4)
+			);
+		};
+		addPie = function(x,y,width,height,startAngle,sweepAngle){
+			gdip.assert2(
+				gdip.AddPathPie( owner[["pPath"]],x,y,width,height,startAngle,sweepAngle)
+			);
+		};
+		addEllipse = function(x,y,width,height){
+			gdip.assert2(
+				gdip.AddPathEllipse( owner[["pPath"]],x,y,width,height)
+			);
+		};
+		addRectangle = function(x,y,width,height){
+			gdip.assert2(
+				gdip.AddPathRectangle( owner[["pPath"]],x,y,width,height)
+			);
+		}; 
+		addRoundRect = function(r,r1,r2,r3,r4) {
+			var x = r.left;  
+            var y = r.top; 
+            var x2 = r.right;
+            var y2 = r.bottom;
+            var w = x2 - x;  
+            var h = y2 - y; 
+            if( r1 > w/2 ) r1 = w/2; 
+            if( r1 > h/2 ) r1 = h/2; 
+            if( r2 === null ) r2 = r1;
+            if( r3 === null ) r3 = r1;
+            if( r4 === null ) r4 = r2;
+            
+            var p = owner[["pPath"]];
+            with(gdip){
+                AddPathBezier(p,x,y + r1,x,y,x + r1,y,x + r1,y);  
+                AddPathLine(p,x + r1,y,x2 - r2,y);  
+                AddPathBezier(p,x2 - r2,y,x2,y,x2,y + r2,x2,y + r2);  
+                AddPathLine(p,x2,y + r2,x2,y2 - r3);  
+                AddPathBezier(p,x2,y2 - r3,x2,y2,x2 - r3,y2,x2 - r3,y2);  
+                AddPathLine(p,x2 - r3,y2,x + r4,y2);  
+                AddPathBezier(p,x + r4,y2,x,y2,x,y2 - r4,x,y2 - r4);   
+                AddPathLine(p,x,y2 - r4,x,y + r1); 
+            }
+		}; 
+		addCurve = function(...){
+			var points = { ... }; 
+			gdip.assert2( gdip.AddPathCurve(owner[["pPath"]] ,{ float points[] = points },#points/2  ) );  
+		};
+		addClosedCurve = function(...){
+			var points = { ... }; 
+			gdip.assert2( gdip.AddPathClosedCurve(owner[["pPath"]] ,{ float points[] = points },#points/2  ) );  
+		};
+		addPolygon = function(...){
+			var points = { ... }; 
+			gdip.assert2( gdip.AddPathPolygon(owner[["pPath"]] ,{ float points[] = points },#points/2  ) );  
+		};
+		startFigure = function(){
+			gdip.StartPathFigure(owner[["pPath"]])
+		};
+		closeFigure = function(){
+			gdip.ClosePathFigure(owner[["pPath"]])
+		};
+		closeAllFigure = function(){
+			gdip.ClosePathFigures(owner[["pPath"]])
+		};
+		reset = function(){
+			gdip.ResetPath(owner[["pPath"]])
+		};
+		delete = function(){
+			if( owner[["pPath"]] ){
+				gdip.DeletePath(owner[["pPath"]])
+				owner[["pPath"]] = null;
+			}
+		};
+		//自动转换为API指针
+		_topointer = function(){
+			return owner[["pPath"]];
+		}
+	)  
+}
+
+var $ = _dll; //http://msdn.microsoft.com/en-us/library/ms534039(v=vs.85).aspx
+/*intellisense(gdip)*/
+CreatePath = $.api("GdipCreatePath","int(int brushmode,pointer& Path)")
+StartPathFigure = $.api("GdipStartPathFigure","int(PTR path)")
+ClosePathFigure = $.api("GdipClosePathFigure","int(PTR path)")
+ClosePathFigures = $.api("GdipClosePathFigures","int(PTR path)")
+AddPathPath = $.api("GdipAddPathPath","int(PTR path,pointer addingPath,int bConnect)")
+AddPathCurve = $.api("GdipAddPathCurve","int(PTR path,struct Points,int count)")
+AddPathClosedCurve = $.api("GdipAddPathClosedCurve","int(PTR path,struct Points,int count)")
+AddPathPolygon = $.api("GdipAddPathPolygon","int(PTR path,struct Points,int count)") 
+AddPathString = $.api("GdipAddPathString","int(PTR path,string str,int Length,pointer family,int style,float emSize,struct& layoutRect,ptr strFmt)")
+AddPathLine = $.api("GdipAddPathLine","int(PTR path,float x1,float y1,float x2,float y2)") 
+AddPathArc = $.api("GdipAddPathArc","int(PTR path,float x,float y,float width,float height,float startAngle,float sweepAngle)")
+AddPathBezier = $.api("GdipAddPathBezier","int(PTR path,float x1,float y1,float x2,float y2,float x3,float y3,float x4,float y4)")
+AddPathRectangle = $.api("GdipAddPathRectangle","int(PTR path,float x,float y,float width,float height)") 
+AddPathEllipse = $.api("GdipAddPathEllipse","int(PTR path,float x,float y,float width,float height)")
+AddPathPie = $.api("GdipAddPathPie","int(PTR path,float x,float y,float width,float height,float startAngle,float sweepAngle)")
+ClonePath = $.api("GdipClonePath","int(PTR path,int& clonePath)")
+DeletePath = $.api("GdipDeletePath","int(PTR path)")
+ResetPath = $.api("GdipResetPath","int(PTR path)")
+/*end intellisense*/
+ 
+/**intellisense()
+gdip.path(_GdipFillMode__) = 创建路径对象
+!gdippath.startFigure() = 不闭合开始新图形
+!gdippath.closeFigure() = 闭合当前图形开始新图
+!gdippath.closeAllFigure() = 闭合所有图形开始新图
+!gdippath.addstring(.(( str,family,style,emSize,rclayout,strformat ) = 添加字符串 
+!gdippath.addLine(.(x1,y1,x2,y2) = 添加直线
+!gdippath.addArc(.(x,y,width,height,startAngle,sweepAngle) = 添加椭圆弧\nstartAngle:起始角度,以度为单位从X轴顺时针测量\nsweepAngle:startAngle 和弧线末尾之间的角度
+!gdippath.addBezier(.(x1,y1,x2,y2,x3,y3,x4,y4) = 添加贝塞尔曲线\n4个坐标点分别为：起始锚点，起始控制点，结束锚点，结束控制点
+!gdippath.addPie(.(x,y,width,height,startAngle,sweepAngle) = 添加一个扇形轮廓\nstartAngle:起始角度,以度为单位从X轴顺时针测量\nsweepAngle:startAngle 和弧线末尾之间的角度
+!gdippath.addEllipse(.(x,y,width,height) = 添加椭圆
+!gdippath.addRectangle(.(x,y,width,height) = 添加矩形
+!gdippath.addRoundRect(.(RECT,圆角大小) = 添加圆角矩形\n圆角大小也可以使用四个值,自左上角开始顺时针为序:\n左上,右上,右下,左下
+!gdippath.addCurve(.(x1,y1,x2,y2,->->->) = 添加曲线\n参数使用任意个成对的数值参数表示曲线经过坐标
+!gdippath.addClosedCurve(.(x1,y1,x2,y2,->->->) = 添加闭合曲线\n参数使用任意个成对的数值参数表示曲线经过坐标
+!gdippath.addPolygon(.(x1,y1,x2,y2,->->->) = 添加多边形
+!gdippath.reset() = 重置为空路径
+!gdippath.delete() = 释放路径对象
+gdip.path() = !gdippath.
+end intellisense**/

package/aardio/lib/gdip/pathGradientBrush.aardio

@@ -0,0 +1,93 @@
+//pathGradientBrush 路径渐变笔刷
+import gdip.core;
+namespace gdip;
+
+class pathGradientBrush {
+
+	ctor( path ){ 
+		var err,handle = gdip.CreatePathGradientFromPath(path);
+		if(err) return null,gdip.errMsg[brush]; 
+		this.pBrush = handle; 
+		
+		..table.gc(this,"delete");
+	}
+
+	@_metaProperty//元表指向属性表
+}
+ 
+namespace pathGradientBrush {
+
+	self.gdip = ..gdip;
+	var gdip = gdip; 
+
+	_metaProperty = ..util.metaProperty(  
+		setCenterColor = function( color ){  
+			gdip.assert2( ::Gdiplus.GdipSetPathGradientCenterColor(owner[["pBrush"]],color ) );
+		};
+		setSurroundColors = function( colors,... ){  
+			if( type(colors) == "number" ) colors = {colors;...};
+			var count ={int value = #colors}
+			if( count.value < 1 ) error("参数中的数组长度错误",2); 
+			gdip.assert2( ::Gdiplus.GdipSetPathGradientSurroundColorsWithCount(owner[["pBrush"]],{ int colors[] = colors },count) );
+			return count.value;
+		};
+		setInterpolationColors = function( colors,points ){ 
+			var count = #colors;
+			if( count != #points ) error("参数中的数组长度错误",2)
+			gdip.assert2( ::Gdiplus.GdipSetPathGradientPresetBlend(owner[["pBrush"]],{ int colors[] = colors },{ float points[] = points },#points) )
+		};
+		setFocusScales = function(x,y){
+			gdip.assert2( gdip.SetPathGradientFocusScales(owner[["pBrush"]],x,y) );
+		};
+		setCenterPoint = function(x,y){
+			gdip.assert2( ::Gdiplus.GdipSetPathGradientCenterPoint(owner[["pBrush"]],::POINTF(x,y) ) );
+		};
+		gammaCorrection = {
+			_get = function(){ 
+				var g ={BOOL v}
+				gdip.assert2( ::Gdiplus.GdipGetPathGradientGammaCorrection(owner[["pBrush"]], v) ); 
+				return g.v;
+			} 
+			_set = function(v){ 
+				gdip.assert2( ::Gdiplus.GdipSetPathGradientGammaCorrection(owner[["pBrush"]], v) ); 
+			}  	
+		}; 
+		setBlend = function(blend,positions){
+			var count = #blend;
+			if( count != #positions ) error("参数中的数组长度错误",2)
+			gdip.assert2( ::Gdiplus.GdipSetPathGradientBlend(owner[["pBrush"]],{ float blend[] = blend },{ float positions[] = positions },#positions) )
+		}; 
+		delete = function(){
+			if( owner[["pBrush"]] ){
+				::Gdiplus.GdipDeleteBrush(owner[["pBrush"]])
+				owner[["pBrush"]] = null;
+			}
+		};
+		_topointer = function(){
+			return owner[["pBrush"]];
+		}
+	)  
+}
+ 
+var $ = _dll;  
+//http://msdn.microsoft.com/en-us/library/windows/desktop/ms534047(v=vs.85).aspx
+CreatePathGradientFromPath = $.api("GdipCreatePathGradientFromPath","int(PTR path,pointer& polyGradient)")
+SetPathGradientFocusScales = $.api("GdipSetPathGradientFocusScales","int(PTR brush,float xScale,float yScale)")
+
+ 
+/**intellisense()
+gdip.pathGradientBrush = 路径渐变笔刷
+gdip.pathGradientBrush(.(路径对象) = 参数是gdip.path对象
+gdip.pathGradientBrush()= !gdippathGradientbrush.
+end intellisense**/
+
+/**intellisense(!gdippathGradientbrush)
+setCenterPoint(.(x,y) = 设置中心点坐标
+setCenterColor(.(颜色) = 指定中心颜色\n颜色请使用0xAARRGGBB格式数值
+setSurroundColors(.(颜色数组) = 指定环绕颜色\n参数可以是数组,也可以是多个颜色数值参数,\n颜色请使用0xAARRGGBB格式数值
+setInterpolationColors(.(插值颜色数组,插值位置数组) = 定义多色渐变\n数组元素都是数值,长度必须相等\n插值位置以小数表示百分比,开始必须为0表示外边界,最后一个必须为1
+setFocusScales(.(x聚焦缩放,y聚焦缩放) = 对中心焦点进行缩放,参数为x轴、y轴的缩放比例,\n使中心颜色不仅显示在中心点,而是显示于围绕中心点进行缩放的路径内，\n被缩放的中心焦点路径内部使用中心颜色填充
+gammaCorrection = 是否允许伽马校正
+setBlend(.(颜色因子数组,位置因子数组) = 参数@1使用小数表示的百分比代表色彩渐变的度,\n0表示起点色,1表示完全转变为终点色\n合成位置中0表示起点,1表示终点,第一个合成位置必须是0,最后一个必须是1
+delete() = 释放路径对象
+end intellisense**/