/*                                  axis

	Class for axis views.

    Note, the max and min for ticksets must be set through the _set_xyz_min
	  programs provided here.
*/

*! version 1.0.8  19jul2004
version 8

class {
	style		= .axisstyle.new
	position	= .relative_posn.new

	title		= .sized_textbox.new

	.major		= .tickset_g.new		// labeled major ticks
	.minor		= .tickset_g.new		// labeled minor ticks
	.majornl	= .tickset_g.new		// unlabeled major ticks
	.minornl	= .tickset_g.new		// unlabeled minor ticks

	draw_view       = .yesno.new, style(yes)	// ok, primitive style
	fill_if_undrawn = .yesno.new, style(no)
	force_draw	= .yesno.new, style(yes)	// for grid

	// plotregion -- declared dynmaically by reference

	xtransform = .transform.new , dimension(x)	// so axis can act
	ytransform = .transform.new , dimension(y)	// as container 

	box_alignment	= .compass2dir.new , style(center) // for aspect()

	_recreate	= .yesno.new, style(no)
	_uncreate	= .yesno.new, style(no)
	_created	= .yesno.new, style(no)

}, inherit(view)


// ----------------------------------------------------------------------------
//
//	Usage:  .new , plotregion(plotregion) [ position(left|right|below|above)
//			label_position style(axis_stylename) 
//			titlestyle(textbox_stylename) title(title_text) ]

program define new
				// apply default style settings if they are
				// not about to be reset by options
	syntax [ , Style(string) TITLEStyle(string) * ]
	if "`titlestyle'" == "" { 
		.title.set, style(scheme axis_title)
	}
	if "`style'" == ""      { 
		.style.setstyle, style(scheme)
	}

	.set `0'
	.set_formats
	.set_scales

	.minor.Declare mymajor   = .major.ref
	.minornl.Declare mymajor = .major.ref

	.set_ticks
end

program define set

	syntax [, PLotregion(string) POSition(string) Style(passthru) 	///
		  LAbel_position TITLE(string asis) TITLEStyle(string) * ]

	if `"`title'"' != `""' { 
		local title text(`title') 
	}
	if "`titlestyle'" != "" { 
		local titlestyle `"style(`titlestyle')"'
	}

	if "`plotregion'" != "" {
		if "`.Local.plotregion.isa'" == "" {
			.Declare plotregion = .Global.`plotregion'.ref
		}
		else	.plotregion.ref = .Global.`plotregion'.ref

		local ord = cond("`position'"=="left" |			///
				 "`position'"=="right", "y", "x")
		.`plotregion'.`ord'scale.add_axis `.objkey'
		.`plotregion'.addaxis `.objkey'
	}

	if "`style'" != "" { 
		.style.setstyle, `style'
	}

	.Super.set , `options'

	if "`position'" != "" {
		.position.setstyle, style(`position')

		if "`position'" == "left" | "`position'" == "right" {
			.xstretch.set fixed
			.ystretch.set shared
		}
		else if "`position'" == "below" | "`position'" == "above" {
			.xstretch.set shared
			.ystretch.set fixed
		}
	}

	if "`.position.snm'" == "left" | "`.position.snm'" == "right" {
		local orient orientation(vertical)
	}
	.title.edit, `title' `titlestyle' `orient'

end

// ---------------------------------------------------------------------------
//  Lets each of the ticksets use natscale to select a range and actual number
//  of ticks, then sets the scale to be the smallest miniumum and largest
//  maximum.

program define set_ticks
	args only_default

	if ! 0`.plotregion.isofclass plotregion' {
		exit					// no plotregion
	}

	local ord = cond("`.position.snm'"=="left" |			///
			 "`.position.snm'"=="right", "y", "x") 

	local min = 0`.plotregion.`ord'scale.min'
	local max = 0`.plotregion.`ord'scale.max'

	if `min' > `max' {					// not set yet
		exit 
	}			

	foreach ticks in major majornl minor {
		.`ticks'.set_ticks `min' `max'				///
			`.style.`ticks'style.numticks.val' `only_default'
	}
	.reset_scale 
        .minornl.suggest_between_ticks `.style.minornlstyle.numticks.val'
end


program define _set_ticks
	set_ticks `0'
end

program define reset_scale

	local ord = cond("`.position.snm'"=="left" |			///
			 "`.position.snm'"=="right", "y", "x") 
	.plotregion.`ord'scale.reset_from_axes
end


// ---------------------------------------------------------------------------
// Return the overall min/max of all the ticksets of the axis.

program overallmin
	local omin 1e300
	foreach ticks in major majornl minor minornl {
		local omin = min(`omin', `.`ticks'.overallmin')
	}

	class exit = `omin'
end

program define overallmax
	local omax -1e300
	foreach ticks in major majornl minor minornl {
		local omax = max(`omax', `.`ticks'.overallmax')
	}

	class exit = `omax'
end


// ---------------------------------------------------------------------------
//  Sets the formatting of each tickset to be the format picked up by the
//  plotregion.

program define set_formats
	local ord = cond("`.position.snm'"=="left" |			///
			 "`.position.snm'"=="right", "y", "x") 

	local fmt `.plotregion.dimformat `ord''

	if "`fmt'" == "" & "`.plotregion.`ord'scale._format'" != "" {
		local fmt `"`.plotregion.`ord'scale._format'"'
	}

	if "`fmt'" != "" {
		foreach ticks in major majornl minor minornl {
		      .`ticks'.set_format `fmt'
		}
	}
end


// ---------------------------------------------------------------------------
//  Let the ticksets know about their scale.

program define set_scales


	local ord = cond("`.position.snm'"=="left" | 			///
			 "`.position.snm'"=="right", "y", "x") 

	if 0`.plotregion.`ord'scale.isofclass scale' {
		foreach ticks in major majornl minor minornl {
		      .`ticks'.set_scale `.plotregion.`ord'scale.objkey'
		}
	}
end


// ---------------------------------------------------------------------------
//  Let the ticksets know about transform (log or linear).
//  They assume the current transform in the scale.

program define set_transform

	local ord = cond("`.position.snm'"=="left" | 			///
			 "`.position.snm'"=="right", "y", "x") 

	foreach ticks in major majornl minor minornl {
	      .`ticks'.set_transform `.plotregion.`ord'scale.objkey'
	}
end


// ---------------------------------------------------------------------------
//  Sets the plotregion for the axis and registers the axis with the 
//  plotregion and scale.

program set_plotregion
	args plotregion xy

	if "`plotregion'" == "" {
		exit
	}
	if "`xy'" != "x" & "`xy'" != "y" {
		exit
	}

	if "`.Local.plotregion.isa'" == "" {
		.Declare plotregion = .Global.`plotregion'.ref
	}
	else	.plotregion.ref = .Global.`plotregion'.ref

	.`plotregion'.`xy'scale.add_axis `.objkey'
	.`plotregion'.addaxis `.objkey'
end


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

	if "`.position.snm'"=="left" | "`.position.snm'"=="right" {
		local size = `.xsize_notitle' + `.style.outer_space.gmval'
		if 0`.title.draw_view.istrue' {
			local size = `size' + `.title.extent x' +	///
				     `.style.title_gap.gmval'
		}
	}
	else {
		local size cond("`.xstretch.setting'" == "fixed" ,	///
				0`.plotregion.xsize' , 0)
	}

	class exit = `size'
end

program define ysize

	if ! ( "`.position.snm'"=="left" | "`.position.snm'"=="right" ) {
		local size = `.ysize_notitle' + `.style.outer_space.gmval'
		if 0`.title.draw_view.istrue' {
			local size = `size' + `.title.extent y' + 	///
				     `.style.title_gap.gmval'
		}
	}
	else {
		local size cond("`.ystretch.setting'" == "fixed" ,	///
				0`.plotregion.ysize' , 0)
	}

	class exit = `size'
end

program define xsize_notitle

	if "`.position.snm'"!="left" & "`.position.snm'"!="right" {
		class exit = 0
	}

	class exit `._tick_and_label_width x'
end

program define ysize_notitle

	if "`.position.snm'"=="left" | "`.position.snm'"=="right" {
		class exit = 0
	}

	class exit = `._tick_and_label_width y'
end

program _tick_and_label_width
	args ord

	local frd = cond("`ord'" == "x" , "y" , "x")
	
	local max 0
	foreach ticks in major majornl minor minornl {
	    local max = max(`max', `.`ticks'._tick_and_label_width 	///
	      `.style.`ticks'style.objkey' `ord' `._value_label_series `frd''')
	}

	class exit = `max'
end

// ---------------------------------------------------------------------------
program set_userules
	args yesno

	foreach ticks in major majornl minor minornl {
		.`ticks'.use_rule.setstyle , style(`yesno')
	}
end


// ---------------------------------------------------------------------------
program clear_ticks
	foreach ticks in major majornl minor minornl {
		.`ticks'.clear_ticks
	}
end

// ---------------------------------------------------------------------------
//  Use compass_draw to allow alignment of the sized axis in an area that
//  is possibly larger than the size of the axis.

program draw

	syntax [, PLOTREgion(string) * ]

	if ("`plotregion'" == "") local plotregion plotregion


	if "`.`.position.parallel_dim'stretch.setting'" == "fixed" {
		.compass_draw , align(box_alignment)			///
			drawpgm(_sized_draw)				///
			margins(`plotregion'.style.margin)		///
			plotregion(`plotregion') `options'
	}
	else {
		.real_draw , `options'
	}
end

program _sized_draw

	syntax [, XSize(real 0) YSize(real 0) * ]

	.xsize_ren = `xsize'
	.ysize_ren = `ysize'

	.real_draw , xsize(`.xsize_ren') ysize(`.ysize_ren') `options'
end


// ---------------------------------------------------------------------------
// Note that .draw_view.isfalse implies we are only drawing the grids.
// Unless, .force_draw is also false

program define real_draw

	syntax [, XSize(real -1) YSize(real -1) GRIDONLY PLOTREgion(string) ]

	if `xsize' == -1 {
		.xsize_ren = `.xsize'
	}
	else	.xsize_ren = `xsize'

	if `ysize' == -1 {
		.ysize_ren = `.ysize'
	}
	else	.ysize_ren = `ysize'


	local gridonly = "`gridonly'" != ""

	if "`plotregion'" == "" {
		local plotregion plotregion
	}

	if ! (`.draw_view.istrue' | `gridonly') {
		exit						// Exit
	}

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


	.style.linestyle.setgdifull			// compute positions
	local pos `.position.snm'
	if "`pos'" == "default" { 
		local pos below 
	}

	if "`pos'" == "below" | "`pos'" == "above" {
	    local x0 = !`.style.extend_full_low.istrue' * 		  ///
			`.`plotregion'.style.margin.gmleft'
	    local x1 = `.xsize_ren' - !`.style.extend_full_high.istrue' * ///
			`.`plotregion'.style.margin.gmright'
	    local xtitle 0
	    local xtitlesz `.xsize_ren'
	    local ytitlesz `.title.extent y'
	    if "`pos'" == "below" {
	    	local y0 `.ysize_ren'
	    	local y1 `.ysize_ren'
		local ytitle `.style.outer_space.gmval'
	    }
	    else {
	    	local y0 0
	    	local y1 0
		local ytitle = `.ysize_notitle' + `.style.title_gap.gmval'
	    }
	}
	else if "`pos'" == "left" | "`pos'" == "right" {
	    local y0 = !`.style.extend_full_low.istrue' * 		  ///
			`.`plotregion'.style.margin.gmbottom'
	    local y1 = `.ysize_ren' - !`.style.extend_full_high.istrue' * ///
			`.`plotregion'.style.margin.gmtop'
	    local ytitle = 0
	    local xtitlesz `.title.extent x'
	    local ytitlesz `.ysize_ren'
	    if "`pos'" == "left" {
	    	local x0 = `.xsize_ren'
	    	local x1 = `.xsize_ren'
		local xtitle = `.style.outer_space.gmval'
	    }
	    else {
	    	local x0 0
	    	local x1 0
		local xtitle = `.xsize_notitle' + `.style.title_gap.gmval'
	    }
	}

							// draw main line
	if "`.style.linestyle.color.snm'" != "none" & 0`.draw_view.istrue' & ///
	   ! `gridonly' {
	    if `.style.extend' {
		gdi line `x0' `y0' `x1' `y1'	
		`crt' ._declare_array axis_line1
		`crt' .Declare axis_line1 = .line_g.new `x0' `y0' `x1' `y1', ///
			styleref(`.style.linestyle.objkey')
	    }
	    else {
		if "`pos'" == "left" | "`pos'" == "right" { 
			gdi line `x0' `.`plotregion'.yscale.curmin' 	///
				 `x1' `.`plotregion'.yscale.curmax' 
		}
		else {
			gdi line `.`plotregion'.xscale.curmin' `y0'	///
				 `.`plotregion'.xscale.curmax' `y1'
		}
	    }
	}

							// draw ticks
	if "`pos'" == "left" | "`pos'" == "right" {
		if ! `gridonly' {
			.`plotregion'.style.margin.setgdi, view(`.objkey') yonly
		}
		.`plotregion'.yscale.setgdi `.ysize_ren'
	}
	else {
		if ! `gridonly' {
			.`plotregion'.style.margin.setgdi, view(`.objkey') xonly
		}
		.`plotregion'.xscale.setgdi `.xsize_ren'
	}

	if `gridonly' {
		local x0 = - `.`plotregion'.style.margin.gmleft'
		local y0 = - `.`plotregion'.style.margin.gmbottom'
	}

	foreach ticks in minor minornl major majornl {

		local drawgrid = `gridonly' & 0`.style.draw_`ticks'_grid.istrue'
//		local gridonly = 0`.draw_view.isfalse'
//		local gridonly = `gridonly' | 0`.draw_view.isfalse'

		if "`pos'" == "left" | "`pos'" == "right" {
		    .`ticks'.draw `.style.`ticks'style.objkey'	///
			`pos' `x0'				///
			0`drawgrid'				///
			0`gridonly'				///
			0`.`plotregion'.xsize_ren'		///
			0`.`plotregion'.style.margin.gmleft'	///
			0`.`plotregion'.style.margin.gmright'	///
			"`._value_label_series y'"

		}
		else {
		    .`ticks'.draw `.style.`ticks'style.objkey'	///
			`pos' `y0'				///
			0`drawgrid'				///
			0`gridonly'				///
			0`.`plotregion'.ysize_ren'		///
			0`.`plotregion'.style.margin.gmbottom'	///
			0`.`plotregion'.style.margin.gmtop'		///
			"`._value_label_series x'"

		}
		gdi update
	}

	if ! `gridonly' {
		._draw_title `xtitle' `ytitle' `xtitlesz' `ytitlesz'
	}
	else {
		.xtransform.reset		/* back to transform when */
		.ytransform.reset		/* .axis was called 	  */
	}

exit


						/* Draw major ticks */
local fmt `.label_format'
local delta = (`.max' - `.min') / (`.numticks'-1)
local y0_0 `y0'
local x0_0 `x0'

if "`pos'" == "below" | "`pos'" == "above" { 
	.`plotregion'.style.margin.setgdi, view(`.objkey') xonly

	if "`pos'" == "below" {
		local y0 = `y0' - `.style.tickstyle.tick0'
		local y1 = `y0' + `.style.tickstyle.length.gmval'
	}
	else {
		local y0 = `y0' + `.style.tickstyle.tick0'
		local y1 = `y0' - `.style.tickstyle.length.gmval'
	}

	.`plotregion'.xscale.setgdi `.xsize_ren'

	if ! `.style.extend' {			/* draw main line */
	    if "`.style.linestyle.color.snm'" != "none" {
		gdi line `.min' `y0_0' `.max' `y0_0'
		`crt' ._declare_array axis_line
		`crt' .Declare axis_line = .line_g.new `.min' `y1'  /*
		      */ `.max' `y1',				  /*
		      */ styleref(`.style.linestyle.objkey')
	    }
	}
if `._created.istrue' & ! `._recreate.istrue' & "`crt'" != "" {
._drawem2 custom_labels x `y0_0' `pos' 
exit
}

	.style.tickstyle.setgdifull , 				/*
		*/ angle(`.style.tickangle.val') posdefault(`pos')

	local x = `.min'				/* ticks */
	forvalues i = 1/0`.numticks' {
		gdi line `x' `y0' `x' `y1'
		local x = `x' + `delta'
	}

							/* labels */
	if `.style.tickstyle.show_labels.istrue' {