grid.class

是一个经济学管理应用软件 很难找的 但是经济学学生又必须用到

	forvalues c = `m'(-1)1 {
		._fitgaps_check_n_blot clear : `rmin' `rmax' `c' `c'
		if ! `clear' { 
			continue, break				/* BREAK */
		}
		.`cell'.mincol = `c'
	}
end

program define _fitgaps_goright
	args cell

	local rmin `.`cell'.minrow'
	local rmax `.`cell'.maxrow'

	local c = `.`cell'.maxcol' + 1
	while `c' < `.maxcol' {
		._fitgaps_check_n_blot clear : `rmin' `rmax' `c' `c'
		if ! `clear' { 
			continue, break				/* BREAK */
		}
		.`cell'.maxcol = `c'
		local c = `c' + 1
	}
end

program define _clear_fitgaps
	cap macro drop T_gaprow*
	cap macro drop T_one
	cap macro drop T_zero
end

program define _fitgaps_show
	di substr("--------------------------------------------", 1, `.maxcol')
	forvalues r = `.maxrow'(-1)1 {
		di "${T_gaprow`r'}"
	}
	di substr("--------------------------------------------", 1, `.maxcol')
end


/* -------------------------------------------------------------------------*/
program define delete
	args view

	if "`.`view'.isa'" != "" {
		.`view'.ref       = NULLKEY
	}
	if "`.cells.`view'.isa'" != "" {
		.cells.`view'.ref = NULLKEY
	}
	if `.fitcells.arrnels' > 0 {
		_fill_fitgaps 
	}
end

/* -------------------------------------------------------------------------*/
program clear_all_views
	forvalues i = 1/0`.dynamicmv.arrnels' {
		class nameoflocal dynamicmv[`i'] 
		.delete `r(name)'
	}
end



/* -------------------------------------------------------------------------*/
program define xsize

	if "`.xstretch.setting'" == "fixed" & `.fixed_xsize' < . {
		class exit `.fixed_xsize'
	}
	class exit = `._fixed_sz col'
end

program define ysize

	if "`.ystretch.setting'" == "fixed" & `.fixed_ysize' < . {
		class exit `.fixed_ysize'
	}
	class exit = `._fixed_sz row'
end

program _fixed_sz
	args dim

	local ord = cond("`dim'"=="col", "x", "y")

	if "`.`ord'stretch.setting'" != "fixed" {
		class exit = 0
	}

	local holdgm `._Gr_Cglobal.gmetric_mult'	// gmetric multiplier
	._Gr_Cglobal.gmetric_mult =					///
		`.gmetric_mult' * `._Gr_Cglobal.gmetric_mult'

	tempname sizes				/* get sizes for each row/col */
	.`sizes' = {}

	forvalues i = 1/0`.cells.dynamicmv.arrnels' {

		if "`.cells.dynamicmv[`i'].isa'" != "array" {
			._do_fixed `sizes' `dim' "[`i']"
			continue				/* CONTINUE */
		}

					/* loop over any that are arrays */
		forvalues j = 1/0`.cells.dynamicmv[`i'].arrnels' {
		       ._do_fixed `sizes' `dim' "[`i'][`j']" 
		}
	}

						/* handle views that span */
	forvalues i = 1/0`.cells.dynamicmv.arrnels' {

		if "`.cells.dynamicmv[`i'].isa'" != "array" {
			._adj_span `sizes' `dim' "[`i']"
			continue				/* CONTINUE */
		}

					/* loop over any that are arrays */
		forvalues j = 1/0`.cells.dynamicmv[`i'].arrnels' {
		       ._adj_span `sizes' `dim' "[`i'][`j']" 
		}
	}

	forvalues i = 1/0`.`sizes'.arrnels' {
		local sz = 0`sz' + 0`.`sizes'[`i']'
	}

	._Gr_Cglobal.gmetric_mult = `holdgm'

	class exit = 0`sz'

end

program _do_fixed
	args sizes dim dex

	local cell cells.dynamicmv`dex'
	local view dynamicmv`dex'
	local ord = cond("`dim'"=="col", "x", "y")

	if "`.`view'.`ord'stretch.setting'" != "fixed" {	/* not fixed */
		exit
	}
	if 0`.`cell'.min`dim'' != 0`.`cell'.max`dim'' {		/* spans */
		exit
	}

	local sz = 0`.`view'.extent `ord''
	if `sz' > 0`.`sizes'[`.`cell'.min`dim'']' {
		.`sizes'[`.`cell'.min`dim''] = `sz'
	}

end

program _adj_span
	args sizes dim dex

	local cell cells.dynamicmv`dex'
	local view dynamicmv`dex'

	if 0`.`cell'.min`dim'' == 0`.`cell'.max`dim'' {		/* no span */
		exit
	}
	if "`.`view'.`ord'stretch.setting'" != "fixed" {	/* not fixed */
		exit
	}

	local ord = cond("`dim'"=="col", "x", "y")
	local sz = 0`.`view'.extent `ord''

	forvalues i = `.`cell'.min`dim''/`.`cell'.max`dim'' {
		local sum = `sum' + 0`.`sizes'[`i']'
	}

	if `sz' > 0`sum' {
		.`sizes'[`.`cell'.min`dim''] = `sz'
		forvalues i = `=`.cell.min`dim''+1'/`.`cell'.max`dim'' {
			.`sizes'[`i'] = 0
		}
	}

end


// ---------------------------------------------------------------------------
//  Places all of the pieces (views) of the source grid into this grid
//  at the specified location.  `ref' may be "" meaning copy, or ".ref"
//  meaining the target will contain references to the original views.
//  Copying is dangerous because of styles.
//  margin is optional and if it is specified, spacer views of the size of the
//  margin are placed around the views.  If a margin direction is zero, no
//  spacer is placed and if the the caller is tracking rows and columns it is
//  her responsibility to adjust for this.

program place_views
	args source r0 c0 ref margin

	if 0`.`source'.dynamicmv.arrnels' < 0 {		// nothing to place
		exit					// margins ignored
	}

	if 0`.`margin'.isofclass margin' {		// handle margins
	    if `.`margin'.left' > 0 {
		.insert (space = .spacer.new, xsize(`.`margin'.left'))	  ///
			at `=`r0'+1+`.`margin'.bottom'>0' `++c0'
	    }
	    if `.`margin'.bottom' > 0 {
		.insert (space = .spacer.new, ysize(`.`margin'.bottom'))  ///
			at `++r0' `=`c0'+1'
	    }

	    if `.`margin'.right' > 0 {
		.insert (space = .spacer.new, xsize(`.`margin'.right'))  ///
			at `=`r0'+1' `=`c0'+`.`source'.maxcol''
	    }
	    if `.`margin'.top' > 0 {
		.insert (space = .spacer.new, ysize(`.`margin'.top'))  ///
			at `=`r0'+`.`source'.maxrow'' `=`c0'+1'
	    }
	}

	forvalues i = 1/0`.`source'.dynamicmv.arrnels' {	// place views

	    class nameof `source' dynamicmv[`i'] 

	    if "`.`source'.dynamicmv[`i'].isa'" != "array" {
		._insert_plview `source' `r(name)' "[`i']" `r0' `c0' `ref'
		continue				// Continue
	    }

						/* loop over any arrays */
	    forvalues j = 1/`.`src'[`i'].arrnels' {
		._insert_plview `source' `r(name)' "[`i'][`j']" `r0' `c0' `ref'
	    }
	}


end

program _insert_plview
	args source name dex r0 c0 ref

	local src    `source'.dynamicmv`dex'
	local srcell `source'.cells.dynamicmv`dex'

	local range = `.`srcell'.maxrow' - `.`srcell'.minrow'
	if `range' > 0 {
		local spanrow spanrow(`range')
	}
	local range = `.`srcell'.maxcol' - `.`srcell'.mincol'
	if `range' > 0 {
		local spancols spancols(`range')
	}

	.insert (`name' = .`src'`ref')					  ///
		at `=`r0'+`.`srcell'.minrow'' `=`c0'+`.`srcell'.mincol''  ///
		, `spanrows' `spancols'
end

// ---------------------------------------------------------------------------

program draw

	if (! `.draw_view.istrue')  exit			// Exit

	.draw_setup1 `0'			// so children can break in
	.draw_setup2
	.draw_cells
end

program draw_setup1

	syntax [, XSize(real -999) YSize(real -999) ]

	if `xsize' == -999 {
		local xsize `.xsize'
	}
	if `ysize' == -999 {
		local ysize `.ysize'
	}

	if "`._scheme.isa'" != "" {		/* set the scheme */
		set curscm `._scheme.objkey'
	}

	._hold_scaling = .get_gu_scaling	// hold current GU scaling 

	if `.subview.istrue' {			/* set new GU scaling */
*		.set_gu_scaling `xsize' `ysize'	subview
		.xsize_ren = `xsize'
		.ysize_ren = `ysize'
	}
	else {
		.set_gu_scaling `xsize' `ysize'		
		if `xsize' < `ysize' {
			.ysize_ren = `ysize' * 100 / `xsize'
			.xsize_ren = 100
		}
		else {
			.xsize_ren = `xsize' * 100 / `ysize'
			.ysize_ren = 100
		}
	}

	if `.xoffset' | `.yoffset' {
		.xtransform.get_from_gdi
		.ytransform.get_from_gdi
	}
	if `.xoffset' {
		.xtransform.translate `.xoffset'
	}
	if `.yoffset' {
		.ytransform.translate `.yoffset'
	}

	if 0`.style.boxstyle.is_drawn' {			/* outer box */
		.style.boxstyle.draw 0 0 `.xsize_ren' `.ysize_ren'
	}

	.style.margin.setgdi,  view(`.objkey')		/* allow for margins */

	if 0`.style.inner_boxstyle.is_drawn'  {			/* inner box */
		.style.inner_boxstyle.draw 0 0 `.xsize_ren' `.ysize_ren'
	}

	.xtransform.get_from_gdi	/* fetch current transform */
	.ytransform.get_from_gdi
end

program draw_setup2

	._align y 			/* align if fixed stretch */
	._align x 			/* align if fixed stretch */


							// gmetric multiplier
	._hold_gmetric_mult = ._Gr_Cglobal.gmetric_mult	
	._Gr_Cglobal.gmetric_mult =					///
		`.gmetric_mult' * `._Gr_Cglobal.gmetric_mult'

	.position			/* position grid cells */

end

program draw_cells
					/* loop over all cells in the grid 
					 * and have them draw themselves */
	forvalues i = 1/0`.dynamicmv.arrnels' {

		if "`.dynamicmv[`i'].isa'" != "array" {
			._draw_cell "[`i']"
			continue				/* CONTINUE */
		}

					/* loop over any name that are arrays */
		forvalues j = 1/`.dynamicmv[`i'].arrnels' {
			._draw_cell "[`i'][`j']"
		}
						/* get row/col index from 1 */
	}

	._Gr_Cglobal.gmetric_mult = ._hold_gmetric_mult
	.reset_gu_scaling `._hold_scaling'	/* reset original GU scaling */
	gdi update
end


program draw_cell				// children may break in
	._draw_cell `0'
end

program define _draw_cell				
	gettoken dex options : 0

	local cell cells.dynamicmv`dex'
	local view dynamicmv`dex'

	if "`.`view'.isa'" == "" { 
		exit					/* empty view */
	}

	if "`.`view'.draw_view.istrue'"  == "0" & 			///
	   "`.`view'.force_draw.istrue'" != "1" {
		exit						/* not drawn */
	}	

	local row `.`cell'.minrow'		/* get row/col index from 1 */
	local col `.`cell'.mincol'

	if "`row'" == "" {			/* a view not in the grid */
		.`view'.draw
		exit				/* EXIT */
	}
	.xtransform.translate `.colpos[`col']'	/* translate to position */
	.ytransform.translate `.rowpos[`row']'	/* of view		 */

						/* compute allocated size */
	local toprow = min(`.`cell'.maxrow'+1, `.maxrow'+1)
	local topcol = min(`.`cell'.maxcol'+1, `.maxcol'+1)
	local xsize = cond(						/*
		*/    "`.`view'.xstretch.setting'" == "shared",	 	/*
		*/	`.shared_colsz', 				/*
		*/	`.colpos[`topcol']' - `.colpos[`col']'		/*
		*/ )
	local ysize = cond(						/*
		*/    "`.`view'.ystretch.setting'" == "shared",		/*
		*/	`.shared_rowsz', 				/*
		*/	`.rowpos[`toprow']' - `.rowpos[`row']'		/*
		*/ )

	.`view'.draw ,  xsize(`xsize') ysize(`ysize') `options'	    /* draw */

	.xtransform.reset			/* reset any scale changes */
	.ytransform.reset			/* made when object drew   */
end


program _align
	args dim

	if "`.`dim'stretch.setting'" != "fixed" {
		exit						// Exit
	}

	if `.fixed_`dim'size' < . {
		local sz `.fixed_`dim'size'
	}
	else {
		local sz `.`dim'size'
	}

	local shift = cond("`dim'" == "y", "top", "right")

	if `.`dim'size_ren' > `sz' {
	    if "`.style.vertical.stylename'"      == "`shift'" {
		.`dim'transform.translate_permanent `=`.`dim'size_ren'-`sz''
	    }
	    else {
		if "`.style.vertical.stylename'" == "center" {
		    .`dim'transform.translate_permanent 	///
		    	`=(`.`dim'size_ren'-`sz')/2'
		}
	    }

		.`dim'size_ren = `sz'
	}

end


/* -------------------------------------------------------------------------*/
/* Determine the positions of the grid's rows and columns.
*/
program define position

	if 0`._Gr_Cglobal.noposition'  exit

	_pos_dim row
	_pos_dim col
end

program define _pos_dim
	args dim			/* dim is "row" or "col" */

	tempname shrfrac		/* largest fraction in a shared view */
	.`shrfrac' = {}
					/* intialize sizes, will reuse the 
					 * position array */
	local m = `.max`dim'' + 1				/* sic */
	forvalues i = 1/`m' {
		.`dim'pos[`i'] = 0
		.`shrfrac'[`i'] = 0
	}

	global T_gm_fix_span 0
	.shared_`dim'sz = 0

	local ord = cond("`dim'"=="col", "x", "y")

					/* compute the maximum size of each 
					 * dim (row/col) and flag those that 
					 * are shared sizeable */
	forvalues i = 1/0`.dynamicmv.arrnels' {
		if "`.dynamicmv[`i'].isa'" != "array" {
			_update_pos `shrfrac' `dim' "[`i']"
			continue				/* CONTINUE */
		}
					/* loop over any that are arrays */
		forvalues j = 1/`.dynamicmv[`i'].arrnels' {
			_update_pos `shrfrac' `dim' "[`i'][`j']"
		}
	}
					/* expand sizes for spanning fixed */
	if $T_gm_fix_span {
		forvalues i = 1/0`.dynamicmv.arrnels' {
			if "`.dynamicmv[`i'].isa'" != "array" {
				_spread_fixed `shrfrac' `dim' "[`i']"
				continue			/* CONTINUE */
			}
					/* loop over any that are arrays */
			forvalues j = 1/`.dynamicmv[`i'].arrnels' {
				_spread_fixed `shrfrac' `dim' "[`i'][`j']"
			}
		}
	}
	
	._set_sizes    `shrfrac' `dim'

	_posn_from_size `dim'		/* set the positions from the sizes */

end

program define _update_pos
	args shrfrac dim dex			/* dim is "row" or "col" */

	local cell cells.dynamicmv`dex'
	local view dynamicmv`dex'

					
	if "`.`view'.isa'" == ""  {			/* empty view */
		exit
	}		
	if "`.`view'.draw_view.istrue'" == "0" & 			/*
	    */ ! 0`.`view'.fill_if_undrawn.istrue' { 
		exit					/* not drawn */
	}	

	local ord = cond("`dim'"=="col", "x", "y")

					/* see if sizeable in the current dim */
	
	local stretchability `.`view'.`ord'stretch.setting'

	if "`stretchability'" == "free" {
		if `.`cell'.min`dim'' == `.`cell'.max`dim'' {
			.`shrfrac'[`.`cell'.min`dim''] = 1
		}
		exit						/* EXIT */
	}                  

	if "`stretchability'" == "shared" {
		forvalues i = `.`cell'.min`dim''/`.`cell'.max`dim'' {
		   .`shrfrac'[`i'] = 1 + `.`cell'.max`dim'' - `.`cell'.min`dim''
		}
		exit						/* EXIT */
	}

							/* must be fixed */
	if `.`cell'.min`dim'' != `.`cell'.max`dim'' {
		global T_gm_fix_span 1
		exit						/* EXIT */
	}
					/* possibly update maximum size of the
					 * cell's row or column (dim) */

	local sizeref `dim'pos[`.`cell'.min`dim'']  /* ref to col/row size  */
	local size = 0`.`view'.extent `ord''
	
	if `size' > `.`sizeref'' {
		.`sizeref' = `size'
	}
end

program define _spread_fixed
	args shrfrac dim dex			/* dim is "row" or "col" */

	local cell cells.dynamicmv`dex'
	local view dynamicmv`dex'

					
	if "`.`view'.isa'" == ""  {			/* empty view	*/
		exit
	}		
	if "`.`view'.draw_view.istrue'" == "0" & 			/*
	    */ ! 0`.`view'.fill_if_undrawn.istrue' { 
		exit					/* not drawn	*/
	}	
	if `.`cell'.min`dim'' == `.`cell'.max`dim'' {
		exit					/* not spanning	*/
	}

	local ord = cond("`dim'"=="col", "x", "y")