unit utvclgraphics;
interface
uses utslvclauxiliary;
//tsl绘图库 
//20240126
//20240204 添加说明
//20240220 三维绘图功能
//20240614 添加消息
{
    tg_const 常量类型，作为所有类型的基类，提供常量别名
    tg_canvas 绘图画布对象，该对象以窗口中的canvas为父类，并增加了辅助函数
        axesclip() 限定到坐标系区域       
        axesunclip() 取消坐标系区域限定
        axesrec  坐标系的范围
    tg_line_info 画笔线型信息
        Style 线型 tgc_PS_DOT tgc_PS_DASH tgc_PS_NULL tgc_PS_SOLID tgc_PS_DASHDOT tgc_PS_DASHDOTDOT
        size 线宽度，像素
        color 线颜色
        bkcolor 线型封闭后的背景
    tg_font_info 系统信息
        size 字号，宽度的像素
        color 字颜色
        bkcolor 背景色
    tg_mark_info 点标记信息
        size 标记大小，像素
        color 线颜色
        bkcolor 背景色   
          
    tg_base 做个绘图类基类，提供一些基础功能，以及层次关系
        层次关系：
        parent: 设置或者父节点
        nodecount 获取子节点数量
        GetNodeByIndex 通过序号获取子节点
        set_node_index(nd,idx) 设置子节点的序号
        基础功能：
        markinfo 标记信息 tg_mark_info 类型
        lineinfo 画笔信息 tg_line_info 类型
        line_mode 是否画线
        mark_mode 是否画点的标记
        clip_state 是否裁剪区域
        zoom_to_xyz(x,y,z,var _x,var _y) 通过坐标点计算画布点位置
        xyz_to_zoom(x,y,z,var x_,var y_,var z_) 通过画布点计算坐标点
        set_lineinfo_to_canvas(cvs,peninfo) 设置当前画笔信息到画布
        set_fontinfo_to_canvas(cvs,info) 设置当前字体信息到画布
        paint(cvs);virtual;该函数由tg_figure的管理者在适当时候发起，并送入tg_canvas对象
        addEventListener(etype,fun(e),ifCapture) //添加消息处理
        removeEventListener(etype,fun(e),ifCapture) //移除消息处理
        dispatchEvent(evt) ;//分发消息
        
    tg_figure //坐标容器类，可以在上面放坐标系，设置坐标系的位置信息
        add_axes(axes) 添加坐标系
        del_axes(axes) 删除坐标系
        executecommand(cmd,p); //命令行执行
        paint(cvs); 送入画布，绘制各个图形，如果是窗口，在onpaint消息中调用该函数
        属性： 
        rec_getter ：function() 返回画布区域 array(左上右下) 
        fresh_caller: function() //刷新回调
        
    tg_axes 坐标系类型，作为绘图的基础载体，以及位置关系的基准
        属性：
        title 标题 tg_label 类型 
        y_label y轴标签 tg_label 类型 
        x_label x轴标签 tg_label 类型 
        axises(idx) 0,1,2 分别获取对应的x，y轴 ，tg_axis 类型
        axes_reverse(idx) 坐标轴是否反向，默认正向
        auto_ticks(idx) 设置坐标轴刻度自动计算
        margins 空白，array(左上右下)，设置上下左右空白，tg_figure区域的百分比
        axes_bounds(idx) 坐标系的大小 array((x,width),(y,heigt))，以margins为基准点，安百分比
        data_bounds(idx) 获取或者设置数据范围 array((x0,x1),(y0,y1),(z0,z1))
        zoom_box(idx) 设置显示的数据的区域 array((x0,x1),(y0,y1),(z0,z1))
        x_location 坐标轴方向，tgc_bottom tgc_top,tgc_middle ,tgc_origin
        y_location 坐标轴方向，tgc_left tgc_right,tgc_middle ,tgc_origin
        box 是否有边框
        grid(idx) 背景网格线属性 tg_line_info 对象，size为0的时候网格线消失
    
    tg_axis 坐标轴，可以在坐标系中放置任意多个坐标轴
        tics_direction 坐标轴方向 tgc_direct_asc(坐标轴指向的左手方向) , tgc_direct_desc
        tics_style 刻度类型 tgc_tics_v (设置值) tgc_tics_r ([x0,x1,inteval])
        tics_coord 刻度，根据tics_style 确定 [2,3,4,5,6,7] 计算 [start,end,interval]
        ytics_coord 位置，设置在另一个方向的位置，相对坐标系的数据位置,array(x,y,z),为对应三维坐标,x,y,z中为非数字的值表示该坐标轴在对应维度上面
        tics_segment 是否有轴线
        tics_color 刻度线颜色
        sub_tics 子刻度个数
        tics_labels 刻度值对应的标签，一维字符串数组 
        
    tg_label 标签，以axes作为父节点
        text 文本
        position 坐标系位置
        auto_position 自动位置，在坐标轴标签中使用
        font_angle 设置角度
        其他字体相关的通过 fontinfo设置
    tg_graph_base 图基类
         get_data_bounds();virtual; //获取数据边界               
    tg_graph 图类型
        get_data_tips(); //获得数据提示对象
        get_legend_size(var w,var h);virtual; 获取图例中的大小
        paint_legend(cvs,rec);virtual; //绘制图例
        get_graph_data_by_idx(idx); //通过数据序号获取数据
        graph_data  绘图数据; 
    
    tg_Polyline 线图，以tg_graph为父类
        closed 是否封闭的图像
        polyline_style 线类型， tgc_LS_interpolated tgc_LS_bar tgc_LS_filled tgc_LS_arrowed tgc_LS_barplot tgc_LS_staircase
        bar_width 柱状图类型时候的宽度    
    tg_legend 图例    
        location 位置 tgc_in_upper_left tgc_in_lower_left ..... tgc_by_coordinates        
        postion 定位为tgc_by_coordinates，设置具体位置 array(x,y)
        line_mode 边框线
        links 关联的绘图，tg_graph 数组 
        text 文本内容，字符串数组
    tg_tips 数据点提示，父节点为tg_graph 对象 
        text 文本数组
        data_idx 绑定数据序号 
    tg_text 文本展示
        text 字符串数组
        font_angle 角度
        data array(x,y,z) 相对于坐标系的位置  
         
    tg_WinControl:绘图展示窗口对象，管理了一个 tg_figure 对象，在paint消息的时候构造tg_canvas 对象并调用tg_figrue的paint函数实现图形的绘制 
                  其仅仅作为一个案例，用户可以按照其原理构造自己的画布对象，驱动绘制，得到图形 
                  
    消息对象
    tg_evt 基类
            create(typename,pms) //构造函数 
            bubbles //是否冒泡,只读
            currentTarget //当前绑定的对象,只读
            target //目标对象,只读
            stoppropagationed 否//已经调用 stoppropagation,只读
            stopImmediatePropagationed //是否已经调用 stopImmediatePropagation,只读
            eventPhase //只读,1,捕获,2到达目标,3,冒泡
            timeStamp //只读,加载完成到现在的时间
            eventtype //只读类型
            isTrusted //true表示用户触发,false表示代码触发
            init_params //初始化参数 数组
     tg_evt_mouse
         cvsx ,cvsy //画布位置
         double 是否双击
         button 左右,中 按键 
         ctrl  ,shift //功能按键  
     tg_evt_custom
         detail     
    目前提供 evt_mouse_up ,evt_mouse_down evt_mouse_move 三个消息
    消息传播方式采用类似html对象的捕获和冒泡方式
    捕获阶段,从figure对象向下一直传递到当目标对象
    冒泡阶段,从目标对象向上传递到figure对象  
}
{
//////////////////线图范例//////////////////////////
uses tslvcl,utvclgraphics;
app :=  initializeapplication();
app.createform(class(tfm),fm);
fm.show();
app.run();
type tfm = class(tvcform)
    function create(aowner);
    begin
        inherited;
        Caption := "line";
        fg := new tg_WinControl(self);
        fg.Caption := "hello1";
        fg.parent := self;
        fg.Align := alClient;
        //////////设置坐标轴属性////////////////////////
        axs := new tg_axes();
        axs.figure := fg.figure;
        axs.title.text := "你好 plot ";
        axs.title.fontinfo.size := 15;
        axs.title.fontinfo.color := 0xff0000;
        axs.x_label.text := "x fanli ";         
        axs.axises(1).tics_color := 0x0000ff;
        axs.axises(1).fontinfo.size := 8;        
        axs.axises(1).lineinfo.color := 0x00ff00;
        axs.grid(0).Width := 2;
        axs.grid(0).color := 0x0ff0f0;          
        //设置线型属性             
        line := new tg_Polyline();
        line.lineinfo.style := 4;
        line.lineinfo.color := 0xff0000;
        line.markinfo.bkcolor := 0x00ff00;
        line.markinfo.color := 0x0000ff;
        line.mark_mode := "on";
        line.markinfo.size := 30;
        line.markinfo.style  := "pentagram";
        line.polyline_style := "staircase";
        d := array();
        idx := 0;
        for i:= -pi() to pi() step 0.2 do 
        begin
            d[idx] := array(i,sin(i));
            idx++;
        end 
        line.graph_data := d;
        line.parent := axs;        
    end 
    fg;
end 
//////////////////表面图范例///////////////////////////////////////
uses tslvcl,utvclgraphics;
app :=  initializeapplication();
app.createform(class(tfm),fm);
fm.show();
app.run();
type tfm = class(tvcform)
    function create(aowner);
    begin
        inherited;
        Caption := "surface";
        fg := new tg_WinControl(self);
        fg.Caption := "hello1";
        fg.parent := self;
        fg.Align := alClient;
        //////////设置坐标轴属性////////////////////////
        axs := new tg_axes();
        t := pi()*60/180;
        a := pi()*70/180;
        axs.set_trans(a,t);
        axs.box := true;
        axs.figure := fg.figure;
        axs.title.text := "你好 surface ";
        axs.title.fontinfo.size := 15;
        axs.title.fontinfo.color := 0xff0000;
        axs.axises(1).tics_color := 0x0000ff;
        axs.axises(1).fontinfo.size := 8;
        axs.axises(1).lineinfo.color := 0x00ff00;   
        sf := new tg_my_surf();
        sf.lineinfo.color := 0x0000ff;
        sf.lineinfo.style := tgc_BS_SOLID;
        sf.graph_data := get_surf_data();
        sf.parent := axs; 
        return ;    
    end     
    fg;
    function c_3(x,y);
    begin
        return X - 3*X*sin(X)*cos(Y-4) ;
    end 
    function get_surf_data();
    begin
        st1 := (12)/50; 
        vs1 := array(-10,st1)->2;
        st2 := 10/50;
        vs2 := array(-5,st2)->5;
        d := array();
        dlen := 0;            
        for i,vi in vs1 do 
        begin             
            for j,vj in vs2 do 
            begin
                r := array();
                x0 := vi;
                y0 := vj;
                x1 := vi+st1;
                y1 := vj+st2;
                v1 := array(x0,y0,c_3(x0,y0));
                v2 := array(x1,y0,c_3(x1,y0));
                v3 := array(x1,y1,c_3(x1,y1));
                v4 := array(x0,y1,c_3(x0,y1));
                d[dlen++] := array(v1,v2,v3,v4,v1);
            end 
        end 
        return d;
    end    
end 
type tg_my_surf = class(tg_graph) //绘图对象,包括数据,提示等内容
    function create(pms);
    begin
        inherited;
        lineinfo.bkcolor := 0x00f0f0;
    end 
    function get_data_bounds();override;
    begin
        d := graph_data;
        r := array((inf,-inf),(inf,-inf),(inf,-inf));
        for i ,v in d do 
        begin 
            for j,vj in v do 
            begin
                for k := 0 to 2 do 
                begin
                    r[k,0] := min(r[k,0],vj[k]);
                    r[k,1] := max(r[k,1],vj[k]);
                end     
            end             
        end 
        for k := 0 to 2 do 
        begin
            r[k,0] -= abs(r[k,0]*0.1);
            r[k,1] += abs(r[k,1]*0.1);
        end 
        return r;
    end 
    function paint_legend(cvs,rec);virtual; //绘制图例
    begin            
    end 
    function paint(cvs);override;
    begin
        d := graph_data;
        cvs.axesclip();       
        set_lineinfo_to_canvas(cvs);
        dp := cvs.draw_polygon();        
        bx := axes.zoom_box;
        //cvs.pen.color := 0xff0000;
        for i,v in d do 
        begin
            ps := array();
            flg := false;
            zz := 0;
            for j,vj in v do 
            begin
                if vj[0]<bx[0,0] or vj[1]<bx[1,0] or vj[2]<bx[2,0] or vj[0]>bx[0,1] or vj[1]>bx[1,1] or vj[2]>bx[2,1] then 
                begin 
                flg := true;
                break;
                end 
                //zz:=vj[2];
                zoom_to_xyz(vj[0],vj[1],vj[2],_x,_y,_z);
                zz := vj[2];
                ps[j] := array(_x,_y);
            end 
            if flg then continue;
            if zz>0 then cvs.brush.color := 0x00ff00;
            else 
                cvs.brush.color := 0xff0000;
            dp.points(ps).requiregdi().draw();               
        end 
        cvs.axesunclip();
    end      
end
//////////////////饼图范例///////////////////////////////////////////
uses tslvcl,utvclgraphics;
app :=  initializeapplication();
app.createform(class(tfm),fm);
fm.show();
app.run();
type tfm = class(tvcform)
    function create(aowner);
    begin
        inherited;
        caption := "pie";
        width := 800;
        Height := 800;
        fg := new tg_WinControl(self);
        fg.Caption := "hello1";
        fg.parent := self;
        fg.Align := alClient;
        //////////设置坐标轴属性////////////////////////
        axs := new tg_axes();
        axs.box := true;
        axs.figure := fg.figure;
        axs.title.text := "hello pie ";
        axs.axises(1).tics_color := 0x0000ff;
        axs.axises(1).fontinfo.size := 8;
        axs.data_bounds(0) := array(-0.1,2.1);
        axs.data_bounds(1) := array(-0.1,2.1);
        axs.data_bounds(2) := array(-0.5,0.5);
        args := array(
            (pi()/4,pi()/3,0x0000ff),
            (pi()/3,pi()/2,0x00ff00),
            (pi()/2,pi()*3/2,0xff0000),
            (pi()*3/2,pi()*9/4,0xff00ff)
        
        );
        prominentidx := 0; //凸显的块
        prominentrate := 0.1; //凸显的块
        for i,v in args do 
        begin
            line := new tg_Polyline();
            line.polyline_style := line.tgc_LS_filled;
            line.closed := true;
            c := (i=2)?1.1:1;
            line.graph_data := 1+get_pie_lines(v[0],v[1],i=prominentidx,prominentrate);
            line.lineinfo.bkcolor := v[2];
            line.parent := axs;  
        end     
    end 
    function get_pie_lines(arg1,arg2,prominent,prominentrate);
    begin
        stp := pi()/180;
        d := 1;
        r := array();
        r[0] := array(0,0);
        idx := 1;
        for i:= arg1+(prominent?stp:0) to arg2-(prominent?stp:0) step stp do 
        begin 
            r[idx++] := array(sin(i),cos(i));                
        end 
        r[idx] :=array(0,0);
        if prominent then 
        begin
            rx := r[integer(idx/2)]*prominentrate;
            for i := 0 to idx do 
            begin
                r[i]+=rx;
            end 
        end 
        return r;
    end 
    fg;
end 
///////////////////////////消息处理///////////////////////////////////////////////////
uses tslvcl,utvclgraphics;
app :=  initializeapplication();
app.createform(class(tfm),fm);
fm.show();
app.run();
type tfm = class(tvcform)    
    function create(aowner);
    begin
        inherited;
        fgwnd := new tg_WinControl(self);
        fgwnd.Caption := "hello event";
        fgwnd.parent := self;
        fgwnd.Align := alClient;
        fg := fgwnd.figure;
        axs := new tg_axes();
        axs.figure := fg;       
        axs.title.text := "你好 event ";        
        line := new tg_Polyline();
        line.parent := axs;
        line.lineinfo.Width := 3;
        line.lineinfo.bkcolor := 0xff00f0;
        line.lineinfo.color := 0xff0000;
        line.markinfo.bkcolor := 0x00ff00;
        line.markinfo.color := 0x0000ff;
        line.line_mode := 1;
        line.markinfo.size := 20;
        line.mark_mode := true;
        line.markinfo.style  := line.tgc_mks_pentagram;
        line.polyline_style := line.tgc_LS_interpolated;//"bar";
        d2 := array();
        idx := 0;        
        for i:= -pi() to pi() step 0.3 do 
        begin
            d2[idx++] := array(i,sin(i+pi()/2));
        end 
        line.graph_data := d2;
        
        gtx := new tg_text();
        gtx.font_angle := pi()/4;
        //////////////命中处理///////////////
        gtx.onhit_at := function(o,d)begin 
            x := d["cvsx"];
            y := d["cvsy"];
            rgn := o.ExecuteCommand("text_rgn");
            return rgn and point_in_rgn(array(x,y),rgn);
        end 
        gtx.lineinfo.bkcolor := 0x00ff00;
        gtx.parent :=line;
        gtx.text := array("按住鼠标左键","移动我");
        gtx.data := array(0.3,0.2);
        //处理鼠标按下
        gtx.addEventListener("mouse_down",function(e)begin
            fdragtext := e.target;
            ftextinitpos := fdragtext.data;
            x := e.cvsx;y := e.cvsy;
            fdragtext.xyz_to_zoom(x,y,0,x1,y1);
            fmousedownpos := array(x1,y1);
        end);
        //移动标签
        fg.addEventListener("mouse_move",function(e)begin
            if fdragtext then 
            begin 
                e.stoppropagation();
                x := e.cvsx;
                y := e.cvsy;
                fdragtext.xyz_to_zoom(x,y,0,x1,y1);
                dxdata := ftextinitpos+ array(x1-fmousedownpos[0],y1-fmousedownpos[1]);
                fdragtext.data := dxdata;                
            end 
        end ,true);
        //处理鼠标松开
        fg.addEventListener("mouse_up",function(e)begin
            if fdragtext then  
            begin
                e.stoppropagation();
                fdragtext := nil;
            end 
        end );
        //构造提示标签
        fmovetip := new tg_tips();
        fmovetip.Visible := false;
        fmovetip.clip_state := 0;
        fmovetip.parent := line;
        fmovetip.data_idx := 5;
        fmovetip.fontinfo.size := 12;
        fmovetip.box_mode := true;//false;
        fmovetip.fontinfo.color := 0xff00ff;
        //设置提示数据点
        line.onhit_at := function(o,d)begin
            x := d["cvsx"];
            y := d["cvsy"];
            for i,v in o.ExecuteCommand("points_in_canvas") do 
            begin
                if abs(v[0]-x)<10 and abs(v[1]-y)<10 then 
                begin
                    return true; 
                end 
            end 
        end
        line.addEventListener("mouse_out",function(e)begin
            if e.eventPhase<>2 then return ;
            fmovetip.Visible := false;
            e.stoppropagation();
        end,true); 
        line.addEventListener("mouse_move",function(e)
                    begin 
                        if e.eventPhase<>2 then return ;
                        e.stoppropagation(); 
                        x := e.cvsx;
                        y := e.cvsy;
                        for i,v in e.target.ExecuteCommand("points_in_canvas") do 
                        begin
                            if abs(v[0]-x)<10 and abs(v[1]-y)<10 then 
                            begin
                                fmovetip.Visible := true;
                                return fmovetip.data_idx := i; 
                            end 
                        end                  
                    end,true);
    end 
    fdragtext;
    ftextinitpos;
    fmousedownpos;
    fmovetip;
    fgwnd;
    fg;
end 
}
function point_in_rgn(p,rgn_); //判断点是否在区域中
type tg_WinControl = class(tcustomcontrol,tg_const) //绘图窗口
    function create(AOwner);
    begin
        inherited;
        ffigure := new tg_figure();
        fg_timer := new unit(utslvclstdctl).tcustomtimer(self);
        fg_timer.Interval := 200;
        fg_timer.Ontimer := thisfunction(figure_need_fresh);
        ffigureprepared := false;
        ffigure.rec_getter := function()begin
            return clientrect;
        end 
        ffigure.fresh_caller := thisfunction(flushfigure);
    end 
    function flushfigure();
    begin
        if not ffigureprepared then return ;
        if Fneed_invaliate then return ;
        if not HandleAllocated() then return ;
        Fneed_invaliate := true; 
        fg_timer.start(); 
    end 
    function paint();override; //绘制
    begin
        cvs := canvas;
        ffigure.paint(cvs);
        ffigureprepared := true;   
    end 
    function DestroyHandle();override;
    begin
        ffigureprepared := false;
        inherited;
    end 
    function MouseUp(o,e);override;
    begin
        if ffigure then 
        begin 
            d := e_2_array(e);
            if ffigure.executecommand(evt_mouse_up,d)=1 then e.skip := true;   
        end      
    end 
    function MouseDown(o,e);override;
    begin
        if ffigure then 
        begin 
            d := e_2_array(e);
            if ffigure.executecommand(evt_mouse_down,d)=1 then e.skip := true;   
        end
        //echo "\r\n",functionname(),tostn(array(xy,bt,sh));
    end 
    function MouseMove(o,e);override;
    begin
        if ffigure then 
        begin 
            fmovecnt++;
            if fmovecnt>4 then fmovecnt := 0;
            if fmovecnt<>2 then return ;
            d := e_2_array(e);
            if ffigure.executecommand(evt_mouse_move,d)=1 then e.skip := true;   
        end  
    end 
    function DoMouseWheel(o,e);override;
    begin        
        p := ScreenToClient(e.xpos,e.ypos);
        if ffigure then 
        begin
            ffigure.executecommand(cmd_zoom_inc,array("delta":e.delta,"x":p[0],"y":p[1]));  
        end  
    end 
    function DoWMSIZE(o,e);override;
    begin
        inherited;
        if ffigure then 
            ffigure.executecommand(cmd_figure_changed);
    end     
    function Recycling();override;
    begin
        ffigure:=nil;
        inherited;
    end 
    property figure read ffigure;
    private 
    function figure_need_fresh(o,e); //定时刷新
    begin          
        o.stop();
        InvalidateRect(nil,false);   
        Fneed_invaliate := false;                
    end 
    function e_2_array(e);
    begin
        d := array();
        st := e.shiftstate();
        sft := 0x0 in st;
        sctl := 0x2 in st;
        d := array(
                "cvsx":e.xpos,
                "cvsy":e.ypos,
                "shift":sft,
                "ctrl":sctl,
                "button":e.button(),
                );
        return d;
    end 
    private
    fmovecnt; 
    ffigure;
    fg_timer;
    Fneed_invaliate;
    ffigureprepared;  
end 
type tg_figure = class(tg_evet_conainter)   /////////
    function create();
    begin
        inherited;
        faxeses := new tnumindexarray();
    end 
    function paint(cvs); //绘制
    begin
        cvs := new tg_canvas(cvs.Handle);
        for i,v in faxeses.data do 
        begin
            v.paint_pre(cvs);
        end   
    end     
    function executecommand(cmd,p);
    begin
        case cmd of
            "figure_need_fresh":
            begin
                fresh();      
                return ;
            end 
            cmd_zoom_inc:
            begin
                for i,v in faxeses.data do 
                begin
                    v.executecommand(cmd_zoom_inc,p);  
                end       
            end 
            evt_mouse_move:
            begin
                return cmd_mouse_event(evt_mouse_move,p);
            end 
            evt_mouse_up:
            begin
                return cmd_mouse_event(evt_mouse_up,p);                    
            end 
            evt_mouse_down:
            begin
                return cmd_mouse_event(evt_mouse_down,p);    
            end 
            cmd_figure_changed:
            begin
                for i,v in faxeses.data do 
                begin
                    v.executecommand(cmd_figure_changed);
                end 
            end              
        end ;
    end 
    function add_axes(axs);//添加
    begin
        if get_axes_idx(axs)>=0 then return ;
        if fwilladdaxs and fwilladdaxs=axs then 
        begin 
            faxeses.unshift(axs); 
            fwilladdaxs := nil;
            axs.figure := self(true);
            return ;       
        end            
        if not(axs is class(tg_axes)) then return ;
        fwilladdaxs := axs;
        axs.figure := self(true);         
    end 
    function del_axes(axs); //移除
    begin
        idx := get_axes_idx(axs);
        if not(idx>=0) then return ; 
        if fwilldelaxs and fwilldelaxs = axs then 
        begin 
            fwilldelaxs := nil;
            faxeses.splice(idx,1);
            axs.figure := nil;
            return ;
        end 
        fwilldelaxs := axs;
        axs.figure := nil;           
    end     
    function fresh(); ///////////////////////////
    begin
        if ffresh_caller then call(ffresh_caller);    
    end 
    function rect(); //////////////////////////////////
    begin
        r := array(0,0,200,200);
        if frect_getter then r := call(frect_getter);
        return r;
    end         
    property rec_getter read frect_getter write frect_getter; //区域获取
    property fresh_caller read ffresh_caller write ffresh_caller; //刷新回调
    public 
    function dispatchEvent(evt,nd); 
    begin 
        bs := evt.bubbles;
        if ifarray(nd) then 
        begin 
            nds := nd;        
        end else 
        begin 
            nds := array();
            p := nd;
            while p do 
            begin
                nds[idx] := p;   
                idx++;
                p := p.parent; 
            end 
        end 
        tg := nds[0];
        nds[length(nds)] := self(true);
        for i := length(nds)-1 downto 0 do 
        begin
            it := nds[i];
            ph := (i=0)?2:1;
            d := array("eventphase":ph,
                        "target":tg,
                        "currenttarget":it,
                    );
            e := evt.clone(d);
            it.dealevent(e,true);
            if e.stoppropagationed then 
            begin
                evt.stoppropagation();
                return true;
            end 
        end         
        if not bs then return true;
        for i := 0 to length(nds)-1 do 
        begin
            it := nds[i];
            ph := (i=0)?2:3;
            d := array("eventphase":ph,
                        "target":tg,
                        "currenttarget":it,
                    );
            e := evt.clone(d);
            it.dealevent(e);
            if e.stoppropagationed then 
            begin
                evt.stoppropagation();
                return true;
            end 
        end 
    end  
    private
    function get_axes_idx(axs);
    begin
        for i ,v in faxeses.data do 
        begin 
            if v=axs then 
            begin 
                return i;
            end 
        end  
        return -1;   
    end 
    function inverse_array(d);
    begin
        r := array();
        len := length(d)-1;
        for i,v in d do 
        begin
            r[len-i] := v;
        end 
        return r;
    end     
    function cmd_mouse_event(evtname,p);
    begin
        d := p;        
        for i,v in inverse_array(faxeses.data) do 
        begin
            nds := node_hit_list(v,d);
            if nds then 
            begin
                break;                
            end             
        end  
        d["istrusted"] := true;
        d["bubbles"] := true;
        case evtname of
            evt_mouse_move :
            begin
                ninnode := nds[0];
                if ninnode then 
                begin 
                    if fMouseOnOBJ<> ninnode then //鼠标进入不同的控件
                    begin
                        if fMouseOnOBJ then //旧控件 处理move out
                        begin
                            onds := array();
                            nnd := fMouseOnOBJ;
                            while  nnd do 
                            begin
                                onds[length(onds)] := nnd;
                                nnd := nnd.parent;
                            end  
                            evt := new tg_evt_mouse(evt_mouse_out,d);   
                            dispatchEvent(evt,onds);
                        end 
                        fMouseOnOBJ := ninnode;
                        evt := new tg_evt_mouse(evt_mouse_in,d); //处理mouse in 
                        dispatchEvent(evt,nds);  
                    end    
                end                
            end 
        end 
        evt := new tg_evt_mouse(evtname,d);
        dispatchEvent(evt,nds);
        return evt.stoppropagationed;
    end 
    private 
    [weakref] frect_getter;
    [weakref] ffresh_caller; 
    [weakref] fMouseOnOBJ; 
    fwilladdaxs;
    fwilldelaxs;
    faxeses;         
end 
type tg_axes = class(tg_base) //坐标系
    private 
    [weakref]fFigure;
    ///////////////坐标辅助计算/////////////////////////
    p_left;
    p_top;
    p_width;
    p_height;     
    f_changed;    
    static const c_g_data_changed=1;
    static const c_g_paint_rect=2;
    static const c_g_data_zoombox=4;
    static const c_g_rote_changed=8;
    ///////////////////////////////////////////  
    public //zoom-xyz
    function executecommand(cmd,pm);override;
    begin
        ochanged := f_changed;
        case cmd of
            "title_rgn": return ftitle.executecommand("label_rgn");  
            "x_label_rgn": return (fx_label.visible=tgc_on)?faxes_objects[0].executecommand("label_rgn"):nil;
            "y_label_rgn": return (fy_label.visible=tgc_on)?faxes_objects[1].executecommand("label_rgn"):nil;
            "z_label_rgn": return (fz_label.visible=tgc_on)?faxes_objects[2].executecommand("label_rgn"):nil;
            "x_tics_recs": return (fx_label.visible=tgc_on)?faxes_objects[0].executecommand("tics_recs"):nil;
            "y_tics_recs": return (fy_label.visible=tgc_on)?faxes_objects[1].executecommand("tics_recs"):nil;
            "z_tics_recs": return (fz_label.visible=tgc_on)?faxes_objects[2].executecommand("tics_recs"):nil;
            cmd_zoom_inc:
            begin
                if not ifarray(pm) then return ;
                p0 := pm["x"];
                p1 := pm["y"];
                for i := 0 to 2 do 
                begin 
                    a0 := fzoom_box[i,0];
                    b0 := fzoom_box[i,1];                    
                    if not xy_in_paint_rect(p0,p1) then 
                    begin
                        continue;
                    end 
                    if not xyz_to_zoom(p0,p1,fzoom_box[2,0],x,y,z) then continue ;
                    dx := ((pm["delta"]>0)?(1.05):(1/1.05)); 
                    if not zoom_bound_op(a0,b0,dx,array(x,y,z)[i],a,b) then continue ;
                    rt := 1.1;
                    cg := 0;
                    if a<fdata_bounds[i,0]*rt then 
                    begin
                        cg++;
                        a := fdata_bounds[i,0]*rt ;
                    end 
                    if b>fdata_bounds[i,1]*rt then 
                    begin
                        cg++;
                        b := fdata_bounds[i,1]*rt;
                    end 
                    if cg=2 then continue;
                    fzoom_box[i] := array(a,b); 
                    f_changed .|= c_g_data_zoombox; 
                end 
            end 
            cmd_node_add_in:
            begin
                if pm is class(tg_graph_base) then 
                begin
                    f_changed .|= c_g_data_changed;
                    f_changed .|= c_g_data_zoombox;
                end 
            end 
            cmd_figure_changed:
            begin
                f_changed .|= c_g_paint_rect;
                f_changed .|= c_g_data_zoombox;
            end 
            cmd_data_changed:
            begin
                f_changed .|= c_g_data_changed;
                f_changed .|= c_g_data_zoombox;
            end            
        end ;
        if ochanged<>f_changed then prop_changed(cmd_data_changed,f_changed);
    end 
    
    function axes_mapping(x,y,z,_x,_y);override;//坐标系相对位置到画布
    begin
        if not(fFigure ) then return false; 
        _x := p_left+p_width*x ;
        _y := p_top +p_height*y;  
        return true;
    end
    function axes_unmapping(x,y,_x,_y,_z);override;//画布位置到坐标系相对位置
    begin
        if not(fFigure ) then return false; 
        _x := (x-p_left)/p_width;
        _y := (y-p_top)/p_height;  
        return true;
    end 
    function zoom_to_xyz(x,y,z,_x,_y,_z); //----------
    begin
        if not(fFigure ) then return false; 
        if faxes_reverse[0]=tgc_on then x0 := fcoordinate_sizes[0]/2-(x-fzoom_bounds[0,0])/fzoom_coordinate_rates[0];    
        else 
            x0 := (x-fzoom_bounds[0,0])/fzoom_coordinate_rates[0] -fcoordinate_sizes[0]/2;
        if faxes_reverse[1]=tgc_on then y0 := fcoordinate_sizes[1]/2-(y-fzoom_bounds[1,0])/fzoom_coordinate_rates[1];   
        else y0 := (y-fzoom_bounds[1,0])/fzoom_coordinate_rates[1] -fcoordinate_sizes[1]/2;
        if faxes_reverse[2]=tgc_on then z0 := fcoordinate_sizes[2]/2-(z-fzoom_bounds[2,0])/fzoom_coordinate_rates[2];   
        else z0 := (z-fzoom_bounds[2,0])/fzoom_coordinate_rates[2] -fcoordinate_sizes[2]/2;
        transxyz(x0,y0,z0,_x,_y,_z);        
        _x +=fbounds_center[0];
        _y +=fbounds_center[1];
        _z +=fbounds_center[2];
        return true;
    end 
    function xyz_to_zoom(x,y,z,_x,_y,_z);
    begin
        if not(fFigure ) then return false; 
        x1 := x;y1 := y;z1 := z;
        x1 -=fbounds_center[0];
        y1 -=fbounds_center[1];
        z1 -=fbounds_center[2]; 
        untransxyz(x1,y1,z1,x0,y0,z0);           
        if faxes_reverse[0]=tgc_on then 
        begin
            _x := (fcoordinate_sizes[0]/2-x0)*fzoom_coordinate_rates[0]+fzoom_bounds[0,0];
        end     
        else 
        begin 
            _x := (x0+fcoordinate_sizes[0]/2)*fzoom_coordinate_rates[0]+fzoom_bounds[0,0];
        end 
        if faxes_reverse[1]=tgc_on  then 
        begin
            _y := (fcoordinate_sizes[1]/2-y0)*fzoom_coordinate_rates[1]+fzoom_bounds[1,0];
        end  
        else 
        begin
            _y := (y0+fcoordinate_sizes[1]/2)*fzoom_coordinate_rates[1]+fzoom_bounds[1,0];
        end 
        if faxes_reverse[2]=tgc_on  then 
        begin
            _z := (fcoordinate_sizes[2]/2-z0)*fzoom_coordinate_rates[2]+fzoom_bounds[2,0];
        end   
        else 
        begin
            _z := (z0+fcoordinate_sizes[2]/2)*fzoom_coordinate_rates[2]+fzoom_bounds[2,0];
        end  
        return true;         
    end 
    function paint_pre(cvs);
    begin
        if visible<>tgc_on then return ;
        axes_changed();
        modify_coordinate_position();  
        r := array(p_left-1,p_top-1,p_left+p_width+1,p_top+p_height+1);
        cvs.axesrec := r;
        paint(cvs);
        cvs.axesunclip();
    end 
    function paint(cvs);override;
    begin  
        paint_grid(cvs);           
        inherited;  
        cvs.axesunclip();               
        for i,v in faxes_objects do //绘制坐标
        begin 
            v.paint(cvs);
        end 
        modify_label_postion();
        ftitle.paint(cvs);
        if fbox = tgc_on then 
        begin 
            set_lineinfo_to_canvas(cvs);
            paint_box(cvs);
        end         
    end 
    function axes_changed();//改变
    begin
        if not fFigure then return ;
        if f_changed then 
        begin
            change_locked := true;
            fr := fFigure.rect();
            w := fr[2]-fr[0];
            h := fr[3]-fr[1];
            
            p_left := fr[0]+w*fmargins[0]+faxes_bounds[0];
            p_top := fr[1]+h*fmargins[1]+faxes_bounds[1];
            p_width := w*(1-fmargins[0]-fmargins[2])*faxes_bounds[2];
            p_height := h*(1-fmargins[1]-fmargins[3])*faxes_bounds[3]; 
            fcvs_bounds := array(p_left,p_top,p_left+p_width,p_top+p_height);               
            if (f_changed .& c_g_data_changed)=c_g_data_changed then 
            begin
                tbds := fdata_bounds;
                for i,v in get_node_data_bounds(self(true)) do 
                begin 
                    if not fdata_bounds_locked[i] then 
                    begin
                        new_bounds(v[0],v[1],a_,b_);
                        tbds[i] := array(a_,b_);//v*1.05;
                    end  
                end                 
                fdata_bounds := tbds;
                fzoom_box := tbds*1.05;
                fzoom_bounds := fzoom_box;
            end 
            /////////////计算旋转矩阵//////////////////////////
            if (f_changed .& c_g_rote_changed)=c_g_rote_changed then 
            begin  
                c := cos(falpha);
                s := sin(falpha);
                c1 := cos(ftheta);
                s1 := sin(ftheta);
                frote_mt := array((0,1,0),(1,0,0),(0,0,1)):*array((c,s,0),(-s,c,0),(0,0,1)):*array((1,0,0),(0,c1,s1),(0,-s1,c1)); 
            end 
            ////////////////////////////////////////                    
            if (f_changed .& c_g_data_zoombox)=c_g_data_zoombox then 
            begin
                fzoom_bounds := fzoom_box;
            end  
            recalc_size();
            auto_set_axis();
            change_locked := false;
        end         
        f_changed := 0;        
    end 
    private 
    //////////长宽高////////////////////
    fbounds_center; //中心    
    //////////////////////
    fface_v_indexs; //定点次序
    flines_index;//
    ftheta;
    ftheta_a;
    falpha;
    falpha_a;
    frote_mt;
    fcvs_bounds; 
    fzoom_bounds;   
    fbox_vertexs;  
    fzoom_coordinate_rates; 
    fcoordinate_sizes; 
    frevers;    
    public  //create
    function set_trans(t,a); //设置转换角度
    begin
        if (t=ftheta) and (falpha=a) then return ;
        if ifnumber(t) then 
        begin
            ftheta_a := (r_2_a(t) mod 360);
            ftheta := a_2_r(ftheta_a);
        end 
        if ifnumber(a) then 
        begin            
            falpha_a := r_2_a(a) mod 360;
            falpha := a_2_r(falpha_a);
        end 
        if ifnumber(t) or ifnumber(a) then f_changed .|=8;
        prop_changed();
        return ;
    end         
    function create(pms);
    begin
        inherited;
        f_changed := 0;
        ftheta := 0;
        falpha := 0; 
        flines_index := array(
                            (0,1),
                            (1,2),
                            (2,3),
                            (3,0),
                            (4,5),
                            (5,6),
                            (6,7),
                            (7,4),                            
                            (0,4),
                            (1,5),
                            (2,6),
                            (3,7)                            
                        ); 
        fface_v_indexs := array(
                    (0,1,2,3),
                    (0,4,7,3),
                    (0,1,5,4),
                    (1,5,6,2),
                    (2,6,7,3),
                    (4,5,6,7)        
            );
        fcvs_bounds := array(0,0,200,200); 
        fcoordinate_sizes := array(200,200,200);        
        frote_mt := array((0,1,0),(1,0,0),(0,0,1)); 
        fbounds_center := array(100,100,100); 
        fzoom_bounds := array((0,200),(0,200),(0,200));       
        set_trans(0,pi()*1.5);
        fzoom_coordinate_rates := array(1,1,1);        
        fdata_bounds_locked := array(0,0,0);        
        fgrid := array();
        for i:= 0 to 1 do 
        begin 
            gd := new tg_line_info();
            gd.width := 0;
            gd.Style := tgc_PS_DOT;
            fgrid[i] := gd;
        end 
        
        faxes_reverse := array(tgc_off,tgc_off,tgc_off);
        fbox := tgc_off;
        ffilled := tgc_off;
        fx_location := tgc_bottom;
        fz_location := tgc_right;
        fy_location := tgc_left;
        faxes_objects := array();
        for i := 0 to 2 do 
        begin 
            axi := new tg_axis_main();
            axi.tics_style := tgc_tics_v;//tgc_tics_r;
            lbl := new tg_label_axis();
            case i of 
                0: 
                begin
                    fx_label := lbl;
                    axi.tics_direction := tgc_bottom;
                    axi.ytics_coord := array("x",0,0);
                    axi.tag := "+x+";
                end 
                1:
                begin
                    fy_label := lbl;
                    axi.tics_direction := tgc_left;
                    axi.ytics_coord := array(0,"y",0);
                    axi.tag := "+y+";
                end 
                2:
                begin
                    fz_label := lbl;
                    //axi.visible := false;
                    axi.ytics_coord := array(0,0,"z");
                    axi.tag := "+z+";
                end 
            end ;
            axi.axis_label := lbl;
            faxes_objects[i] := axi;
            axi.axes := self(true);
        end  
         
        ftitle := new tg_label_axes();
        ftitle.axes := self(true); 
        ftitle.location := tgc_by_axes;     
        fauto_ticks := array(tgc_on,tgc_on,tgc_on);
        fmargins := array(0.125,0.125,0.125,0.125);
        faxes_bounds := array( 0,0,1,1);
        fdata_bounds := array((0,1),(0,1),(0,1));
        fzoom_box := fdata_bounds;
        //FA vector containing the handles of all graphics objects children of the 
        //axes These graphics objects are of type 
        //"Compound", "Rectangle", "Polyline", "Segs", "Arc", "Grayplot",.. (see Compound_properties, 
        //rectangle_properties, champ_properties, axis_properties, polyline_properties, segs_properties, 
        //grayplot_properties, surface_properties, fec_properties, text_properties, legend_properties)
    end 
    published
    property figure read fFigure write SetFigure;  //窗口  
    property axises read get_axises;//axes_visible ;//= ["on","on","on"]
    property axes_reverse read gs_axes_reverse write gs_axes_reverse;//axes_reverse ;//= ["off","off","off"]
    property x_location read fx_location write set_x_location;//'bottom
    property y_location read fy_location write set_y_location;//'left
    property z_location read fz_location write set_z_location;//'left
    property title read ftitle;
    property x_label read fx_label;
    property y_label read fy_label;
    property z_label read fz_label;
    property auto_ticks read gs_auto_ticks write gs_auto_ticks;
    property box read fbox write set_box;
    property filled read ffilled write set_filled;
    property sub_ticks read gs_sub_ticks write gs_sub_ticks;    
    //上下左右空白
    property margins read gs_margins write gs_margins;
    property axes_bounds read gs_axes_bounds write gs_axes_bounds;
    property data_bounds read gs_data_bounds write gs_data_bounds;
    property zoom_box read gs_zoom_box write gs_zoom_box;
    //在窗口中的区域
        
    //网格线
    property grid read get_grid;
    
    
    //grid ;//= [-1,-1]
    //grid_position ;//= "background"
    //grid_thickness ;//= [1,1]
    //grid_style ;//= [7,7]
    //x_ticks.locations ;//= matrix 21x1
    //y_ticks.locations ;//= matrix 11x1
    //z_ticks.locations ;//= []
    //x_ticks.labels ;//= matrix 21x1
    //y_ticks.labels ;//= matrix 11x1
    //z_ticks.labels ;//= []
    //ticks_format ;//= ["","",""]
    //ticks_st ;//= [1,1,1;0,0,0]
    //sub_ticks ;//= [1,1]
    font_style ;//= 6
    font_size ;//= 1
    font_color ;//= -1
    fractional_font ;//= "off"
     
    //isoview ;//= "off"
    //cube_scaling ;//= "off"
    //rotation_angles ;//= [0,270]
    //log_flags ;//= "nnn"
    //tight_limits ;//= ["off","off","off"]
    //zoom_box ;//= []
    //auto_margins ;//= "on"     
    //auto_clear ;//= "off"
    //auto_scale ;//= "on"
    //auto_stretch ;//= "on"
     
    //hidden_axis_color ;//= 4
    //hiddencolor ;//= 4
    //line_mode ;//= "on"
    //line_style ;//= 1
    //thickness ;//= 1
    //mark_mode ;//= "off"
    //mark_style ;//= 0
    //mark_size_unit ;//= "tabulated"
    //mark_size ;//= 0
    //mark_foreground ;//= -1
    //mark_background ;//= -2
    //foreground ;//= -1
    //background ;//= -2
    //arc_drawing_method ;//= "lines"
    //clip_state ;//= "clipgrf"
    //clip_box ;//= []
    protected
    function get_axes();override;
    begin
        return self(true);
    end 
    private //variable
    fgrid;
    faxes_objects;
    fzoom_box;
    fmargins;
    faxes_bounds ;//= [0,0,1,1]
    fdata_bounds;
    fdata_bounds_locked;
    ffilled;
    fauto_ticks;
    ftitle; 
    fx_label;
    fy_label;
    fz_label;
    fx_location;
    fy_location;
    fz_location;
    fbox;
    faxes_reverse;
    private  
    fwilldelfigure;
    fwilladdfigure;
    function paint_grid(cvs);//绘制表格
    begin
        xg := fgrid[0];
        if xg.width>0 and ifnumber(xg.color) then 
        begin 
            set_lineinfo_to_canvas(cvs,xg);
            //y1 := p_top;
            //y2 := p_top+p_height;
            for i,v in faxes_objects[0].executecommand("get_tics_value") do 
            begin 
                if v<fzoom_box[0,0] or v>fzoom_box[0,1] then continue;
                if zoom_to_xyz(v,fzoom_box[1,0],0,_x1,_y1) then 
                begin 
                    zoom_to_xyz(v,fzoom_box[1,1],0,_x2,_y2);
                    cvs.moveto(array(_x1,_y1));
                    cvs.lineto(array(_x2,_y2));
                end               
            end  
        end 
        xg := fgrid[1];
        if xg.width>0 and ifnumber(xg.color) then 
        begin 
            set_lineinfo_to_canvas(cvs,xg);
            for i,v in faxes_objects[1].executecommand("get_tics_value") do 
            begin 
                if v<fzoom_box[1,0] or v>fzoom_box[1,1] then continue;
                if zoom_to_xyz(fzoom_box[0,0],v,0,_x1,_y1) then 
                begin 
                    zoom_to_xyz(fzoom_box[0,1],v,0,_x2,_y2);
                    cvs.moveto(array(_x1,_y1));
                    cvs.lineto(array(_x2,_y2));
                end                
            end  
        end        
    end 
    function paint_box(cvs);
    begin
        r := array();
        ls := array();
        ps2 := array();
        inpoints := array();
        tf := get_top_face(); //获得顶部的3个面
        for i,fc in tf do 
        begin
            for ii in fbox_vertexs do //判断点是否在面的阴影中
            begin
                if (ii in fc) then continue;
                if  point_in_rgn(fbox_vertexs[ii],fbox_vertexs[fc]) then 
                begin 
                 inpoints[length(inpoints)] := ii;    
                end  
            end 
        end 
        hd := array(); 
        for i,v in flines_index do //判断线是否需要隐藏
        begin            
            ps := fbox_vertexs[v];
            if (inpoints intersect v) then hd[i] := true;
            for j,vj in ps do 
                ls[i,j] := vj[0:1]+fbounds_center;
        end          
        for i,v in ls do //绘制线
        begin
            ps1 := v;
            if hd[i] then cvs.pen.style := 1;
            else  cvs.pen.style := 0;
            cvs.draw_polyline().points(ps1).draw();
        end 
    end
    function auto_set_axis();//自动计算坐标
    begin
        for i:=0 to 2 do 
        begin
            axi :=faxes_objects[i]; 
            axi.executecommand("set_bounds",fzoom_box[i]);
            if axi.visible<>tgc_on then continue;
            fsz := axi.fontinfo.size;
            if fauto_ticks[i] = tgc_on then 
            begin
                [arg,ifx,sz] := axi.executecommand("get_angleofhoriz");
                if ifx then 
                begin
                    n := integer(sz/(fsz*12));        
                end else
                begin
                    n := integer(sz/(fsz*4));
                end
                xcd := array();
                xcdls := array();
                if n>0 then 
                begin 
                    rt := new_bounds(fzoom_box[i,0],fzoom_box[i,1],a_,b_);
                    bs :=ceil((b_-a_)/(rt)/n);
                    axi.sub_tics := min(bs,5);
                    stp :=  bs*rt;
                    vi := a_;
                    ii := 0;
                    while vi<=b_ do 
                    begin 
                        xcd[ii++] := vi;
                        vi+=stp;                        
                    end 
                end 
                axi.tics_coord := xcd;
            end
        end         
    end  
    function xy_in_paint_rect(x,y);//鼠标是否在坐标内
    begin
        if not ifnumber(x) then return false;
        if not ifnumber(y) then return false;
        if x<p_left or x>(p_left+p_width) then return false;    
        if y<p_top or y>(p_top+p_height) then return false; 
        return true; 
    end 
    function zoom_bound_op(a,b,dx,x,a1,b1);//缩放
    begin
        if x<a or  x>b then return false;
        if not(ifnumber(dx))  then return false ;
        len := (b-a)/dx; 
        rt := (x-a)/(b-a); 
        a1 := x-len*rt;  
        b1 := a1+len;
        return true;
    end 
    function modify_label_postion(); //修正标签位置
    begin
        if ftitle and (ftitle.visible=tgc_on) and (ftitle.auto_position=tgc_on) then 
        begin 
            s := ftitle.text;
            if s then 
            begin 
                ax  := faxes_objects[0];
                //y := p_top-20-(ftitle.fontinfo.size*2);
                fr := fFigure.rect();
                y := fr[1]+10;
                {if (ax.visible=tgc_on) and (ax.tics_direction = tgc_top) then 
                begin 
                    y -=(ax.fontinfo.size*2);    
                end}
                x := p_left+(p_width-length(s)*10)/2;
                if ftitle.location=tgc_by_coordinates then
                    xyz_to_zoom(x,y,0,_x,_y,_z);
                else axes_unmapping(x,y,_x,_y,_z);
                ftitle.executecommand("auto_position_value",array(_x,_y)); 
            end    
        end 
    end 
    function get_axis_index(p);
    begin
        r := array();
        for i,v in p do 
        begin 
            zoom_to_xyz(v[0],v[1],v[2],_x0,_y0,_z0);
            r[i] := array(_x0,_y0,_z0);
        end 
        return sselect thisrowindex from r order by [1] asc end;
    end 
    function get_duan_dian(x0,y0,z0,x1,y1,z1,x2,y2,z2);
    begin
        x0 := fzoom_box[0,0];
        y0 := fzoom_box[1,0];
        z0 := fzoom_box[2,0];
        x1 := fzoom_box[0,1];
        y1 := fzoom_box[1,1];
        z1 := fzoom_box[2,1];
        x2 := (x0+x1)/2;
        y2 := (y0+y1)/2;
        z2 := (z0+z1)/2;
    end 
     
    function modify_x_position(loc);
    begin
        get_duan_dian(x0,y0,z0,x1,y1,z1,x2,y2,z2);
        //////bottom
        px := array();                
        px[0] := array(x2,y0,z0);
        px[1] := array(x2,y0,z1);
        ///top
        px[2] := array(x2,y1,z0);
        px[3] := array(x2,y1,z1);
        r := array();
        for i,v in px do 
        begin 
            zoom_to_xyz(v[0],v[1],v[2],_x0,_y0,_z0);
            r[i] := array(_x0,_y0,_z0);
        end 
        axx := faxes_objects[0];
        case loc of
            tgc_bottom:
            begin            
                if like_0(ftheta) then 
                begin
                    if faxes_reverse[1]=tgc_on then idx := 2;
                    else 
                        idx := 0;                        
                end else 
                begin
                    idxs := sselect thisrowindex from r order by [1] asc end; 
                    if faxes_reverse[1]=tgc_on then idx := idxs[3];
                    else 
                        idx := idxs[0];
                end 
                idxv := px[idx]; 
                zoom_to_xyz(x2,y2,z2,_x0,_y0,_z0);//中间点
                zoom_to_xyz(x0,idxv[1],idxv[2],_x00,_y00,_z00);//轴线0点
                v1 := array(_x0-r[idx,0],_y0-r[idx,1]);//射线方向
                v2 := array(r[idx,0]-_x00,r[idx,1]-_y00); //轴方向
                p_trans(v2[0],v2[1],-pi()/2.01,_x,_y);
                jj := r_2_a( d2angle(array(_x,_y),v1));
                axx.ytics_coord := array("x",idxv[1],idxv[2]);
                if jj>90 then axx.tics_direction := tgc_direct_desc ;
                else axx.tics_direction := tgc_direct_asc;  
                return ;
                axx.ytics_coord := array("x",fzoom_box[1,(faxes_reverse[1]= tgc_on)],fzoom_box[2,(faxes_reverse[1]= tgc_on)]); 
                if faxes_reverse[0]=tgc_on then axx.tics_direction := tgc_direct_asc;
                else   
                    axx.tics_direction := tgc_direct_desc; 
            end 
            tgc_top:
            begin
                if like_0(ftheta) then 
                begin
                    if faxes_reverse[1]=tgc_on then idx := 0;
                    else 
                        idx := 2;                        
                end else 
                begin
                    idxs := sselect thisrowindex from r order by [1] desc end; 
                    if faxes_reverse[1]=tgc_on then idx := idxs[3];
                    else 
                        idx := idxs[0];
                end 
                idxv := px[idx]; 
                zoom_to_xyz(x2,y2,z2,_x0,_y0,_z0);//中间点
                zoom_to_xyz(x0,idxv[1],idxv[2],_x00,_y00,_z00);//轴线0点
                v1 := array(_x0-r[idx,0],_y0-r[idx,1]);//射线方向
                v2 := array(r[idx,0]-_x00,r[idx,1]-_y00); //轴方向
                p_trans(v2[0],v2[1],-pi()/2.01,_x,_y);
                jj := r_2_a( d2angle(array(_x,_y),v1));
                axx.ytics_coord := array("x",idxv[1],idxv[2]);
                if jj>90 then axx.tics_direction := tgc_direct_desc ;
                else axx.tics_direction := tgc_direct_asc;  
                return ;                
                axx.ytics_coord := array("x",fzoom_box[1,(faxes_reverse[1]<> tgc_on)],fzoom_box[2,(faxes_reverse[1]= tgc_on)]);  
                if faxes_reverse[0]=tgc_on then axx.tics_direction := tgc_direct_desc;
                else   
                    axx.tics_direction := tgc_direct_asc;   
            end 
            tgc_middle:
            begin
                axx.ytics_coord := array("x",fzoom_box[1,0]+(fzoom_box[1,1]-fzoom_box[1,0])/2,0);
            end
            tgc_origin:
            begin
                if fzoom_box[1,0]<0 and fzoom_box[1,1]>0 then 
                    axx.ytics_coord := array("x",0,0);
                else 
                begin
                    return modify_x_position(tgc_bottom);
                    //axx.ytics_coord := array("x",fzoom_box[1,(faxes_reverse[1]= tgc_on)],0); 
                end 
                axx.tics_direction := tgc_direct_desc; 
            end 
        end ;    
    end 
    function modify_y_postion(loc);
    begin
        get_duan_dian(x0,y0,z0,x1,y1,z1,x2,y2,z2);
        //////left
        py := array();                
        py[0] := array(x0,y2,z0);
        py[1] := array(x0,y2,z1);
        ///right
        py[2] := array(x1,y2,z0);
        py[3] := array(x1,y2,z1);
        r := array();
        for i,v in py do 
        begin 
            zoom_to_xyz(v[0],v[1],v[2],_x0,_y0,_z0);
            r[i] := array(_x0,_y0,_z0);
        end         
        axy := faxes_objects[1];
        case loc of 
            tgc_left:
            begin            
                if like_0(ftheta) then 
                begin
                    if faxes_reverse[0]=tgc_on then idx := 2;
                    else 
                        idx := 0;                        
                end else 
                begin
                    idxs := sselect thisrowindex from r order by [1] desc end; 
                    if faxes_reverse[0]=tgc_on then idx := idxs[3];
                    else 
                        idx := idxs[0];
                end
                idxv := py[idx]; 
                zoom_to_xyz(x2,y2,z2,_x0,_y0,_z0);//中间点
                zoom_to_xyz(idxv[0],y0,idxv[2],_x00,_y00,_z00);//轴线0点
                v1 := array(_x0-r[idx,0],_y0-r[idx,1]);//射线方向
                v2 := array(r[idx,0]-_x00,r[idx,1]-_y00); //轴方向
                p_trans(v2[0],v2[1],-pi()/2.01,_x,_y);
                jj := r_2_a( d2angle(array(_x,_y),v1));
                axy.ytics_coord := array(py[idx,0],"y",py[idx,2]);
                if jj>90 then axy.tics_direction := tgc_direct_desc ;
                else axy.tics_direction := tgc_direct_asc;  
                return ;
                axy.ytics_coord := array(fzoom_box[0,(faxes_reverse[0] = tgc_on)],"y",fzoom_box[2,(faxes_reverse[1]= tgc_on)]); 
                if faxes_reverse[1]=tgc_on then axy.tics_direction := tgc_direct_desc ; 
                else 
                    axy.tics_direction := tgc_direct_asc;                                                    
            end 
            tgc_right:
            begin
                if like_0(ftheta) then 
                begin
                    if faxes_reverse[0]=tgc_on then idx := 0;
                    else 
                        idx := 2;                        
                end else 
                begin
                    idxs := sselect thisrowindex from r order by [1] asc end; 
                    if faxes_reverse[0]=tgc_on then idx := idxs[3];
                    else 
                        idx := idxs[0];
                end
                idxv := py[idx]; 
                zoom_to_xyz(x2,y2,z2,_x0,_y0,_z0);//中间点
                zoom_to_xyz(idxv[0],y0,idxv[2],_x00,_y00,_z00);//轴线0点
                v1 := array(_x0-r[idx,0],_y0-r[idx,1]);//射线方向
                v2 := array(r[idx,0]-_x00,r[idx,1]-_y00); //轴方向
                p_trans(v2[0],v2[1],-pi()/2.01,_x,_y);
                jj := r_2_a( d2angle(array(_x,_y),v1));
                axy.ytics_coord := array(py[idx,0],"y",py[idx,2]);
                if jj>90 then axy.tics_direction := tgc_direct_desc ;
                else axy.tics_direction := tgc_direct_asc;  
                return ;
                axy.ytics_coord := array(fzoom_box[0,(faxes_reverse[0]<> tgc_on)],"y",fzoom_box[2,(faxes_reverse[1]= tgc_on)]);
                if faxes_reverse[1]=tgc_on then axy.tics_direction := tgc_direct_asc; 
                else 
                    axy.tics_direction := tgc_direct_desc; 
            end 
            tgc_middle:
            begin
                axy.ytics_coord := array(fzoom_box[0,0]+(fzoom_box[0,1]-fzoom_box[0,0])/2,"y",0);
            end   
            tgc_origin:
            begin
                if fzoom_box[0,0]<0 and fzoom_box[0,1]>0 then
                begin  
                    axy.ytics_coord := array(0,"y",0);                    
                end 
                else 
                begin
                    return modify_y_postion(tgc_left);
                    //axy.ytics_coord := array(fzoom_box[0,(faxes_reverse[0] = tgc_on)],"y",0);
                end 
                axy.tics_direction := tgc_direct_asc; 
            end 
        end;      
    end 
    function modify_z_position(loc);
    begin
        if like_0(ftheta_a) then return ;
        get_duan_dian(x0,y0,z0,x1,y1,z1,x2,y2,z2);
        axz := faxes_objects[2];
        pz := array();                
        pz[0] := array(x0,y0,z2);
        pz[1] := array(x1,y0,z2);
        pz[2] := array(x1,y1,z2);
        pz[3] := array(x0,y1,z2);
        r := array();
        for i,v in pz do 
        begin 
            zoom_to_xyz(v[0],v[1],v[2],_x0,_y0,_z0);
            r[i] := array(_x0,_y0,_z0);
        end 
        case loc of 
            tgc_right:
            begin 
                idxs :=  sselect thisrowindex from r order by [0] desc end;  
            end 
            else 
            begin
                idxs :=  sselect thisrowindex from r order by [0] asc end; 
            end
        end; 
        idx := idxs[0];  
        idxv := pz[idx]; 
        zoom_to_xyz(x2,y2,z2,_x0,_y0,_z0);//中间点
        zoom_to_xyz(idxv[0],idxv[1],z0,_x00,_y00,_z00);//轴线0点
        v1 := array(_x0-r[idx,0],_y0-r[idx,1]);//射线方向
        v2 := array(r[idx,0]-_x00,r[idx,1]-_y00); //轴方向
        p_trans(v2[0],v2[1],-pi()/2.01,_x,_y);
        jj := r_2_a( d2angle(array(_x,_y),v1));
        axz.ytics_coord := array(pz[idx,0],pz[idx,1],"z");
        if jj>90 then axz.tics_direction := tgc_direct_desc ;
        else axz.tics_direction := tgc_direct_asc;  
        return ;
        
        axz.ytics_coord := array(idxv[0],idxv[1],"z"); 
        if ftheta_a>180 or ftheta_a<0 then axz.tics_direction :=tgc_direct_asc ; 
        else axz.tics_direction := tgc_direct_desc  ; 
    end
    function modify_coordinate_position();//修正坐标轴位置
    begin
        
        ////////////////y轴///////////////////////////////////        
        modify_y_postion(fy_location);
        ///////////////x///////////////////////////////
        modify_x_position(fx_location);        
        //////z-axis 
        modify_z_position(fz_location);
    end 
    function SetFigure(v); //添加窗口
    begin
        if v=fFigure then return ;        
        if fwilladdfigure and fwilladdfigure=v then 
        begin 
            fwilladdfigure := nil;
            fFigure := v;
            v.add_axes(self(true));
            f_changed .|= c_g_paint_rect;
            return ;
        end 
        if fwilldelfigure and fwilldelfigure=tp then 
        begin 
            fwilldelfigure := nil;
            fFigure := nil;
            v.del_axes(self(true));
            return ;
        end 
        tp := fFigure;
        if tp then //删除 
        begin 
             fwilldelfigure := tp;
             tp.del_axes(self(true));  
             fwilldelfigure := nil; 
        end 
        if v is class(tg_figure) then //添加
        begin     
            fwilladdfigure := v;
            v.add_axes(self(true));  
            fwilladdfigure := nil;      
        end else 
        begin 
            fFigure := nil;        
        end 
    end    
    function set_filled(v);
    begin
        if not tg_boolen_value(v,nv) then return ;
        if nv<>fbox then 
        begin
            ffilled := nv;
            prop_changed("ffilled",nv);
        end  
    end 
    function set_box(v);
    begin
        if not tg_boolen_value(v,nv) then 
        begin 
            nv := v;
        end 
        if (nv in array(tgc_box_on,tgc_box_off,tgc_box_half,tgc_box_hidden_axes)) and v<>fbox then 
        begin
            fbox := nv;
            prop_changed("box",v);
        end  
    end 
    function set_x_location(v);
    begin
        if v<>fx_location and ( v in array(tgc_bottom,tgc_top,tgc_middle,tgc_origin)) then 
        begin 
            fx_location := v;
            prop_changed("x_location",v);
        end 
    end 
    function set_y_location(v);
    begin
        if v<>fy_location and ( v in array(tgc_left,tgc_right,tgc_middle,tgc_origin)) then 
        begin 
            fy_location := v;
            prop_changed("y_location",v);
        end 
    end
    function set_z_location(v);
    begin
        if v<>fz_location and ( v in array(tgc_left,tgc_right)) then 
        begin 
            fz_location := v;
            prop_changed("z_location",v);
        end 
    end
    function get_grid(idx);
    begin
        if idx=0 or idx=1 then return fgrid[idx];
    end 
    function set_view(v);
    begin
        return ;
    end 
    function gs_auto_ticks(vidx,v);//自动更新坐标标签
    begin
        tg_boolen_value(v,nv);
        idx := tg_get_true_idx(vidx);
        if nv=tgc_on or nv=tgc_off then 
        begin 
            if idx in array(0,1,2) then 
            begin 
                if fauto_ticks[idx]<>nv then 
                begin 
                    fauto_ticks[idx] := nv;
                    if nv=tgc_on then faxes_objects[i].tics_style := tgc_tics_v;//faxes_objects[i].tics_style := tgc_tics_r;
                    //else faxes_objects[i].tics_style := tgc_tics_v;
                    prop_changed("auto_ticks",idx);
                end      
            end         
        end else //get 
        begin 
            if idx in array(0,1,2) then return  fauto_ticks[idx];
            return fauto_ticks;            
        end         
    end
    function get_axises(vidx); 
    begin
        idx := tg_get_true_idx(vidx);
        if idx in array(0,1,2) then 
        begin 
            return faxes_objects[idx];    
        end    
    end
    function gs_axes_bounds(idx,v);
    begin
        if ifarray(v) and ifnumber(v[0]) and ifnumber(v[1]) then 
        begin 
            if idx in array(0,1,2,3) then 
            begin 
                faxes_bounds[idx] := array(v[0],v[1]); 
                f_changed .|=c_g_paint_rect ; 
                prop_changed("axes_bounds",idx);     
            end         
        end else //get 
        begin 
            if idx in array(0,1,2,3) then return  faxes_bounds[idx];
            return faxes_bounds;             
        end         
    end 
    function gs_data_bounds(vidx,v);
    begin
        idx := tg_get_true_idx(vidx);
        if v=-1 then 
        begin
            if idx in array(0,1,2) then
            begin
                fdata_bounds_locked[idx] := false;    
            end     
        end else 
        if ifarray(v) and  ifnumber(v[0]) and ifnumber(v[1]) then 
        begin 
            if idx in array(0,1,2) then 
            begin 
                fdata_bounds[idx] := v;   
                fdata_bounds_locked[idx] := true;
                prop_changed("data_bounds",idx);     
            end         
        end else //get 
        begin 
            if idx in array(0,1,2) then return  fdata_bounds[idx];
            return fdata_bounds;             
        end         
    end
    function gs_zoom_box(vidx,v);
    begin
        idx := tg_get_true_idx(vidx);
        if ifarray(v) and  ifnumber(v[0]) and ifnumber(v[1]) then 
        begin 
            if idx in array(0,1,2) then 
            begin 
                fzoom_box[idx] := v;   
                prop_changed("zoom_box",idx);     
            end         
        end else //get 
        begin 
            if idx in array(0,1,2) then return  fzoom_box[idx];
            return fzoom_box;             
        end     
    end     
    function gs_axes_reverse(vidx,v); //反向
    begin
        if not tg_boolen_value(v,nv) then return ;
        idx := tg_get_true_idx(vidx);
        if nv=tgc_off or nv=tgc_on then 
        begin 
            if idx in array(0,1) then 
            begin 
                faxes_reverse[idx] := nv;   
                prop_changed("axes_reverse",idx);     
            end         
        end else //get 
        begin 
            if idx in array(0,1) then return  faxes_reverse[idx];
            return faxes_reverse;             
        end         
    end 
    function gs_margins(idx,v); //空白
    begin
        if ifnumber(v) then 
        begin 
            if idx in array(0,1,2,3) then 
            begin 
                fmargins[idx] := v;  
                f_changed .|= c_g_paint_rect; 
                prop_changed("margins",idx);     
            end         
        end else //get 
        begin 
            if idx in array(0,1,2,3) then return  fmargins[idx];
            return fmargins;             
        end         
    end    
    function gs_sub_ticks(vidx,v); //小刻度线
    begin
        idx := tg_get_true_idx(vidx);
        if ifnumber(v) and (v>=0) then 
        begin 
            if idx in array(0,1,2) then 
            begin 
                faxes_objects[idx].sub_tics := v;        
            end         
        end else //get 
        begin 
            if idx in array(0,1,2) then return  faxes_objects[idx].sub_tics;
            return array(faxes_objects[0].sub_tics,faxes_objects[1].sub_tics,faxes_objects[2].sub_tics);            
        end      
    end 
    
    ////////////////三维转换////////////////////
    function transxyz(x,y,z,_x,_y,_z); //旋转数据
    begin
        r := array((x,y,z)):*frote_mt;
        _x := r[0,0];
        _y := r[0,1];
        _z := r[0,2];
    end 
    function untransxyz(x,y,z,_x,_y,_z);
    begin
        r := array((x,y,z)):/frote_mt;
        _x := r[0,0];
        _y := r[0,1];
        _z := r[0,2];  
    end 
    function get_new_w_h(w1,h1,w,h,z);//获取变换的大小
    begin
        //z1 := (w1+h1)/2;
        z1 := min(w1,h1);
        z := z1; 
        w := w1;
        h := h1;       
        while true do 
        begin 
            ps := init_vecs(h,w,z);            
            bd := zeros(2,2);
            for i,v in ps do 
            begin
                transxyz(v[0],v[1],v[2],_x,_y,_z); 
                bd[0,0] := min(_x,bd[0,0]);
                bd[0,1] := max(_x,bd[0,1]);
                bd[1,0] := min(_y,bd[1,0]);
                bd[1,1] := max(_y,bd[1,1]);   
            end 
            bw := bd[0,1]-bd[0,0];
            bh := bd[1,1]-bd[1,0];
            if bw<w1 and bh<h1 then break;
            w*=0.99;
            h*=0.99;
            z*=0.99;
        end 
        mj1 := w*h;
        bk := array(w,h,z);
        z := z1; 
        w := h1;
        h := w1;       
        while true do 
        begin 
            ps := init_vecs(h,w,z);            
            bd := zeros(2,2);
            for i,v in ps do 
            begin
                transxyz(v[0],v[1],v[2],_x,_y,_z); 
                bd[0,0] := min(_x,bd[0,0]);
                bd[0,1] := max(_x,bd[0,1]);
                bd[1,0] := min(_y,bd[1,0]);
                bd[1,1] := max(_y,bd[1,1]);   
            end 
            bw := bd[0,1]-bd[0,0];
            bh := bd[1,1]-bd[1,0];
            if bw<w1 and bh<h1 then break;
            w*=0.99;
            h*=0.99;
            z*=0.99;
        end 
        mj2 := w*h;
        if mj2<mj1 then 
        begin
            [w,h,z] := bk;
        end         
    end 
    function recalc_size(); //重算大小
    begin
        w1 := fcvs_bounds[2]-fcvs_bounds[0];
        h1 := fcvs_bounds[3]-fcvs_bounds[1];
        fbounds_center := array(fcvs_bounds[0]+w1/2,fcvs_bounds[1]+h1/2,0);                            
        get_new_w_h(w1,h1,w,h,z);
        fcoordinate_sizes[0] := h;
        fcoordinate_sizes[1] := w;
        fcoordinate_sizes[2] := z;
        fzoom_coordinate_rates[0] := (fzoom_bounds[0,1]-fzoom_bounds[0,0])/h;
        fzoom_coordinate_rates[1] := (fzoom_bounds[1,1]-fzoom_bounds[1,0])/w;
        fzoom_coordinate_rates[2] := (fzoom_bounds[2,1]-fzoom_bounds[2,0])/z;
        fbox_vertexs := array();
        for i,v in  init_vecs(h,w,z) do 
        begin
            transxyz(v[0],v[1],v[2],x,y,z); 
            fbox_vertexs[i] := array(x,y,z);
        end 
    end 
    function init_vecs(x,y,z); //初始化顶点
    begin
        r := array();
        r[0]:=array(-x/2, -y/2, -z/2); //0
        r[1]:=array(-x/2, y/2, -z/2); //1
        r[2]:=array(x/2, y/2, -z/2); //2
        r[3]:=array(x/2, -y/2, -z/2); //3        
        r[4]:=array(-x/2, -y/2, z/2); //4
        r[5]:=array(-x/2, y/2, z/2); //5
        r[6]:=array(x/2, y/2, z/2); //6
        r[7]:=array(x/2, -y/2, z/2); //7
        return r;  
    end 
    function get_top_face(); //获取最上面的三个面,便于计算隐藏的线
    begin
        r := array();
        for i , v in fface_v_indexs do 
        begin 
            zi := 0;
            for j,vj in v do 
            begin 
                zi += fbox_vertexs[vj][2];
            end 
            r[i] := zi;
        end 
        r := sselect thisrowindex  from r order by thisrow desc end;
        return fface_v_indexs[r[0:2]];
    end 
        
end 
type tg_canvas = class(TcustomCanvas)
    uses utslvclgdi;
    function create(h);
    begin
        inherited create();
        FCvsHandle := h;
        Handle := h;
        faxesrgn := new TRGNPOLY();//new TRGNRECT(); 
        faxesrgntemp := new TRGNPOLY();//new TRGNRECT(); 
    end  
    function axesclip();
    begin 
        if faxesrgn then 
        begin
            _wapi.SelectClipRgn(FCvsHandle,faxesrgn.Handle); //裁剪区域	    
        end    
    end 
    function clip_rgn(pts);
    begin
        faxesrgntemp.points := pts;
        h := faxesrgntemp.Handle;
        if h then  _wapi.SelectClipRgn(FCvsHandle,faxesrgntemp.Handle); 
    end 
    function axesunclip();
    begin 
        _wapi.SelectClipRgn(FCvsHandle,0);       
    end 
    function destroy();
    begin
        Handle := 0;
        faxesrgn := nil;
    end 
    property axesrec read FaxesRec write set_clip_rect;
    private 
    FaxesRec;
    FCvsHandle;
    faxesrgn;
    faxesrgntemp;
    private 
    function set_clip_rect(rec);
    begin 
        FaxesRec := rec;
        //faxesrgn.rect := rec; 
        pts := rec_to_points(rec);
        faxesrgn.points := pts; 
    end
end 
type tg_axis_main = class(tg_axis) //主轴
    public 
    function create(pms);
    begin
        inherited;
    end     
    protected
    function prop_changed(n,v);override;
    begin
        case n of 
            "tics_direction","xtics_coord","ytics_coord":
            begin
                return ;
            end else
            begin            
                //echo "\r\n",n;
            end 
        end 
        inherited;
    end 
    function SetParent(V);override;
    begin
    
    end 
    function get_axes();override;
    begin
        return faxes;
    end 
    function set_axes(axs);override;
    begin
        if axs is class(tg_axes) then faxes := axs;    
    end 
    private 
    [weakref] faxes;    
end 
type tg_label_axis = class(tg_label)
     public 
    function create(pms);
    begin
        inherited; 
        ftext := "";
        ffont_angle := 0;
    end
    published
    property font_angle read ffont_angle write set_font_angle;//90
    property text read ftext write set_text;
    protected
    function SetParent(V);override;
    begin
    end 
    private 
    ffont_angle;
    ftext;
    private 
    function set_font_angle(ag);
    begin
        if v<>ffont_angle and ifnumber(v) then 
        begin 
            ffont_angle := v;
            prop_changed("font_angle",v);
        end 
    end 
    function set_text(v);
    begin
        if v<>ftext and ifstring(v) then 
        begin 
            ftext := v;
            prop_changed("text",v);
        end 
    end 
end 
type tg_label_axes = class(tg_label) //坐标系标签
    public 
    function create(pms);
    begin
        inherited; 
        clip_state := tgc_off;
        auto_position := tgc_on;
    end
    protected
    function SetParent(V);override;
    begin
    end 
    function get_axes();override;
    begin
        return faxes;
    end 
    function set_axes(axs);override;
    begin
        if axs is class(tg_axes) then faxes := axs;     
    end 
    private 
    [weakref] faxes;
end 
type tg_axis = class(tg_base) //轴对象
    function create(pms);
    begin
        inherited;
        clip_state := tgc_off;
        fticksize := 12;
        fsubticksize := 6;
        ftics_direction := tgc_direct_asc; //
        fxtics_coord := array(0,1,2,3);
        ftcmin := 0;
        ftcmax := 3;
        ftccount := 3;
        fxtics_coord_v := array(0,1,2,3);
        fytics_coord := array("tics",0,0);
        ftics_labels := array("0","1","2","3");
        ftics_segment := tgc_on;
        ftics_style := tgc_tics_v;//"v";
        fsub_tics := 2;
        ftics_color := nil;
        //"v". It's the default value, In this case, tics positions are given by the row factor xtics_coord for horizontal axis (ytics_coord for the vertical one).
        //"r". In this case, tics positions are given by the vector [min,max,n] where n is the number of intervals.
        //"i". In this case the vector given tics positions is of size 4, [k1,k2,a,n] then values are increasing between k1*10^a and k2*10^a, n is the number of intervals.
    end  
    function executecommand(cmd,pm);override;
    begin
        case cmd of 
            "tics_recs" : return (visible=tgc_on)?ftics_recs:nil;
            "label_rgn": return (flabel.visible=tgc_on)?flabel_rgn:nil;
            "get_tics_value":return fxtics_coord_v; 
            "set_bounds": return  set_zoom_bounds(pm); 
            "get_angleofhoriz" : 
            begin
                 get_angleofhoriz(xarg,ifh,sz);  
                 return array(xarg,ifh,sz);
            end  
        end;
    end    
    function paint(cvs);override;
    begin
        if visible<>tgc_on then return ;
        if clip_state=tgc_on then cvs.axesclip();
        else cvs.axesunclip();
        subtks := array();
        idx := 0;        
        if fsub_tics>1 then 
        begin 
            for i:= 0 to length(fxtics_coord_v)-2 do 
            begin
                dx := (fxtics_coord_v[i+1]-fxtics_coord_v[i])/fsub_tics;
                for j := 1 to  (fsub_tics-1) do 
                begin 
                    vi := fxtics_coord_v[i]+dx*j;
                    if fzoom_bounds and (vi<fzoom_bounds[0] or vi>fzoom_bounds[1]) then continue;
                    subtks[idx++] := vi;
                end   
            end 
        end  
        return draw_axis(cvs,subtks);             
    end 
    protected
    function draw_tics(cvs,info);virtual;
    begin
        for i,v in info do 
        begin 
            cvs.drawtext(v[0],v[1]);
        end 
    end 
    function check_parent(p);override;
    begin
        return  (not(p)) or (p is class(tg_compound)) or (p is class(tg_axes));
    end 
    published
    /////////////////////////////////////
    property tics_direction read ftics_direction write set_tics_direction;//= "top"
    property tics_coord read  fxtics_coord write set_xtics_coord ;//= [2,3,4,5,6,7]
    property ytics_coord read  fytics_coord write set_ytics_coord ;//= 4
    property tics_segment read ftics_segment write set_tics_segment; // true,false
    property tics_color read ftics_color write set_tics_color; //  -1
    property tics_style read ftics_style write set_tics_style; //  = "v"
    property sub_tics read fsub_tics write set_sub_tics; //  = 2
    property tics_labels read ftics_labels write set_tics_labels; //  = ["2","3","4","5","6","7"]
    property axis_label read flabel write flabel;
    private
    flabel_rgn;
    ftics_recs;
    fzoom_bounds;
    fticksize;
    fsubticksize;
    fxtics_coord_v;
    ftcmin;
    ftcmax;
    ftccount;
    ///////////////////////////////
    ftics_direction; 
    fxtics_coord;
    fytics_coord;
    fsub_tics;
    ftics_color;
    ftics_segment;
    ftics_style;
    ftics_labels;
    flabel;
    //format_n ;//= ""
    //fractional_font ;//= "off"
    //clip_state ;//= "off"
    //clip_box ;//= []
    //user_data ;//= []
    //tag ;//= "" 
    private 
    function v_to_cvs(tpax,v,x,y);
    begin
        case tpax of 
            "x":zoom_to_xyz(v,fytics_coord[1],fytics_coord[2],x,y);
            "y":zoom_to_xyz(fytics_coord[0],v,fytics_coord[2],x,y);
            "z":zoom_to_xyz(fytics_coord[0],fytics_coord[1],v,x,y);
        end;  
    end 
    function get_tic_to(direc,size,arg,_x,_y);
    begin
        pi2 := pi()/2;
        if direc=tgc_direct_desc then 
        begin 
             p_trans(size,0,-arg-pi2,_x,_y);           
        end 
        else 
        begin
            p_trans(size,0,-arg+pi2,_x,_y);  
        end 
        return 1;
    end     
    function get_angleofhoriz(xarg,ifh,sz); //获取角度以及位置
    begin
        xarg := 0;ifh := false;sz:=0;
        tkxys := array();
        get_axis_type(tpax);
        if fzoom_bounds then 
        begin 
            v_to_cvs(tpax,fzoom_bounds[0],x,y);
            tkxys[0] := array(x,y); 
            v_to_cvs(tpax,fzoom_bounds[1],x2,y2); 
            tkxys[1] := array(x2,y2); 
            sz :=  (x2-x)^2+(y2-y)^2; 
            if sz>0 then sz := sqrt(sz);   
        end else 
        begin 
            minv := minvalue(fxtics_coord_v);
            manv := maxvalue(fxtics_coord_v);
            if not(minv<manv) then return false;
            v_to_cvs(tpax,minv,x,y);
            tkxys[0] := array(x,y);
            v_to_cvs(tpax,manv,x,y);
            tkxys[1] := array(x,y);
        end 
        if length(tkxys)<2 then return false;
        dxy := (tkxys[1]-tkxys[0]);
        if (like_0(dxy[0])) and like_0(dxy[1]) then return false; 
        a_180 := pi();
        a_90 := a_180/2;
        a_30 := a_180/6;
        a_60 := a_180/3;
        a_45 := a_180/4;
        a_150 := a_180/6*5;       
        xarg := d2angle(array(5,0),dxy); //和x夹角        
        yarg := d2angle(array(0,5),dxy); //和y夹角
        if isnan(xarg) then 
        begin 
            if dxy[0]>0 then xarg := 0;
            else xarg := a_180;
        end 
        if isnan(yarg) then 
        begin 
            if dxy[1]>0 then yarg := 0;
            else yarg := a_180;
        end
        if xarg<a_30 or  xarg>a_150 then 
        begin 
            ifh := true;
        end 
        if like_0( xarg)  then 
        begin
            ifh := true;
        end else 
        if a_like_b(xarg,a_180) then 
        begin 
            xarg := -xarg;
            ifh := true;
        end else 
        if a_like_b(yarg,a_90) then 
        begin
            xarg := 0;  
            ifh := true;   
        end else 
        if yarg = 0 then 
        begin
            xarg := a_90;
        end else 
        if yarg=a_180 then 
        begin 
            xarg:=-a_90;
        end else 
        if xarg<a_90 and yarg>a_90 then //第1
        begin
            xarg := -xarg;
        end else 
        if xarg>a_90 and yarg>a_90 then //第2
        begin 
            xarg :=-xarg;
        end else 
        if yarg<a_90 and xarg>a_90 then //第3
        begin
        end else 
        if yarg<a_90 and xarg<a_90 then //第4
        begin 
        end 
    end 
    function get_axis_type(tpax);
    begin
        tpax := "x";
        if ifnumber(fytics_coord[1]) and ifnumber(fytics_coord[2]) then tpax := "x";
        else if ifnumber(fytics_coord[2]) and ifnumber(fytics_coord[0]) then tpax := "y";
        else if ifnumber(fytics_coord[0]) and ifnumber(fytics_coord[1]) then tpax := "z";   
        return tpax;
    end 
    function draw_axis(cvs,subtks);
    begin
        pw := lineinfo.width;
        tksize := pw+fticksize;
        tic_space := 3;
        tksizesub := fsubticksize+pw;
        get_axis_type(tpax);     
        set_lineinfo_to_canvas(cvs);
        tkxys := array();
        xarg := 0;
        ifvert := false;
        get_angleofhoriz(xarg,ifvert,sz);
        if like_0(sz) then return ;
        for i,v in fxtics_coord_v do 
        begin 
            v_to_cvs(tpax,v,x,y);
            tkxys[i] := array(x,y);      
        end        
        ///////////////////轴线////////////////////////////////
        
        if ftics_segment=tgc_on then 
        begin 
            if fzoom_bounds then 
            begin 
                v_to_cvs(tpax,fzoom_bounds[0],x1,y1);
                v_to_cvs(tpax,fzoom_bounds[1],x2,y2);
                cvs.moveto(array(x1,y1)); 
                cvs.lineto(array(x2,y2)); 
                x3 := (x1+x2)/2; 
                y3 := (y1+y2)/2; 
                ax_pos := array(x1,y1,x2,y2,x3,y3);           
            end else 
            begin 
                for i,v in tkxys do 
                begin   
                    if i=0 then 
                        cvs.moveto(v);
                    else 
                        cvs.lineto(v);
                end
            end  
        end 
        
        /////////////////////////////////////////////////////
        //////////////////刻度线以及刻度值///////////////////////////////////////
        ts_size := array(fontinfo.size+4,fontinfo.size*2+4);
        tcsinfo := array();
        get_tic_to(ftics_direction,tksize,xarg,_xticlen,_yticklen);   
        if ifnumber(ftics_color) then cvs.pen.color := ftics_color;
        ftics_recs := array();
        for i,vi in   fxtics_coord_v do 
        begin         
            if fzoom_bounds and (vi<fzoom_bounds[0] or vi>fzoom_bounds[1]) then continue;  
            v := tkxys[i];          
            lbi := ftics_labels[i];
            x := v[0];
            y := v[1];
            cvs.moveto(array(x,y));
            
            x1 :=x+_xticlen;
            y1 := y+_yticklen; 
            cvs.lineto(array(x1,y1));             
            //continue;           
            sz := nil;
            if lbi then 
            begin 
                sz := array((length(lbi))*fontinfo.size+4,fontinfo.size*2+4) ;//cvs.GetTextExtent(lbi);
            end 
            if sz then 
            begin                   
                if ifvert then //x
                begin 
                    rec := array(x1-sz[0]/2,0,x1+sz[0]/2,0); 
                    if _yticklen>0 then 
                    begin
                        rec[1] := y1+tic_space;
                        rec[3] := y1+sz[1]+tic_space;                                   
                    end else 
                    begin 
                        rec[1] := y1-sz[1]-tic_space;
                        rec[3] := y1-tic_space;                           
                    end                      
                end else //y 
                begin 
                    ts_size[1] := max(ts_size[1],sz[0]);
                    rec := array(0,y1-sz[1]/2,0,y1+sz[1]/2);
                    if _xticlen>0 then 
                    begin 
                        rec[0] := x1+tic_space;
                        rec[2] := x1+sz[0]+tic_space;    
                    end else 
                    begin
                        rec[0] := x1-sz[0]-tic_space;
                        rec[2] := x1-tic_space;
                    end                 
                end 
                tcsinfo[length(tcsinfo)] := array(lbi,rec,"h");
                ftics_recs[i] := rec;
            end 
        end 
        if tcsinfo then 
        begin
            set_fontinfo_to_canvas(cvs);
            draw_tics(cvs,tcsinfo);
        end 
        /////////////////////////////////////////////////////////////////////////
        ////////////////////子刻度线//////////////////////////////////////////////// 
        get_tic_to(ftics_direction,tksizesub,xarg,_xstic,_ystic);         
        for i,v in subtks do 
        begin 
            v_to_cvs(tpax,v,x,y);       
            cvs.moveto(array(x,y));
            //get_tic_to(ftics_direction,tksizesub,xarg,_x,_y);  
            cvs.lineto(array(_xstic+x,y+_ystic));
        end 
        //if not ax_pos then return ;
        flabel_rgn := array();
        if flabel is class(tg_label_axis) then //绘制标签
        begin             
            //tx := ax_pos[2]-ax_pos[1]
            if flabel.visible<>tgc_on then return ;
            t := flabel.text;
            if not t then return ; 
            if not fzoom_bounds then return ;
            lbft :=  flabel.fontinfo;
            sz := lbft.size;
            set_fontinfo_to_canvas(cvs,lbft);  
            _x := _xticlen;
            _y := _yticklen;
            bs :=2;//xarg<0?1:2;//(xarg<0?2.2:0.2);            
            slen := sz*length(t);
            zlen := max(abs(ax_pos[2]-ax_pos[0]),abs(ax_pos[3]-ax_pos[1]));
            rt := (1-slen/zlen);
            tx := fzoom_bounds[0] + (rt>0? (rt*(fzoom_bounds[1]-fzoom_bounds[0])/2):0);
            v_to_cvs(tpax,tx,x1,y1);
            
            nxarg :=  (r_2_a(xarg) mod 180);//abs()*pi());
            //echo "\r\narg:",r_2_a(xarg),"===",nxarg;
            nxarg := nxarg*pi()/180;
            if _y<0  then _y-=ts_size[0]+tic_space+sz*bs;
            else _y+=ts_size[0]+tic_space+sz*bs;
            if _x<0  then _x -= sz*bs+ts_size[1]+tic_space;
            else _x+=sz*bs+ts_size[1]+tic_space;
            nx := x1+_x;//ax_pos[4]+_x;
            ny := y1+_y;//ax_pos[5]+_y;
            t_rec := array(nx,ny,nx+slen,ny+lbft.size);
            flabel_rgn := rec_to_points(t_rec);
            if like_0(nxarg) then 
            begin 
                cvs.textout(t,array(nx,ny));    
            end else 
            begin
                rgn_points_trans(flabel_rgn,-nxarg);
                cvs.SaveDC();
                cvs.trans(-nxarg,nx,ny);
                cvs.textout(t,array(0,0));
                cvs.RestoreDC();
            end             
        end  
    end 
    function set_zoom_bounds(v);
    begin
        if ifarray(v) and v[0]<v[1] then 
        begin
            fzoom_bounds := array(v[0],v[1]);    
        end else 
        begin
            fzoom_bounds := nil;
        end 
    end 
    function set_tics_direction(v);
    begin
        if v<>ftics_direction and ( v in array(tgc_direct_asc,tgc_direct_desc)) then 
        begin
            ftics_direction := v; 
            prop_changed("tics_direction",v);   
        end 
    end 
    function tc_to_label(v);
    begin
        return format("%f",v);//tostn(v);
    end 
    function set_xtics_coord(v);
    begin
        if v<> fxtics_coord and ifarray(v) then 
        begin
            case ftics_style of 
                tgc_tics_v:
                begin
                    lbs := array();
                    for i,vi in v do 
                    begin 
                        if not ifnumber(vi) then return ; 
                        lbs[i] := tc_to_label(vi);
                    end 
                    ftcmin := minvalue(v);
                    ftcmax := maxvalue(v);
                    if ftcmin=ftcmax then return ;
                    ftccount := length(v)-1;  
                    fxtics_coord := v;
                    fxtics_coord_v := v;  
                    ftics_labels := lbs;     
                end 
                tgc_tics_r:
                begin
                    if not(v[0]<v[1] and v[2]>=1) then return ;
                    fxtics_coord := v;
                    ftcmin := v[0];
                    ftcmax :=v[1];
                    ftccount := v[2];                    
                    type_c_to_r();
                end 
            
            end; 
            fxtics_coord := v;
            prop_changed("xtics_coord",v);   
        end    
    end 
    function ytics_ok(v);
    begin
        if ifarray(v) and length(v)>=3 then 
        begin
            nmc := 0;
            for i := 0 to 2 do 
            begin 
                if ifnumber(v[i]) then nmc++;
            end 
            return nmc=2;
        end     
    end 
    function set_ytics_coord(v);
    begin
        if v<> fytics_coord and ytics_ok(v) then 
        begin            
            fytics_coord := v;
            prop_changed("ytics_coord",v);   
        end    
    end 
    function set_tics_segment(v);
    begin
        if not tg_boolen_value(n,nv) then return ;
        if ftics_segment<>nv then 
        begin 
            ftics_segment := nv;    
            prop_changed("tics_segment",nv);  
        end 
    end 
    function set_tics_color(v);
    begin
        if ftics_color<>v then 
        begin 
            ftics_color := v;    
            prop_changed("tics_color",v);  
        end 
    end 
    function set_tics_style(v);
    begin
        if v<>ftics_style and( v in array(tgc_tics_v,tgc_tics_r)) then 
        begin 
            ftics_style := v;
            case v of 
                tgc_tics_v:
                begin
                    fxtics_coord := array(); 
                    for i,v in fxtics_coord_v do 
                    begin 
                        fxtics_coord[i] := v;
                    end    
                end 
                tgc_tics_r:
                begin
                    fxtics_coord := array();
                    fxtics_coord[0] := ftcmin;
                    fxtics_coord[1] := ftcmax;
                    fxtics_coord[2] := ftccount;
                    type_c_to_r();    
                end        
            end ;
            prop_changed("tics_style",v);  
        end 
    end 
    function type_c_to_r();
    begin        
        fxtics_coord_v := array();
        ftics_labels := array();
        vidx := 0;
        for x := ftcmin to ftcmax step (ftcmax-ftcmin)/ftccount do 
        begin 
            fxtics_coord_v[vidx] := x;
            ftics_labels[vidx] := tc_to_label(x);
            vidx++;
        end 
        if x>=ftcmax then 
        begin 
            fxtics_coord_v[vidx-1] := ftcmax  ;
            ftics_labels[vidx-1] := tc_to_label(ftcmax)  ;        
        end else 
        begin 
            fxtics_coord_v[vidx] := ftcmax  ;
            ftics_labels[vidx] := tc_to_label(ftcmax)  ;
        end 
         
    end 
    function set_sub_tics(v);
    begin
        if v>=0 and v<>fsub_tics then 
        begin 
            fsub_tics := v;
            prop_changed("sub_tics",v);
        end     
    end 
    function set_tics_labels(v);
    begin
        if ifarray(v) and v<>ftics_labels then 
        begin 
            ftics_labels:=v;
            prop_changed("tics_labels",v);    
        end 
    end   
end 

type tg_text = class(tg_base)
    public 
    function create(pms);
    begin
        inherited;
        clip_state := tgc_off;
        ftext := array();
        fdata := array();
        ffont_angle := 0;
    end 
    function paint(cvs);override;
    begin
        if (visible<>tgc_on) then return ;
        if not fdata then return ;
        if not zoom_to_xyz(fdata[0],fdata[1],fdata[2],x,y) then return ;
        if clip_state=tgc_on then cvs.axesclip();
        else cvs.axesunclip();
        get_text_size(w,h,hi);
        set_lineinfo_to_canvas(cvs);   
        FPaintrect := array(x,y,x+w,y+h);           
        Frgnpoints := rec_to_points(FPaintrect)[0:3];   
        if ffont_angle<>0 then 
        begin 
            cvs.SaveDC();            
            cvs.trans(-ffont_angle,x,y); 
            rgn_points_trans(Frgnpoints,-ffont_angle);
            x := 0;
            y := 0;
        end        
        if line_mode then 
        begin 
            rc := array(x,y,x+w,y+h);
            cvs.draw_rect().rect(rc).draw();                      
        end 
        set_fontinfo_to_canvas(cvs);
        for i,v in ftext do 
        begin 
            cvs.textout(v,array(x,y+i*hi));
        end 
        if ffont_angle<>0 then 
            cvs.RestoreDC();
    end 
    function executecommand(cmd,p);override;
    begin
        case cmd of
            "text_rec": return (visible=tgc_on)? FPaintrect:nil;    
            "text_rgn": return (visible=tgc_on)? Frgnpoints:nil;                
        end ;
        return inherited;
    end  
    published
    property text read ftext write set_text;
    property data read fdata write set_data;
    property font_angle read ffont_angle write set_font_angle;
    private
    FPaintrect;
    Frgnpoints;
    ftext;
    fdata;
    ffont_angle;
    private 
    function get_text_size(w,h,hi);
    begin
        fw := fontinfo.size;        
        fh := fw*2;
        hi:=fh+2;
        w := 0;
        h := 0;
        for i,v in ftext do 
        begin 
            si := v;
            w := max(w,length(si)*fw);
            h+=fh;         
        end 
        h+=2;
    end 
    function set_text(v);
    begin
        tx := array();
        for i,vi in v do 
        begin 
            if ifstring(vi) then tx[length(tx)] := vi;
        end 
        if ftext<>tx then 
        begin 
            ftext :=tx;
            prop_changed("text",tx);
        end 
    end 
    function set_data(d);
    begin
        if fdata<>d and ifarray(d) and ifnumber(d[0]) and ifnumber(d[1]) then 
        begin 
            fdata := d;
            prop_changed("data",d);
        end 
    end 
    function set_font_angle(arg);
    begin
        if arg<>ffont_angle then 
        begin 
            ffont_angle := arg;
            prop_changed("font_angle",arg);
        end 
    end 

end 
type tg_label =class(tg_base) //标签对象
    function create(pms);
    begin
        inherited; 
        clip_state := tgc_off;
        ftext := false; 
        flocation := tgc_by_coordinates;
        fposition := array(0,0); 
        ffill_mode := false;
        ffont_angle := 0;
        fauto_rotation := false;
    end
    function paint(cvs);override;
    begin
        if tgc_on<>visible then return ;
        if not ftext then return ;
        if clip_state=tgc_on then cvs.axesclip();
        else cvs.axesunclip();
        set_fontinfo_to_canvas(cvs);
        p := fposition;
        
        if fauto_position=tgc_on then 
        begin 
            p :=  fauto_position_value;          
        end else 
        begin
            p := fposition;
        end 
        case flocation of 
            tgc_by_axes:
            begin
                if not axes_mapping(p[0],p[1],0,x_,y_) then return ;
            end else //tgc_by_coordinates:
            begin
                if not zoom_to_xyz(p[0],p[1],0,x_,y_) then return ;
            end        
        end
        txtw  := length(ftext)*fontinfo.size; 
        rec := array(x_,y_,x_+txtw,y_+fontinfo.size);
        flabel_rgn := rec_to_points(rec)[0:3];            
        if ffont_angle<>0 then 
        begin 
            rgn_points_trans(flabel_rgn,-ffont_angle);        
            cvs.SaveDC();
            cvs.trans(-ffont_angle,x_,y_);
            cvs.textout(ftext,array(0,0));
            cvs.RestoreDC();
        end else 
            cvs.textout(ftext,array(x_,y_));
    end
    function executecommand(cmd,p);override;
    begin
        case cmd of
            "auto_position_value":
            begin
                fauto_position_value := p;
                return ;
            end 
            "label_rgn": 
            begin
                return (visible=tgc_on)?flabel_rgn:nil; 
            end            
        end;
        return inherited;
    end  
    protected
    function check_parent(p);override;
    begin
        return (not p) or (p is class(tg_axis));
    end 
    published
    property text read ftext write set_text;//= ""
    property position read fposition write set_positon;//[-27.697388,-1.7130177]
    property location read flocation write Set_location;
    property auto_position read fauto_position write set_auto_position;//"on"
    //property auto_position_value read fauto_position_value write fauto_position_value;//"on"
    property auto_rotation read fauto_rotation write set_auto_rotation;//"on"
    property font_angle read ffont_angle write set_font_angle;//90
    //font_foreground ;//= 6
    //foreground ;//= 9
    //background ;//= 23
    //fill_mode ;//= "off"
    //font_style ;//= 6
    //font_size ;//= 4
    //fractional_font ;//= "off"
    //font_angle ;//= 90
    private 
    flabel_rgn;    
    flocation;
    ftext;
    fposition;
    fauto_position_value;
    ffont_angle;
    fauto_position;
    fauto_rotation;
    private
    function Set_location(v);
    begin
        if flocation<>v and (v in array(tgc_by_axes,tgc_by_coordinates)) then 
        begin
            flocation := v;    
        end 
    end  
    function set_auto_position(v);
    begin
        if not tg_boolen_value(v,nv) then return ;
        if nv<>fauto_position then 
        begin 
            fauto_position := nv;
            prop_changed("auto_postion",nil);
        end 
    end 
    function set_font_angle(v);
    begin
        if v<>ffont_angle and ifnumber(v) then 
        begin 
            ffont_angle := v;
            prop_changed("font_angle",v);
        end 
    end 
    function set_text(v);
    begin
        if ifstring(v) and v<>ftext then 
        begin 
            ftext := v;
            prop_changed("text",nil);
        end 
    end 
    function set_positon(v);
    begin
        if ifarray(v) and ifnumber(v[0]) and ifnumber(v[1]) and v[0]<>fposition[0] and v[1]<>fposition[1] then 
        begin 
            fposition[0] :=v[0];
            fposition[1] :=v[1];
            fauto_position := tgc_off;
            prop_changed("postion",v);
        end 
    end 
    function set_auto_rotation(v);
    begin
        if not tg_boolen_value(v,nv) then return ;
        if fauto_rotation<>nv then 
        begin 
            fauto_rotation := nv;
            prop_changed("auto_rotation",nv);    
        end 
    end 
end 
type tg_compound = class(tg_graph) //组合对象
    function create(pms);
    begin
        inherited;
    end     
    protected
    function check_parent(p);override;
    begin
        return  (not(p)) or (p is class(tg_compound)) or (p is class(tg_axes));
    end 
end 
type tg_tips = class(tg_base) //提示
    function create(pms);
    begin
        inherited; 
        flocation := tgc_by_coordinates;
        fdisplay_components := "xy";
        fbox_mode := tgc_on; 
        mark_mode := tgc_on;  
        markinfo.Style := tgc_mks_square;
        markinfo.size := 5;
        fline_style := 0;
        fforeground := -1;  
        fbackground := -2;         
        fmark_style := 11;
        fdata_idx := -1;
        frow_mode := false;
    end
    function executecommand(cmd,pm);override;
    begin
        case cmd of
            "fresh":
            begin
                FData := nil;
                ftext :="";
                f_ps := nil; 
                prop_changed("fdata_idx",pm);
            end 
            "tips_rec": return (visible=tgc_on)?FPaintrect:nil;        
        end 
    end 
    function paint(cvs);override;
    begin
        FPaintrect := array(); 
        if tgc_on<>visible then return ;
        p := parent;
        if not p then return ;
        d := get_data();
        if ifnil(d) then return ;        
        ss := get_text();        
        if not ss then return ;
        if not(f_ps and ifnumber(f_ps[0]) and ifnumber(f_ps[1])) then return ;
        if clip_state=tgc_on then cvs.axesclip();
        else cvs.axesunclip();
        ws := 0;
        hs := array();
        w := fontinfo.size;
        h := w*2;
        for i,v in ss do 
        begin
            ws := max(ws,length(v)*w+w);        
            hs[i] := h+4;        
        end 
        zoom_to_xyz(d[0],d[1],z,x_,y_);        
        sz := array(ws,sum(hs));
        if mark_mode = tgc_on then 
        begin 
            mk := markinfo;
            msz := max(ceil(mk.size/2),2);
            paint_marks(mk,cvs,array((x_,y_)));
        end         
        case flocation of 
            tgc_in_upper_left: lc := 0;
            tgc_in_upper_right: lc := 1;
            tgc_in_lower_right: lc := 2;
            tgc_in_lower_left: lc := 3;
            else 
                lc := (fdata_idx+1) mod 3;//randomfrom(array(0,1,2,3));    
        end ;
        rec := get_rect_at_corner(x_,y_,sz[0],sz[1],msz,lc);
        FPaintrect := rec;
        if fbox_mode=tgc_on then 
        begin 
            set_lineinfo_to_canvas(cvs);
            cvs.draw_rect.rect(rec).draw(); 
        end  
        b_x := rec[0];
        b_y := rec[1];  
        
        set_fontinfo_to_canvas(cvs);  
                  
        for i,v in ss do 
        begin 
            rci := array(b_x,b_y,b_x+ws,b_y+hs[i]);          
            cvs.drawtext(v,rci);
            b_y+=hs[i];
        end 
    end 
    published
    //property interp_mode read finterp_mode write finterp_mode; //"on"
    property location read flocation write set_location;
    property box_mode read fbox_mode write set_box_mode; //"on"
    property display_components read fdisplay_components write set_display_components; //"xy"
    property data_idx read fdata_idx write set_data_idx;
    property display_function read fdisplay_function write fdisplay_function;
    property text read get_text write set_text;
    property data read get_data;
    private 
    [weakref]fdisplay_function;
    flocation;
    fbox_mode;
    //finterp_mode;
    fdisplay_components;
    fdata_idx;
    ftext;
    fdata;
    FPaintrect;
    //auto_orientation ;//= "on"
    //orientation ;//= 3
    //label_mode ;//= "on"
    //data ;//= [66.064054,-1.3511706,0]
    //display_components ;//= "xy"
    //display_function ;//= ""
    //text ;//= ["X:66.064";"Y:-1.351"]
    //detached_position ;//= []
    protected
    function check_parent(p);override;
    begin
        return ifnil(p) or (p is class(tg_graph));
    end 
    private 
    f_ps;
    function init_display(tip,ps,txts);
    begin
        d := get_data();
        if ifarray(d) and ifnumber(d[0]) and ifnumber(d[1]) then 
        begin
            px := d[0];
            py := d[1];
            ps := array(px,py);
            txts := array();
            for i := 1 to length(fdisplay_components) do 
            begin
                vi := fdisplay_components[i];
                case vi of 
                    "x","X":
                    begin
                        txts[length(txts)] := vi+format(":%f",px);
                    end 
                    "y","Y":
                    begin
                        txts[length(txts)] := vi+format(":%f",py);
                    end 
                end  ;   
            end 
        end     
    end 
    function set_text(txt);
    begin
        if get_text()<>txt and ifarray(txt) then 
        begin
            ftext := array();
            for i,v in txt do 
            begin
                if ifstring(v) then 
                begin
                    ftext[idx++] := v;
                end 
            end    
        end 
    end 
    function get_text();
    begin
        if ftext then return ftext;
        if iffuncptr(display_function) then 
        begin
            call(display_function,self(true),ps,txt);
            f_ps := ps;
        end else 
        begin
            init_display(self(true),ps,txt);
            f_ps := ps;
        end 
        ftext := txt;
        return ftext;             
    end 
    function get_data();
    begin
        if fdata then return FData;
        if not(fdata_idx>=0) then return nil; 
        p := parent;
        if p then 
        begin
            FData :=  p.get_graph_data_by_idx(fdata_idx); 
            return fdata;
        end 
        return nil;   
    end  
    function set_data_idx(idx);
    begin
        if ifnumber(idx) and idx<>fdata_idx then
        begin
            fdata_idx := idx ;
            executecommand("fresh",pm);
            
        end  
    end 
    function set_location(v);
    begin
        if v<>flocation then 
        begin
            flocation := v;
            prop_changed("location",nv);
        end 
    end 
    function set_display_components(v);
    begin
        if not( v and ifstring(v)) then return ;
        if d_comp_ok(v) and fdisplay_components<>v then 
        begin
            fdisplay_components := v; 
            executecommand("fresh",pm);   
        end 
    end 
    function set_box_mode(v);
    begin
        if not tg_boolen_value(v,nv) then return ;
        if nv<>fbox_mode then 
        begin
            fbox_mode := nv;
            prop_changed("box_mode",nv);
        end 
    end  
    function d_comp_ok(dcp);
    begin
        t := array("x":1,"y":1,"z":1);
        for i := 1 to length(dcp) do 
        begin 
            vi := dcp[i];
            if t[vi]<>1 then return false;
            t[vi] := 2;
        end 
        return true;
    end       
end 
type tg_legend = class(tg_base) //图例
    function create(pms);
    begin
        inherited;  
        clip_state := tgc_off;
        flocation := tgc_in_upper_right;
        flinks := array(); 
        FText := array();
        fposition := nil;
    end
    function paint(cvs);override;
    begin
        if tgc_on<>visible then return ;
        if clip_state=tgc_on then cvs.axesclip();
        else cvs.axesunclip();
        get_lenged_sizes(lw,lh,ws,hs,objs,ss);
        arec := cvs.axesrec;
        rc := arec;
        dis := 30;
        cvs.axesunclip();
        set_lineinfo_to_canvas(cvs);
        case flocation of
            tgc_upper_caption:
            begin
                x := arec[0];
                y := arec[1];
                mx := ceil((arec[2]-arec[0]-lw)/2)-dis;
                rc := get_rect_at_corner(x,y,lw,lh,dis,2,mx);
                cvs.draw_rect().rect(rc).draw();
            end 
            tgc_lower_caption:
            begin
                x := arec[0];
                y := arec[3];
                mx := ceil((arec[2]-arec[0]-lw)/2)-dis;
                rc := get_rect_at_corner(x,y,lw,lh,dis,1,mx);
                cvs.draw_rect().rect(rc).draw();
            end 
            tgc_in_upper_right:
            begin
                x := arec[2];
                y := arec[1];
                rc := get_rect_at_corner(x,y,lw,lh,dis,3);
                cvs.draw_rect().rect(rc).draw();
            end 
            tgc_in_upper_left:
            begin
                x := arec[0];
                y := arec[1];
                rc := get_rect_at_corner(x,y,lw,lh,dis,2);
                cvs.draw_rect().rect(rc).draw();
            end 
            tgc_in_lower_left:
            begin
                x := arec[0];
                y := arec[3];
                rc := get_rect_at_corner(x,y,lw,lh,dis,1);
                cvs.draw_rect().rect(rc).draw();
            end 
            
            tgc_in_lower_right:
            begin
                x := arec[2];
                y := arec[3];
                rc := get_rect_at_corner(x,y,lw,lh,dis,0);
                cvs.draw_rect().rect(rc).draw();
            end
            tgc_by_coordinates: //根据位置信息设置处理
            begin
                if ifnil(fposition) then 
                begin 
                    x := arec[2];
                    y := arec[1];
                    rc := get_rect_at_corner(x,y,lw,lh,0,3);  
                    xyz_to_zoom(rc[0],rc[1],0,_x,_y,_z);
                    fposition := array(_x,_y);
                end else 
                begin 
                    zoom_to_xyz(fposition[0],fposition[1],0,_x,_y); 
                    rc:= array(_x,_y,_x+lw,_y+lh);
                end                                
                cvs.draw_rect().rect(rc).draw();
            end 
            tgc_by_axes:
            begin
                if ifnil(fposition) then 
                begin 
                    x := arec[2];
                    y := arec[1];
                    rc := get_rect_at_corner(x,y,lw,lh,0,3);  
                    axes_unmapping(rc[0],rc[1],_x,_y,_z);
                    fposition := array(_x,_y);
                end else 
                begin 
                    axes_mapping(fposition[0],fposition[1],0,_x,_y); 
                    rc:= array(_x,_y,_x+lw,_y+lh);
                end                                
                cvs.draw_rect().rect(rc).draw();
            end             
        end;
        b_x := rc[0];
        b_y := rc[1];  
        flegend_rec := rc;
        set_fontinfo_to_canvas(cvs);  
        flegend_sub_recs := array();   
        for i,v in objs do 
        begin
            hi := hs[i];
            if v then 
            begin 
                rci := array(b_x,b_y,b_x+ws[0],b_y+hi);
                v.paint_legend(cvs,rci); 
            end 
            flegend_sub_recs[i] := rci;
            si := ss[i];
            if si then 
            begin 
                rci := array(b_x+ws[0],b_y,b_x+ws[0]+ws[1],b_y+hi);
                cvs.drawtext(si,rci);
            end             
            b_y+=hi;   
        end 
        cvs.axesclip();
    end 
    function executecommand(cmd,p);override;
    begin
        case cmd of
            "legend_rec":return  (visible=tgc_on)? flegend_rec:nil;
            "legend_sub_recs":return  (visible=tgc_on)? flegend_sub_recs:nil;
        end 
        return inherited;
    end 
    published 
    property location read flocation write set_location;
    property postion read fposition write set_postion;
    property links read flinks write set_links; 
    property text read FText write set_text;
    protected
    function check_parent(p);override;
    begin
        return ifnil(p) or (p is class(tg_axes));
    end 
    private 
    [weakref] flinks;
    flocation;
    FText;
    fposition;
    flegend_rec;
    flegend_sub_recs;
    //text ;//= "y1"
    //font_style ;//= 6
    //font_size ;//= 1
    //font_color ;//= -1
    //fractional_font ;//= "off"
    //links ;//= "Polyline" [] 数组
    //legend_location ;//= "in_upper_right"
    //position ;//= [0.7379099,0.1325]
    //line_width ;//= 0.1
    //line_mode ;//= "on"
    //thickness ;//= 1
    //foreground ;//= -1
    //fill_mode ;//= "on"
    //background ;//= -2
    //marks_count ;//= 3
    //clip_state ;//= "off"
    //clip_box ;//= []
    private 
    function get_lenged_sizes(lw,lh,ws,hs,objs,ss);
    begin
        ws := array(0,0);
        hs := array();
        w := fontinfo.size;
        h := w*2;
        objs := array();
        ss := array();
        for i:= 0 to max(length(flinks),length(ftext))-1 do 
        begin 
            vi := flinks[i];
            si := ftext[i];
            if vi is class(tg_graph)  then 
            begin 
                objs[i] := vi;
                vi.get_legend_size(w1,h1);
                ws[0] := max(ws[0],w1);
            end else 
            begin
                h1 := 0; 
                objs[i] := 0;   
            end 
            if ifstring(si) then 
            begin 
                ws[1] := max(w*length(si)+2,ws[1]);  
                ss[i] := si;     
            end else 
            begin
                ss[i] := nil;
            end 
            hs[i] := max(h+4,h1);        
        end 
        lw := ws[0]+ws[1];
        lh := sum(hs);   
    end 
    function set_postion(v);
    begin
        if fposition<>v and ifarray(v) and ifnumber(v[0]) and ifnumber(v[1]) then 
        begin 
            fposition := array(v[0],v[1]);
            prop_changed("postion",v);
        end 
    end 
    function set_text(s);
    begin
        idx := 0;
        flg := false;
        for i,v in s do 
        begin
            if not ifstring(v) then continue;            
            if v<>ftext[idx] then 
            begin
                ftext[idx] := v;                 
                flg++;  
            end 
            idx++; 
        end 
        if flg then prop_changed("text",s);    
    end 
    function set_links(vs);
    begin
        if ifarray(vs) and vs<>flinks then 
        begin 
            flinks := vs;
            prop_changed("links_changed",vs);
        end 
    end 
    function set_location(v);
    begin
        vs := static array(tgc_in_upper_right:true,tgc_in_upper_left:true,tgc_in_lower_right:true,tgc_in_lower_left:true,
                            //tgc_out_upper_right,tgc_out_upper_left,tgc_out_lower_right,tgc_out_lower_left,
                            tgc_upper_caption:true,tgc_lower_caption:true,
                            tgc_by_coordinates:true,tgc_by_axes:true);
        if v<>flocation and (vs[v]) then 
        begin 
            flocation := v;
        end 
    end 
end 
type tg_graph_base = class(tg_base) //兼容绘图和goup两个类型
    function create(pm);
    begin
        inherited;
    end 
    function get_data_bounds();virtual; //获取数据边界
    begin
        return get_node_data_bounds(self(true));
    end 
end 
type tg_graph = class(tg_graph_base) //绘图对象,包括数据,提示等内容
    function create(pms);
    begin
        inherited;
        fgraph_data := array();
    end 
    function get_data_tips(); //获得数据提示对象
    begin
        r := array();
        for i:= 0 to NodeCount-1 do 
        begin
            vi := GetNodeByIndex(i);
            if vi is class(tg_tips) then 
            begin 
                r[ridx++] := vi;
            end 
        end 
        return r;
    end 
    function get_legend_size(w,h);virtual;
    begin
        h := fontinfo.size+4;
        w := 100;
    end 
    function paint_legend(cvs,rec);virtual; //绘制图例
    begin
        
    end 
    function get_graph_data_by_idx(idx); //获取数据点
    begin
        return fgraph_data[idx];    
    end  
    property graph_data read fgraph_data write set_graph_data; 
    protected
    fgraph_data;//数据
    protected
    function prop_changed(n,v);override;
    begin
        case n of 
            "data":
            begin
                for i,v in get_data_tips() do 
                begin 
                    v.executecommand("fresh",nil);
                end 
                ax := axes;
                if ax then 
                    ax.executecommand(cmd_data_changed);
            end  else 
            begin
                inherited;
            end            
        end ;
    end 
    function set_graph_data(v);virtual;
    begin
        if v<>fgraph_data then 
        begin
            fgraph_data := v;
            prop_changed("data",v);
        end 
    end     
end 
type tg_Polyline = class(tg_graph) //线图对象
    function create(pms);
    begin
        inherited;
        clip_state := tgc_on;
        fclosed := tgc_off;
        line_mode := tgc_on;
        mark_mode := tgc_off;
        fpolyline_style := tgc_LS_interpolated;// interpolated,staircase,barplot,arrowed,filled,bar
        fbar_width := 0;
        fdata_bounds := array((0,1),(0,1),(0,1));
    end     
    function get_data_bounds();override;
    begin
        return fdata_bounds;
    end 
    function paint(cvs);override;
    begin
        if tgc_on<> visible then return ;
        if clip_state=tgc_on then
        begin
            //cvs.axesclip();
            bx := axes.zoom_box;
            pts := array();
            for i,v in rec_to_points( array(bx[0,0],bx[1,0],bx[0,1],bx[1,1])) do 
            begin 
                zoom_to_xyz(v[0],v[1],bx[2,0],x,y);  
                pts[i] := array(x,y);  
            end 
            cvs.clip_rgn(pts);
        end else 
        begin        
            cvs.axesunclip();
        end         
        //echo tostn(bx);
        xys := array(); 
        set_lineinfo_to_canvas(cvs);
        ys := array();
        for i,v in fgraph_data do 
        begin
            if not zoom_to_xyz(v[0],v[1],bx[2,0],x,y) then return ;
            xys[i] := array(integer(x),integer(y)); 
            case  fpolyline_style of 
                tgc_LS_bar,tgc_LS_barplot,tgc_LS_filled:
                begin
                    zoom_to_xyz(v[0],0,0,x,y) ;
                    ys[i] := array(x,y);    
                end             
            end;       
        end 
        fline_points_in_canvas := xys;
        //zoom_to_xyz(0,0,0,x,y);
        paint_lines(cvs,fpolyline_style,xys,fclosed,array("line_mode":line_mode,"bar_width":fbar_width,"color":lineinfo.color,"bkcolor":lineinfo.bkcolor,"xy0":ys));
        mk := markinfo.clone();
        if mark_mode=tgc_on and mk.size>2 then 
        begin 
            paint_marks(mk,cvs,xys);                    
        end 
        inherited;
    end
    function executecommand(cmd,p);override;
    begin
        case cmd of
            "points_in_canvas":return (visible=tgc_on)? fline_points_in_canvas:nil;
        end;
        return inherited;
    end 
    function get_legend_size(w,h);virtual;
    begin
        mk := markinfo;
        h := fontinfo.size+4;
        w := 100;
        if mark_mode=tgc_on then 
        begin
            h := max(10,mk.size+4);
            w := 5*h;
        end         
    end  
    function paint_legend(cvs,rec);override; //绘制图例
    begin
        y0 := ceil(rec[1]+(rec[3]-rec[1])/2);
        dis := ceil((rec[2]-rec[0])/5);
        xys := array((rec[0]+dis,y0),(rec[0]+4*dis,y0));
        set_lineinfo_to_canvas(cvs);
        paint_lines(cvs,tgc_LS_interpolated,xys,0,array("line_mode":line_mode,"bar_width":fbar_width,"color":lineinfo.color,"bkcolor":lineinfo.bkcolor));
        mk := markinfo.clone();
        if mark_mode=tgc_on and mk.size>2 then 
        begin 
            xys := array((rec[0]+dis*2,y0),(rec[0]+3*dis,y0));
            paint_marks(mk,cvs,xys);                    
        end 
    end        
    property closed read fclosed write set_line_closed;//= "off"
    property polyline_style read fpolyline_style write set_polyline_style;//= "0"
    property bar_width read fbar_width write fbar_width;//= "0"    
    private 
    fline_points_in_canvas;
    fdata_bounds;
    fclosed;
    fforeground;
    fbackground;
    fpolyline_style; 
    fbar_width; 
    //datatips;//: ["Datatip";"Datatip"]
    //datatip_display_mode;//: "always"
    //display_function ;//= ""
    //display_function_data ;//= []
    //fill_mode ;//= "off"
    //thickness ;//= 4
    //arrow_size_factor ;//= 1    
    //interp_color_vector ;//= []
    //interp_color_mode ;//= "off"
    //colors ;//= []    
    //mark_offset ;//= 0
    //mark_stride ;//= 1
    //x_shift ;//= []
    //y_shift ;//= []
    //z_shift ;//= []
    //bar_width ;//= 0
    //clip_state ;//= "clipgrf"
    //clip_box ;//= []
    protected
    function set_graph_data(d);override; //设置数据
    begin
        if d<>fgraph_data then 
        begin 
            fx := d[:,0];
            fy := d[:,1];
            fdata_bounds[0,0] := minvalue(fx);
            fdata_bounds[1,0] := minvalue(fy);
            fdata_bounds[0,1] := maxvalue(fx);
            fdata_bounds[1,1] := maxvalue(fy);
            inherited;
        end 
    end 
    private 
    function set_line_closed(v);
    begin
        if not tg_boolen_value(v,nv) then return ;
        if nv<>fclosed then 
        begin
            fclosed := nv;
            prop_changed("closed",nv);
        end 
    end  
    function set_polyline_style(v);
    begin
        if v<>fpolyline_style then 
        begin 
            fpolyline_style := v;
        end 
    end 
end  
type tg_line_info = class(tg_const)
    function create();
    begin
        fcolor := 0;
        FWidth := 1;
        FStyle := tgc_PS_SOLID;
        fbkcolor := nil;
    end 
    function clone();
    begin
        r := new tg_line_info();
        r.style := fstyle;
        r.width := FWidth;
        r.size := FWidth;
        r.color := fcolor;
        r.bkcolor := fbkcolor;
        return r;
    end
    property Style read FStyle write FStyle;
    property width read FWidth write fwidth;
    property size read FWidth write fwidth;
    property color read fcolor write fcolor;    
    property bkcolor read fbkcolor write fbkcolor;
    private 
    fwidth;
    fcolor;
    FStyle;
    fbkcolor;
end 
type tg_font_info = class(tg_const) //字体信息
    function create();
    begin
        fstyle :=  nil;
        fsize := 7; 
        fforeground := 0; 
        fbackground := nil; 
    end 
    function clone();
    begin
        r := new tg_font_info();
        r.style := fstyle;
        r.size := fsize;
        r.color := fforeground;
        r.bkcolor := fbackground;
        return r;
    end 
    property style read fstyle write fstyle;
    property size read fsize write fsize;
    property color read fforeground write fforeground;
    property bkcolor read fbackground write fbackground;
    private 
    fstyle;
    fsize;
    fsize_unit;
    fforeground;
    fbackground;    
end
type tg_mark_info = class(tg_const) //标记信息
    function create();
    begin
        fstyle :=  tgc_mks_dot;
        fsize := 0; 
        fsize_unit := tgc_mk_point;
        fforeground := 0; 
        fbackground := 0xffffff; 
    end 
    function clone();
    begin
        r := new tg_mark_info();
        r.Style := fstyle;
        r.size := fsize;
        r.size_unit := fsize_unit;
        r.color := fforeground;
        r.bkcolor := fbackground;
        return r;
    end 
    property style read fstyle write fstyle;
    property size read fsize write fsize;
    property size_unit read fsize_unit write fsize_unit;
    property color read fforeground write fforeground;
    property bkcolor read fbackground write fbackground;
    private 
    fstyle;
    fsize;
    fsize_unit;
    fforeground;
    fbackground;    
end 
type tg_evet_conainter = class(tg_const)
    function create();
    begin 
        fCapturelist := new tevent_list();
        fbubblelist := new tevent_list();
    end 
    function addEventListener(evtype,fn,ifCapture);virtual;
    begin
        if ifCapture then return fCapturelist.add(evtype,fn);
        return fbubblelist.add(evtype,fn);
    end 
    function removeEventListener(evtype,fn,ifCapture);
    begin
        if ifCapture then return fCapturelist.remove(evtype,fn);
        return fbubblelist.remove(evtype,fn);
    end         
    function dealevent(evt,ifCapture);
    begin
        if  ifCapture then return fCapturelist.dispatch(evt);  
        return  fbubblelist.dispatch(evt);
    end 
    private 
    fCapturelist;
    fbubblelist;     
end 
type tg_base = class(TNode,tg_evet_conainter) //基类，提供层次关系结构
    public 
    function create(pms);
    begin
        class(TNode).create(); 
        class(tg_evet_conainter).create();       
        fchange_locked := false;
        fclip_state := tgc_on;
        fvisibe := tgc_on;
        fline_mode := tgc_off;
        fmark_mode := tgc_off;
        flineinfo := new tg_line_info();
        fmarkinfo := new tg_mark_info();
        ffontinfo := new tg_font_info();
    end 
    function axes_mapping(x,y,z,_x,_y);virtual;
    begin
        p := get_axes();
        if p then return p.axes_mapping(x,y,z,_x,_y);
        return false;
    end 
    function axes_unmapping(x,y,z,_x,_y);virtual;
    begin
        p := get_axes();
        if p then return p.axes_unmapping(x,y,z,_x,_y);
        return false;
    end 
    function zoom_to_xyz(x,y,z,_x,_y,_z);virtual;
    begin
        p := get_axes();
        if p then return p.zoom_to_xyz(x,y,z,_x,_y,_z);
        return false;
    end 
    function xyz_to_zoom(x,y,z,x_,y_,z_);virtual;
    begin
        p := get_axes();
        if p then return p.xyz_to_zoom(x,y,z,x_,y_,z_);
        return false;
    end 
    function executecommand(cmd,pm);virtual;
    begin
    
    end 
    function paint(cvs);virtual;  //绘制
    begin
        if tgc_on<> visible then return ;
        for i := 0 to NodeCount-1 do 
        begin
            vi := GetNodeByIndex(i);
            vi.paint(cvs);
        end 
    end 
    function hit_at(info):bool;
    begin
        if fonhit_at then return call(fonhit_at,self(true),info) ;
        return false;    
    end  
    function set_lineinfo_to_canvas(cvs,info);
    begin
        if info is class(tg_line_info) then li := info;
        else 
            li := lineinfo;
        cl := li.color;
        cvs.pen.style := li.style;
        if ifnumber(cl) then 
        begin 
            cvs.pen.color := cl;    
        end else 
        begin
            cvs.pen.Style := tgc_BS_NULL;
        end 
        cvs.pen.width := li.width;
        bcl := li.bkcolor;
        if ifnumber(bcl) then 
        begin 
            cvs.brush.color := li.bkcolor;
            cvs.brush.Style := tgc_BS_SOLID;
        end 
        else 
        begin
            cvs.brush.Style := tgc_BS_NULL;
        end 
    end  
    function set_fontinfo_to_canvas(cvs,info);
    begin
        if info is class(tg_font_info) then fi := info;
        else 
            fi := fontinfo;
        cvs.font.color := fi.color;
        cvs.font.bkcolor := fi.bkcolor;
        cvs.font.width := fi.size;
        cvs.font.height := fi.size*2;
    end 
    function dispatchEvent(evt); //分发
    begin
        if not(evt is class(tg_evt)) then return 1;
        tg := self(true);
        p := tg;
        while p do 
        begin 
            if p is class(tg_axes) then 
            begin
                p := p.figure;
                break;
            end  
            p := p.parent;   
        end 
        if not p then return 0; 
        return p.dispatchEvent(evt,tg);              
    end     
    published
    property line_mode read fline_mode write set_line_mode; 
    property mark_mode read fmark_mode write set_mark_mode;
    property clip_state read fclip_state write set_clip_state;
    property axes read get_axes write set_axes;
    property visible read fvisibe write setvisible;
    property lineinfo  read flineinfo;
    property markinfo  read fmarkinfo;
    property fontinfo  read ffontinfo;
    property change_locked read fchange_locked write fchange_locked;
    property onhit_at read fonhit_at write fonhit_at;     
    public 
    user_data;
    tag;
    protected
    function get_axes();virtual;
    begin
        p := parent;
        if p then return p.axes;
    end 
    function set_axes(axs);virtual;
    begin    
    end
    function check_parent(p);virtual; //父节点检查
    begin
        return true;
    end 
    function prop_changed(n,v);virtual; //改变通知
    begin
        if fchange_locked then return ;
        axs := get_axes();
        if axs then 
        begin
            if axs.change_locked then return ;
            fg := axs.figure;
        end 
        if fg then 
        begin
            fg.executecommand("figure_need_fresh",p);
        end           
    end 
    function SetParent(V);virtual;
    begin
        if not check_parent(v) then return ;
        if v then ct := v.NodeCount;
        r :=  inherited;
        if v then ct2 := v.NodeCount;
        if ct2>ct then 
        begin 
            ax := axes;
            if ax then ax.executecommand(cmd_node_add_in,self(true));
        end     
        return r;
    end 
    private
    [weakref]fonhit_at;
    fclip_state;
    fline_mode;
    fmark_mode;
    fvisibe; 
    flineinfo; 
    fmarkinfo; 
    ffontinfo;
    fchange_locked;
    function set_clip_state(v);
    begin
        if tg_boolen_value(v,nv) and (nv<>fclip_state) then 
        begin
            fclip_state := nv;
            prop_changed("clip_state",nv);    
        end 
    end   
    function set_line_mode(v);
    begin
        if tg_boolen_value(v,nv) and (nv<>fline_mode) then 
        begin
            fline_mode := nv;
            prop_changed("line_mode",nv);    
        end 
    end  
    function set_mark_mode(v);
    begin
        if tg_boolen_value(v,nv) and nv<>fmark_mode then 
        begin
            fmark_mode := nv;
            prop_changed("mark_mode",nv);  
        end 
    end   
    function setvisible(v);//设置可见
    begin
        if tg_boolen_value(v,nv)  and (nv<>fvisibe) then 
        begin 
            fvisibe := nv;
            prop_changed("visible",fvisibe);
        end     
    end 
end 
type tg_const = class()
    ////////////基础///////////////////
    static const tgc_off = "off";
    static const tgc_on = "on";
    static const tgc_box_off = "off";
    static const tgc_box_on = "on";
    static const tgc_box_half = "half";
    /////////////坐标轴///////////////////
    static const tgc_direct_asc = "asc";
    static const tgc_direct_desc = "desc";
    
    static const tgc_top = "top";
    static const tgc_bottom = "bottom";
    static const tgc_left = "left";
    static const tgc_right = "right";
    static const tgc_middle = "middle";
    static const tgc_origin = "origin";    
    static const tgc_box_hidden_axes = "hidden_axes";
    static const tgc_tics_v = "v";
    static const tgc_tics_r = "r";
    static const tgc_tics_i = "i";    
    //////标记类型//////////////////////
    static const tgc_mks_dot = "dot"; //原点
    static const tgc_mks_plus = "plus"; //加号
    static const tgc_mks_star = "star"; //圈叉
    static const tgc_mks_diamond = "diamond"; //正方形
    static const tgc_mks_diamond_plus = "diamond_plus"; //正方形
    static const tgc_mks_square = "square"; //正方形
    static const tgc_mks_circle = "circle";//圆圈
    static const tgc_mks_pentagram = "pentagram";//五角
    static const tgc_mks_asterisk = "asterisk";//米字
    static const tgc_mks_cross = "cross";//叉
    static const tgc_mks_triangle_up = "triangle_up";
    static const tgc_mks_triangle_down = "triangle_down";
    static const tgc_mks_triangle_left = "triangle_left";
    static const tgc_mks_triangle_right = "triangle_right";    
    static const tgc_mk_tabulated = "tabulated";
    static const tgc_mk_point = "point";
    /////////////////数据提示类型////////////////////////////////////
    static const tgc_DT_always = "always";
    static const tgc_DT_mouseclick = "mouseclick";
    static const tgc_DT_mouseover = "mouseover";  
    ////////////画笔画刷类型/////////////////////////////////
    static const tgc_PS_SOLID=0x0;
    static const tgc_PS_DASH=0x1;
    static const tgc_PS_DOT=0x2;
    static const tgc_PS_DASHDOT=0x3;
    static const tgc_PS_DASHDOTDOT=0x4;
    static const tgc_PS_NULL=0x5  ;
    static const tgc_BS_NULL=1;
    static const tgc_BS_SOLID=0;
    
    ///////////////////线型///////////////////////////////
    static const tgc_LS_interpolated="interpolated";
    static const tgc_LS_staircase="staircase";
    static const tgc_LS_arrowed="arrowed";
    static const tgc_LS_barplot="barplot";
    static const tgc_LS_filled="filled";
    static const tgc_LS_bar="bar";
    
    /////////////////相对位置////////////////////////////
    static const tgc_in_upper_right = "in_upper_right";
    static const tgc_in_upper_left = "in_upper_left";
    static const tgc_in_lower_right = "in_lower_right";
    static const tgc_in_lower_left = "in_lower_left";    
    static const tgc_upper_caption = "upper_caption";
    static const tgc_lower_caption = "lower_caption";
    static const tgc_by_coordinates = "by_coordinates";
    static const tgc_by_axes = "by_axes";
    
    //static const tgc_out_upper_right = "out_upper_right";
    //static const tgc_out_upper_left = "out_upper_left";
    //static const tgc_out_lower_right = "out_lower_right";
    //static const tgc_out_lower_left = "out_lower_left";
    //////////////
    static evt_mouse_down = "mouse_down";
    static evt_mouse_move = "mouse_move";
    static evt_mouse_in = "mouse_in";
    static evt_mouse_out = "mouse_out";
    static evt_mouse_up = "mouse_up";
    static const CAPTURING_PHASE = 1;
    static const AT_TARGET  = 2;
    static const BUBBLING_PHASE  = 3;
    ///////////////////////////
    static const cmd_zoom_inc  = "zoom_inc";
    static const cmd_figure_changed  = "figure_changed";
    static const cmd_data_changed  = "data_changed";
    static const cmd_node_add_in  = "node_add_in";
    
end 
type tg_evt =class()  //消息
    function create(etype,pms);
    begin
        feventtype := etype;
        ftimeStamp := mtic;
        fisTrusted := false;
        feventPhase := 0;
        freturnValue := true;
        fdefaultPrevented := false;
        fbubbles := true;
        FstopImmediatePropagationed := false;
        if not ifarray(pms) then return ;
        fiparams := pms;
        fisTrusted := pms["istrusted"]?true:false;
        ftarget := pms["target"];
        fcurrentTarget := pms["currenttarget"];
        fbubbles := pms["bubbles"]?true:false;
        feventPhase := (pms["eventphase"]>0)?pms["eventphase"]:0;
    end
    function clone(d); //克隆对象
    begin
        if ifarray(d) then d2 := fiparams union d;
        else d2 := d;
        co := self(true).Classinfo(1);
        return createobject(co,feventtype,d2);        
    end 
    function preventdefault(); //阻止默认行为
    begin
        fdefaultPrevented := true;
    end 
    function stoppropagation();  //停止传播
    begin
        fstoppropagationed := true;
    end 
    function stopImmediatePropagation(); //阻止当前类型的消息
    begin 
        FstopImmediatePropagationed := true;
    end      
    published
    property bubbles read fbubbles; //是否冒泡,只读
    property currentTarget read fcurrentTarget;//当前绑定的对象,只读
    property target read ftarget;//目标对象,只读
    property stoppropagationed read fstoppropagationed;//是否已经调用 stoppropagation,只读
    property stopImmediatePropagationed read FstopImmediatePropagationed;//是否已经调用 stopImmediatePropagation,只读
    property defaultPrevented read fdefaultPrevented;//是否已经调用 preventdefault,只读
    property returnValue read freturnValue write freturnValue;//true表示正常执行,false表示阻止默认行为
    property eventPhase read feventPhase;//只读,0,1,捕获,2到达目标,3,冒泡
    property timeStamp read ftimeStamp;//只读,加载完成到现在的时间
    property eventtype read feventtype;//只读类型
    property isTrusted read fisTrusted;//true表示用户触发,false表示代码触发
    property init_params read fiparams; //初始化参数
    private 
    feventtype;
    ftimeStamp;
    fisTrusted;
    feventPhase;
    freturnValue;
    fdefaultPrevented;
    fstoppropagationed;
    ftarget;
    fbubbles;
    fcurrentTarget;
    FstopImmediatePropagationed;
    fiparams;
end 
type tg_evt_custom = class(tg_evt) //自定义消息
    function create(etyp,pms);
    begin
        inherited;
        fdetail := array();
        if ifarray(pms) then fdetail := pms["detail"];
    end
    property detail read fdetail;
    private 
    fdetail;
end 
type tg_evt_mouse = class(tg_evt_custom) //鼠标消息
    function create(etyp,pms);
    begin
        inherited;
        if ifarray(pms) then 
        begin        
            fcvsx := pms["cvsx"];
            fcvsy := pms["cvsy"];
            fdouble := pms["double"];
            fshift := pms["shift"];
            fctl := pms["ctrl"];
        end 
    end
    property cvsx read fcvsx;
    property cvsy read fcvsy;
    property shift read fshift;
    property double read fdouble;
    property ctrl read fctrl;
    private 
    fcvsx;
    fcvsy;
    fshift;
    fdouble;
    fctrl;
end 

implementation
///////////事件存储对象///////////////////////
type tevent_item = class() 
    function create(n,f);
    begin
        ename := n;
        efunc := f;
    end    
    ename;
    [weakref]efunc;
end 
type tevent_list = class()
    function create();
    begin
        FItems := array();    
    end 
    function add(n,f);
    begin
        if not(ifstring(n) and n) then return 0;
        if not ifobj(f) then return 0;
        for i,v in FItems do 
        begin
            if (v.ename=n and v.efunc=f) then return ;
        end 
        FItems[length(FItems)] := new tevent_item(n,f);
        return true;
    end 
    function remove(n,f);
    begin
        idx := -1;
        for i,v in FItems do 
        begin
            if (ifnil(f) and v.ename = n) or (ifnil(n) and v.efunc=f) or (v.efunc=f and v.ename = n) then 
            begin
                idx := i;
                break;
            end 
        end 
        if idx>0 then 
        begin
            deleteindex(FItems,idx);
            remove(n,f);
        end 
    end 
    function dispatch(e);
    begin
        for i,it in FItems do 
        begin
            if it then 
            begin
                if e.stoppropagationed or e.stopImmediatePropagationed then return ;
                f := it.efunc;
                n := it.ename;
                if f and n=e.eventtype then call(f,e);                
            end 
        end 
    end 
    FItems;
end 
function node_hit_list(nd,info); //节点命中
begin
    nnd := node_hit_at(nd,info); 
    r := array();
    if nnd then 
    begin 
        r[0] := nnd ;
        idx := 1;
        while nnd do 
        begin 
            nnd := nnd.parent;
            if nnd then r[idx] := nnd;
            idx++;
        end 
    end 
    return r;
end 
function node_hit_at(nd,info); //命中处理
begin
    if (nd.visible=nd.tgc_off) then return 0;
    nct := nd.NodeCount;    
    if nct>0 then 
    begin 
        for i := nd.NodeCount-1 downto 0 do 
        begin
            hnod :=  node_hit_at(nd.GetNodeByIndex(i),info) ;
            if hnod then return hnod;
        end 
    end 
    if nd.hit_at(info) then return nd;   
    return 0;
end
function mg_bds(bds,d); //合并数据上下界
begin
    d[0,0] := min(bds[0,0],d[0,0]);
    d[0,1] := max(bds[0,1],d[0,1]);
    d[1,0] := min(bds[1,0],d[1,0]);
    d[1,1] := max(bds[1,1],d[1,1]);  
    d[2,0] := min(bds[2,0],d[2,0]);
    d[2,1] := max(bds[2,1],d[2,1]);    
end 
function p_trans(x,y,ag,_x,_y);//旋转
begin
    _x := x*cos(ag)+y*sin(ag);    
    _y := -x*sin(ag)+y*cos(ag);    
end 
function paint_lines(cvs,pls,xys,cls,ifo);//划线
begin
    o := static  new tg_const();
    case pls of 
        o.tgc_LS_staircase:
        begin
            if ifo["line_mode"]<>o.tgc_on then return ;
            last := array();
            for i,v in xys do 
            begin 
                if i=0 then 
                begin 
                    last := v;
                    cvs.moveto(v);
                end else 
                begin                         
                    cvs.lineto(array(v[0],last[1]));
                    cvs.lineto(v);
                    last := v;
                end 
            end 
        end 
        o.tgc_LS_barplot:
        begin            
            for i,v in xys do 
            begin 
                cvs.moveto(array(v[0],v[1]));
                cvs.lineto(array(ifo["xy0",i,0],ifo["xy0",i,1]));            
            end 
            paint_lines(cvs,o.tgc_LS_interpolated,xys,cls,ifo);            
        end 
        o.tgc_LS_bar:
        begin                        
            b_w := integer(ifo["bar_width"]/2);
            cvs.brush.color := ifo["bkcolor"];
            for i,v in xys do 
            begin 
                if b_w>=1 then 
                begin
                    v1 := array(v[0]-b_w,v[1]);        
                    v2 := array(v[0]+b_w,v[1]);  
                    v3 := array(ifo["xy0",i,0]+b_w,ifo["xy0",i,1]);   
                    v4 := array(ifo["xy0",i,0]-b_w,ifo["xy0",i,1]); 
                    cvs.draw_polygon().points(array(v1,v2,v3,v4)).draw();      
                end else 
                begin 
                    cvs.moveto(array(v[0],v[1]));
                    cvs.lineto(array(ifo["xy0",i,0],ifo["xy0",i,1])); 
                end            
            end  
            paint_lines(cvs,o.tgc_LS_interpolated,xys,cls,ifo);
        end 
        o.tgc_LS_arrowed:
        begin
            if ifo["line_mode"]<>o.tgc_on then return ;
            paint_lines(cvs,o.tgc_LS_interpolated,xys,cls,ifo);
            vlast := xys[0];
            for i,v in xys do 
            begin 
                if i<1 then continue;
                x := v[0];
                y := v[1];                
                dx := x-vlast[0];
                dy := y-vlast[1];
                arg := arctan(dy/dx)+pi();
                sz := 15;
                p_trans(sz,0,-(arg-pi()/6),x1,y1);
                cvs.moveto(v);
                cvs.lineto(array(v[0]+x1,v[1]+y1));
                p_trans(sz,0,-(arg+pi()/6),x1,y1);
                cvs.moveto(v);
                cvs.lineto(array(v[0]+x1,v[1]+y1));
                vlast := v;                    
            end 
        end 
        o.tgc_LS_filled:
        begin            
            
            if cls=o.tgc_on then 
            begin
                cvs.brush.color := ifo["bkcolor"];
                cvs.draw_polygon().points(xys).draw();
            end else 
            begin
                cvs.brush.color := ifo["color"]; 
                for i,v in xys do 
                begin 
                    if i=0 then continue;
                    v1 := v;
                    v4 := xys[i-1];
                    v2 := array(ifo["xy0",i,0],ifo["xy0",i,1]);                
                    v3 := array(ifo["xy0",i-1,0],ifo["xy0",i-1,1]);
                    cvs.draw_polygon().points(array(v1,v2,v3,v4)).draw();        
                end 
            end   
            paint_lines(cvs,o.tgc_LS_interpolated,xys,cls,ifo);                   
        end     
        else 
        begin 
            if ifo["line_mode"]<>o.tgc_on then return ;
            cvs.draw_polyline().points(xys union ((cls=o.tgc_on and length(xys)>2)?array(xys[0]):array())).draw();
        end 
    end 
end 
function paint_marks(mk,dc,xys); //绘制点
begin
    o := static  new tg_const();
    tp := mk.Style;
    sz := mk.size;
    a := integer(sz/2);
    b := max(a,(sz-a));
    a := b; 
    dc.pen.Style := 0; 
    dc.pen.color := mk.color;
    dc.brush.style := 0;
    dc.brush.color := mk.bkcolor;
    case tp of
        o.tgc_mks_pentagram:
        begin            
            sp := dc.draw_polygon();
            for i,v in xys do 
            begin 
                vv := array();
                for ii := 0 to 11 do 
                begin
                    if (ii mod 2)=1 then 
                    begin 
                        p_trans(0,-a/2,(ii*36)/180*pi(),_x,_y);     
                    end else  
                        p_trans(0,-a,(ii*36)/180*pi(),_x,_y); 
                    vv[ii] := array(v[0]+_x,v[1]+_y);   
                end 
                sp.points(vv).draw(); 
            end 
        end 
        o.tgc_mks_triangle_up:
        begin
            sp := dc.draw_polygon();
            for i,v in xys do 
            begin 
                v1 := array(v[0],v[1]-a);
                p_trans(0,-a,120/180*pi(),_x,_y);
                v2 := array(v[0]+_x,v[1]+_y);
                p_trans(0,-a,-120/180*pi(),_x,_y);
                v3 := array(v[0]+_x,v[1]+_y);
                sp.points(array(v1,v3,v2)).draw(); 
            end 
        end 
        o.tgc_mks_triangle_down:
        begin
            sp := dc.draw_polygon();
            for i,v in xys do 
            begin 
                v1 := array(v[0],v[1]+a);
                p_trans(0,a,120/180*pi(),_x,_y);
                v2 := array(v[0]+_x,v[1]+_y);
                p_trans(0,a,-120/180*pi(),_x,_y);
                v3 := array(v[0]+_x,v[1]+_y);
                sp.points(array(v1,v3,v2)).draw(); 
            end     
        end
        o.tgc_mks_triangle_left:
        begin
            sp := dc.draw_polygon();
            for i,v in xys do 
            begin 
                v1 := array(v[0]-a,v[1]);
                p_trans(-a,0,120/180*pi(),_x,_y);
                v2 := array(v[0]+_x,v[1]+_y);
                p_trans(-a,0,-120/180*pi(),_x,_y);
                v3 := array(v[0]+_x,v[1]+_y);
                sp.points(array(v1,v3,v2)).draw(); 
            end    
        end 
        o.tgc_mks_triangle_right:
        begin
            sp := dc.draw_polygon();
            for i,v in xys do 
            begin 
                v1 := array(v[0]+a,v[1]);
                p_trans(a,0,120/180*pi(),_x,_y);
                v2 := array(v[0]+_x,v[1]+_y);
                p_trans(a,0,-120/180*pi(),_x,_y);
                v3 := array(v[0]+_x,v[1]+_y);
                sp.points(array(v1,v3,v2)).draw(); 
            end    
        end
        o.tgc_mks_diamond_plus:
        begin
            mk.Style := o.tgc_mks_diamond ;
            paint_marks(mk,dc,xys);
            mk.Style := o.tgc_mks_plus;
            paint_marks(mk,dc,xys);
            mk.Style := o.tgc_mks_diamond_plus;    
        end  
        o.tgc_mks_diamond:         
        begin
            sp := dc.draw_polygon();
            for i,v in xys do 
            begin 
                x := v[0];
                y := v[1];
                v1 := array(x-a,y);
                v2 := array(x+b,y);
                v3 := array(x,y-a);
                v4 := array(x,y+b);
                sp.points(array(v1,v3,v2,v4)).draw(); 
            
            end     
        end 
        o.tgc_mks_dot,o.tgc_mks_circle,o.tgc_mks_square:
        begin 
            if tp=o.tgc_mks_dot then 
                dc.brush.color := mk.color;
            if tp=o.tgc_mks_square then pse := dc.draw_rect();
            else 
                pse := dc.draw_ellipse();            
            for i,v in xys do 
            begin 
                rec := array(v[0]-a,v[1]-a,v[0]+b,v[1]+b);
                pse.rect(rec).draw();            
            end                 
        end 
        o.tgc_mks_plus:
        begin
            for i,v in xys do 
            begin 
                x := v[0];
                y := v[1];
                v1 := array(x-a,y);
                v2 := array(x+b,y);
                v3 := array(x,y-a);
                v4 := array(x,y+b);
                dc.moveto(v1);
                dc.lineto(v2);
                dc.moveto(v3);
                dc.lineto(v4);            
            end     
        end 
        o.tgc_mks_star:
        begin
            mk.Style := o.tgc_mks_circle;
            paint_marks(mk,dc,xys);
            mk.Style := o.tgc_mks_plus;
            paint_marks(mk,dc,xys);
            mk.Style := o.tgc_mks_star;
        end
        o.tgc_mks_cross:
        begin
            for i,v in xys do 
            begin 
                x := v[0];
                y := v[1];
                v1 := array(x-a,y-a);
                v2 := array(x+b,y+b);
                v3 := array(x+b,y-a);
                v4 := array(x-a,y+b);
                dc.moveto(v1);
                dc.lineto(v2);
                dc.moveto(v3);
                dc.lineto(v4); 
            end    
        end
        o.tgc_mks_asterisk: 
        begin
            mk.Style := o.tgc_mks_cross;
            paint_marks(mk,dc,xys);
            mk.Style := o.tgc_mks_plus;
            paint_marks(mk,dc,xys);
            mk.Style := o.tgc_mks_asterisk;
        end      
    end ;    
end 
function tg_boolen_value(v,nv); //规则化boolean
begin
    if v=true or v="on" then 
    begin
        nv := "on";
        return true;
    end else
    if v=false or v="off" then  
    begin 
        nv := "off";
        return true;
    end  
end 
////////////////边界取整////////////////////////////
function new_bound_factor(a,n);
begin
    if a>1 and a<=10 then 
    begin
        return int(a)*10^n;
    end else 
    if a>10 then 
    begin
        n++;
        return new_bound_factor(a/10,n);
    end else 
    if a<=1 then 
    begin
        n--;
        return new_bound_factor(a*10,n);
    end 
end 
function new_bounds(a,b,a_,b_,par);
begin
    a_ := a;
    b_ := b;
    if not(par>=1) then par:=20;//20;
    r := new_bound_factor((b-a)/par,n);
    if r<>0 then 
    begin 
        a_:=floor(a/r)*r;
        b_:= ceil(b/r)*r;
    end 
    return r;
end
function get_node_data_bounds(nd); //获取节点的范围
begin
    d := zeros(3,2);
    for i := 0 to nd.NodeCount-1 do 
    begin 
        vi := nd.GetNodeByIndex(i);
        if vi is class(tg_graph_base) then 
        begin 
            bds := vi.get_data_bounds();
            mg_bds(bds,d);
        end 
    end 
    return d;     
end 
function get_rect_at_corner(x,y,w,h,itv,flg,mvx,mvy); //计算围绕点的区域位置
begin
    //0左上 ，1右上 2 右下 3 左下
    r := zeros(4);
    case flg of  
        0:
        begin
            r[0] :=x-w-itv;    
            r[1] :=y-h-itv;    
            r[2] :=x-itv;    
            r[3] :=y-itv;    
        end 
        1:
        begin
            r[0] :=x+itv;    
            r[1] :=y-h-itv;    
            r[2] :=x+w+itv;    
            r[3] :=y-itv;
        end 
        2:
        begin
            r[0] :=x+itv;    
            r[1] :=y+itv;    
            r[2] :=x+w+itv;    
            r[3] :=y+h+itv;
        end 
        3: 
        begin
            r[0] :=x-w-itv;    
            r[1] :=y+itv;    
            r[2] :=x-itv;    
            r[3] :=y+h+itv;  
        end 
        4: //中
        begin
            w2 := ceil(w/2);
            h2 := ceil(h/2);            
            r[0] :=x-w2;    
            r[1] :=y-h2;    
            r[2] :=x+w2;    
            r[3] :=y+h2;    
        end 
        
    end; 
    if mvx>0 or mvx<0 then 
    begin 
        r[0]+=mvx;
        r[2]+=mvx;
    end 
    if mvy>0 or mvy<0 then 
    begin 
        r[1]+=mvy;
        r[3]+=mvy;
    end 
    return r;
end
/////////////辅助//////////////////////////////////////
function like_0(x,jd);
begin
    if jd>10 then return (x+jd=jd);
    return (x+1000)=1000;
end 
function a_like_b(a,b,jd);
begin
    return like_0(a-b);
end 
function r_2_a(arg);
begin
    return arg*180/pi();
end
function a_2_r(arg);
begin
    return arg*pi()/180;
end  
function d2angle(v1,v2); //角度计算
begin
    return arccos(sum(v1*v2)/vectorsize(v1)/vectorsize(v2));
end 
function vectorsize(v); //向量长度
begin
    return (v[0]^2+v[1]^2)^0.5;
end     
function rec_to_points(rec);
begin
     return array(rec[array(0,1)],rec[array(2,1)],rec[array(2,3)],rec[array(0,3)],rec[array(0,1)]);
end 
function point_in_rgn(p,rgn_); //判断点是否在区域中
begin
    arg := 0;
    rgn := rgn_ union array(rgn_[0]);   
    for i := 1 to length(rgn)-1 do  
    begin 
        p1 := rgn[i-1];
        p2 := rgn[i];
        v1 := array(p1[0]-p[0],p1[1]-p[1]);
        v2 := array(p2[0]-p[0],p2[1]-p[1]);
        argi := d2angle(v1,v2);
        arg+=argi;
    end
    return (abs(arg/2-pi())<0.01);
end
function rgn_points_trans(pts,ag);
begin
    for i := 1 to length(pts)-1 do 
    begin
        p_trans(pts[i,0]-pts[0,0],pts[i,1]-pts[0,1],ag,px,py);
        pts[i] := array(pts[0,0]+px,pts[0,1]+py);
    end 
end 
function tg_get_true_idx(idx);
begin
    nidx := idx;
    case idx of 
        "x","X": nidx := 0;
        "y","Y": nidx := 1;
        "z","Z": nidx := 2;
    end ;
    return nidx;
end 
////////////////////////////////////////
initialization
finalization
end.