import sys
ver = sys.version[:3]
if ver == "1.5" :
	import pychartdir15
	dll = pychartdir15
elif ver == "1.6" :
	import pychartdir16
	dll = pychartdir16
elif ver == "2.0" :
	import pychartdir20
	dll = pychartdir20
elif ver == "2.1" :
	import pychartdir21
	dll = pychartdir21
elif ver == "2.2" :
	import pychartdir22
	dll = pychartdir22
elif ver == "2.3" :
	import pychartdir23
	dll = pychartdir23
else :
	import pychartdir15
	dll = pychartdir15

#main DLL interface
_r = dll.callMethod

#version checking
dllVersion = (_r("getVersion") >> 16) & 0x7FFF
if dllVersion != 0x0300 and dllVersion != 0x0301 :
	raise ImportError('Version mismatch - "pychartdir.py" is of Ver 3.1, but "chartdir.dll/libchartdir.so" is of Ver %s.%s' % ((dllVersion >> 8) & 0xff, dllVersion & 0xff))

#utility to call DLL method
class MethodWrapper :
	def __init__(self, obj, id) :
		self.obj = obj
		self.id = id
	def __call__(self, *args) :
		defaultArgs = self.obj.defaultArgs.get(self.id)
		if defaultArgs != None and len(defaultArgs) > 1 :
			if len(args) < defaultArgs[1] - len(defaultArgs) + 2 :
				raise TypeError("Wrong number of arguments; expecting at least %d but received %d" %(defaultArgs[1] - len(defaultArgs) + 2, len(args)))
			if len(args) < defaultArgs[1] :
				args = args + defaultArgs[len(defaultArgs) - defaultArgs[1] + len(args):]
		ret = apply(_r, (self.obj.__class__.__name__ + "." + self.id, self.obj.this) + args)
		if defaultArgs != None and len(defaultArgs) > 0 and defaultArgs[0] != None :
			return defaultArgs[0](ret)
		else :
			return ret

class InheritedDictionary :
	def __init__(self, parent, this) :
		self.parent = parent
		self.this = this
	def get(self, key) :
		ret = self.this.get(key)
		if ret == None :
			return self.parent.get(key)
		else :
			return ret

#///////////////////////////////////////////////////////////////////////////////////
#//	constants
#///////////////////////////////////////////////////////////////////////////////////

BottomLeft = 1
BottomCenter = 2
BottomRight = 3	
Left = 4
Center = 5
Right = 6
TopLeft = 7
TopCenter = 8
TopRight = 9
Top = TopCenter
Bottom = BottomCenter

Transparent = 0xff000000L
Palette = 0xffff0000L
BackgroundColor = 0xffff0000L 
LineColor = 0xffff0001L
TextColor = 0xffff0002L
DataColor = 0xffff0008L
SameAsMainColor = 0xffff0007L

NoValue = +1.7e308
LogTick = 1.6E+308
TouchBar = -1.7E-100

NoAntiAlias = 0
AntiAlias = 1
AutoAntiAlias = 2

TryPalette = 0
ForcePalette = 1
NoPalette = 2
Quantize = 0
OrderedDither = 1
ErrorDiffusion = 2

BoxFilter = 0
LinearFilter = 1
QuadraticFilter = 2
BSplineFilter = 3
HermiteFilter = 4
CatromFilter = 5
MitchellFilter = 6
SincFilter = 7
LanczosFilter = 8
GaussianFilter = 9
HanningFilter = 10
HammingFilter = 11
BlackmanFilter = 12
BesselFilter = 13

PNG = 0
GIF = 1
JPG = 2
WMP = 3
BMP = 4

Overlay = 0
Stack = 1
Depth = 2
Side = 3
Percentage = 4
	
defaultPalette = [
	0xffffff, 0x000000, 0x000000, 0x808080, 
	0x808080, 0x808080, 0x808080, 0x808080,
	0xff3333, 0x33ff33, 0x6666ff, 0xffff00, 
	0xff66ff, 0x99ffff,	0xffcc33, 0xcccccc, 
	0xcc9999, 0x339966, 0x999900, 0xcc3300,	
	0x669999, 0x993333, 0x006600, 0x990099,
	0xff9966, 0x99ff99, 0x9999ff, 0xcc6600,
	0x33cc33, 0xcc99ff, 0xff6666, 0x99cc66,
	0x009999, 0xcc3333, 0x9933ff, 0xff0000,
	0x0000ff, 0x00ff00, 0xffcc99, 0x999999,
	-1
]

whiteOnBlackPalette = [
	0x000000, 0xffffff, 0xffffff, 0x808080, 
	0x808080, 0x808080, 0x808080, 0x808080,
	0xff0000, 0x00ff00, 0x0000ff, 0xffff00, 
	0xff00ff, 0x66ffff,	0xffcc33, 0xcccccc, 
	0x9966ff, 0x339966, 0x999900, 0xcc3300,	
	0x99cccc, 0x006600, 0x660066, 0xcc9999,
	0xff9966, 0x99ff99, 0x9999ff, 0xcc6600,
	0x33cc33, 0xcc99ff, 0xff6666, 0x99cc66,
	0x009999, 0xcc3333, 0x9933ff, 0xff0000,
	0x0000ff, 0x00ff00, 0xffcc99, 0x999999,
	-1
]

transparentPalette = [ 
	0xffffff, 0x000000, 0x000000, 0x808080, 
	0x808080, 0x808080, 0x808080, 0x808080,
	0x80ff0000L, 0x8000ff00L, 0x800000ffL, 0x80ffff00L, 
	0x80ff00ffL, 0x8066ffffL, 0x80ffcc33L, 0x80ccccccL, 
	0x809966ffL, 0x80339966L, 0x80999900L, 0x80cc3300L,
	0x8099ccccL, 0x80006600L, 0x80660066L, 0x80cc9999L,
	0x80ff9966L, 0x8099ff99L, 0x809999ffL, 0x80cc6600L,
	0x8033cc33L, 0x80cc99ffL, 0x80ff6666L, 0x8099cc66L,
	0x80009999L, 0x80cc3333L, 0x809933ffL, 0x80ff0000L,
	0x800000ffL, 0x8000ff00L, 0x80ffcc99L, 0x80999999L,
	-1
]

NoSymbol = 0
SquareSymbol = 1
DiamondSymbol = 2
TriangleSymbol = 3
RightTriangleSymbol = 4
LeftTriangleSymbol = 5
InvertedTriangleSymbol = 6
CircleSymbol = 7
CrossSymbol = 8
Cross2Symbol = 9

DashLine = 0x0505
DotLine = 0x0202
DotDashLine = 0x05050205
AltDashLine = 0x0A050505

goldGradient = [0, 0xFFE743, 0x60, 0xFFFFE0, 0xB0, 0xFFF0B0, 0x100, 0xFFE743]
silverGradient = [0, 0xC8C8C8, 0x60, 0xF8F8F8, 0xB0, 0xE0E0E0, 0x100, 0xC8C8C8]
redMetalGradient = [0, 0xE09898, 0x60, 0xFFF0F0, 0xB0, 0xF0D8D8, 0x100, 0xE09898]
blueMetalGradient = [0, 0x9898E0, 0x60, 0xF0F0FF, 0xB0, 0xD8D8F0, 0x100, 0x9898E0]
greenMetalGradient = [0, 0x98E098, 0x60, 0xF0FFF0, 0xB0, 0xD8F0D8, 0x100, 0x98E098]

SideLayout = 0
CircleLayout = 1

NormalLegend = 0
ReverseLegend = 1
NoLegend = 2

PixelScale = 0
XAxisScale = 1
YAxisScale = 2
AngularAxisScale = XAxisScale
RadialAxisScale = YAxisScale

#///////////////////////////////////////////////////////////////////////////////////
#//	bindings to libgraphics.h
#///////////////////////////////////////////////////////////////////////////////////

class TTFText :
	
	#obsoleted constants - for compatibility only
	NoAntiAlias = 0
	AntiAlias = 1
	AutoAntiAlias = 2

	defaultArgs = {}
		
	def __init__(self, this, parent) :
		self.this = this
		self.parent = parent
	def __del__(self) :
		_r("TTFText.destroy", self.this)
	def __getattr__(self, name) :
		if name[:2] == "__" :
			raise AttributeError 
		return MethodWrapper(self, name)
	#
	#Methods handled by MethodWrapper
	#================================
	#getWidth, getHeight, getLineHeight, getLineDistance, draw
	#

class DrawArea :
	
	#obsoleted constants - for compatibility only
	TryPalette = 0
	ForcePalette = 1
	NoPalette = 2
	Quantize = 0
	OrderedDither = 1
	ErrorDiffusion = 2

	defaultArgs = {
		"setSize":(None, 3, 0xffffff),
		"resize":(None, 4, LinearFilter, 1),
		"move":(None, 5, 0xffffff, LinearFilter, 1),
		"rotate":(None, 6, 0xffffff, -1, -1, LinearFilter, 1),
		"line":(None, 6, 1),
		"rect":(None, 7, 0),
		"text2":(None, 11, TopLeft),
		"rAffineTransform":(None, 9, 0xffffff, LinearFilter, 1),
		"affineTransform":(None, 9, 0xffffff, LinearFilter, 1),
		"sphereTransform":(None, 5, 0xffffff, LinearFilter, 1),
		"hCylinderTransform":(None, 4, 0xffffff, LinearFilter, 1),
		"vCylinderTransform":(None, 4, 0xffffff, LinearFilter, 1),
		"vTriangleTransform":(None, 4, -1, 0xffffff, LinearFilter, 1),
		"hTriangleTransform":(None, 4, -1, 0xffffff, LinearFilter, 1),
		"shearTransform":(None, 5, 0, 0xffffff, LinearFilter, 1),
		"waveTransform":(None, 8, 0, 0, 0, 0xffffff, LinearFilter, 1),
		"outJPG":(None, 2, 80),
		"outJPG2":(None, 1, 80),
		"setAntiAlias":(None, 2, 1, AutoAntiAlias),
		"dashLineColor":(None, 2, DashLine),
		"patternColor2":(None, 3, 0, 0),
		"gradientColor2":(None, 5, 90, 1, 0, 0),
		"setDefaultFonts":(None, 4, "", "", "")
		}
			
	def __init__(self, this = None) :
		if this == None :
			self.own_this = 1
			self.this = _r("DrawArea.create")
		else :
			self.own_this = 0
			self.this = this
	def __del__(self) :
		if self.own_this and self.this != None :
			_r("DrawArea.destroy", self.this)
	def __getattr__(self, name) :
		if name[:2] == "__" :
			raise AttributeError 
		return MethodWrapper(self, name)
	def clone(self, d, x, y, align, newWidth = -1, newHeight = -1, ft = LinearFilter, blur = 1) :
		_r("DrawArea.clone", self.this, d.this, x, y, align, newWidth, newHeight, ft, blur)
	def polygon(self, points, edgeColor, fillColor) :
		_r("DrawArea.polygon", self.this, 
			map(lambda a: a[0], points), map(lambda a: a[1], points), edgeColor, fillColor)
	def fill(self, x, y, color, borderColor = None) :
		if borderColor == None :
			_r("DrawArea.fill", self.this, x, y, color)
		else :
			self.fill2(x, y, color, borderColor)
	def text3(self, str, font, fontSize) :
		return TTFText(_r("DrawArea.text3", self.this, str, font, fontSize), self)
	def text4(self, text, font, fontIndex, fontHeight, fontWidth, angle, vertical) :
		return TTFText(_r("DrawArea.text4", self.this, text, font, fontIndex, fontHeight, fontWidth, angle, vertical), self)
	def merge(self, d, x, y, align, transparency) :
		_r("DrawArea.merge", self.this, d.this, x, y, align, transparency)
	def tile(self, d, transparency) :
		_r("DrawArea.tile", self.this, d.this, transparency)
	def patternColor(self, c, h = None, startX = 0, startY = 0) :
		if h == None :
			self.patternColor2(c)
		return _r("DrawArea.patternColor", self.this, c, h, startX, startY)
	def gradientColor(self, startX, startY = 90, endX = 1, endY = 0, startColor = 0, endColor = None) :
		if endColor == None :
			return self.gradientColor2(startX, startY, endX, endY, startColor)
		else :
			return _r("DrawArea.gradientColor", self.this, startX, startY, endX, endY, startColor, endColor)

	#
	#Methods handled by MethodWrapper
	#================================
	#setSize, resize, getWidth, getHeight(), setClipRect, setBgColor
	#move, rotate, hFlip, vFlip, 
	#pixel, getPixel
	#hline, vline, line, arc
	#rect, surface, sector, cylinder, circle, fill2, text, text2
	#setSearchPath, loadGIF, loadPNG, loadJPG, loadWMP, load
	#rAffineTransform, affineTransform, sphereTransform, hCylinderTransform, vCylinderTransform
	#vTriangleTransform, hTriangleTransform, shearTransform, waveTransform
	#out, outGIF, outPNG, outJPG, outWMP, outBMP, outGIF2, outPNG2, outJPG2, outWMP2, outBMP2, 
	#setPaletteMode, setDitherMethod, setTransparentColor, setAntiAliasText, setAntiAlias, setInterlace
	#setColorTable, getARGBColor, halfColor
	#dashLineColor, patternColor2, gradientColor2
	#setDefaultFonts, setFontTable
	#

#///////////////////////////////////////////////////////////////////////////////////
#//	bindings to drawobj.h
#///////////////////////////////////////////////////////////////////////////////////

class Box :
	def __init__(self, this) :
		self.this = this
	def setPos(self, x, y) :
		_r("Box.setPos", self.this, x, y)
	def setSize(self, w, h) :
		_r("Box.setSize", self.this, w, h)
	def setBackground(self, color, edgeColor = -1, raisedEffect = 0) :
		_r("Box.setBackground", self.this, color, edgeColor, raisedEffect)
	def getWidth(self) :
		return _r("Box.getWidth", self.this)
	def getHeight(self) :
		return _r("Box.getHeight", self.this)
	def getImageCoor(self, offsetX = 0, offsetY = 0) :
		return _r("Box.getImageCoor", self.this, offsetX, offsetY)
		
class TextBox(Box) :
	def __init__(self, this) :
		self.this = this
	def setText(self, text) :
		_r("TextBox.setText", self.this, text)
	def setFontStyle(self, font, fontIndex = 0) :
		_r("TextBox.setFontStyle", self.this, font, fontIndex)
	def setFontSize(self, fontHeight, fontWidth = 0) :
		_r("TextBox.setFontSize", self.this, fontHeight, fontWidth)
	def setFontAngle(self, angle, vertical = 0) :
		_r("TextBox.setFontAngle", self.this, angle, vertical)
	def setFontColor(self, color) :
		_r("TextBox.setFontColor", self.this, color)
	def setMargin2(self, leftMargin, rightMargin, topMargin, bottomMargin) :
		_r("TextBox.setMargin2", self.this, 
			leftMargin, rightMargin, topMargin, bottomMargin)
	def setMargin(self, m) :
		_r("TextBox.setMargin", self.this, m)
	def setAlignment(self, a) :
		_r("TextBox.setAlignment", self.this, a)

class Line : 
	def __init__(self, this) :
		self.this = this
	def setPos(self, x1, y1, x2, y2) :
		_r("Line.setPos", self.this, x1, y1, x2, y2)
	def setColor(self, c) :
		_r("Line.setColor", self.this, c)
	def setWidth(self, w) :
		_r("Line.setWidth", self.this, w)

#///////////////////////////////////////////////////////////////////////////////////
#//	bindings to basechart.h
#///////////////////////////////////////////////////////////////////////////////////
class LegendBox(TextBox) :
	def __init__(self, this) :
		self.this = this
	def addKey(self, text, color, lineWidth = 0, drawarea = '$$pointer$$null') :
		if hasattr(drawarea, "this") :
			drawarea = drawarea.this
		_r("LegendBox.addKey", self.this, text, color, lineWidth, drawarea)
	def setKeySize(self, width, height = -1, gap = -1) :
		_r("LegendBox.setKeySize", self.this, width, height, gap)
	def setKeySpacing(self, keySpacing, lineSpacing = -1) :
		_r("LegendBox.setKeySpacing", self.this, keySpacing, lineSpacing)
	def getImageCoor2(self, dataItem, offsetX = 0, offsetY = 0) :
		return _r("LegendBox.getImageCoor", self.this, dataItem, offsetX, offsetY)
	def getHTMLImageMap(self, url, queryFormat = "", extraAttr = "", offsetX = 0, offsetY = 0) :
		return _r("LegendBox.getHTMLImageMap", self.this, url, queryFormat, extraAttr, offsetX, offsetY)

class BaseChart :

	#obsoleted constants - for compatibility only
	PNG = 0
	GIF = 1
	JPG = 2
	WMP = 3

	this = None
	def __del__(self) :
		if self.this != None :
			_r("BaseChart.destroy", self.this)
	#//////////////////////////////////////////////////////////////////////////////////////
	#//	set overall chart
	#//////////////////////////////////////////////////////////////////////////////////////
	def setSize(self, width, height) :
		_r("BaseChart.setSize", self.this, width, height)
	def setBorder(self, color) :
		_r("BaseChart.setBorder", self.this, color)
	def setBackground(self, bgColor, edgeColor = -1, raisedEffect = 0) :
		_r("BaseChart.setBackground", self.this, bgColor, edgeColor, raisedEffect)
	def setWallpaper(self, img) :
		_r("BaseChart.setWallpaper", self.this, img)
	def setBgImage(self, img, align = Center) :
		_r("BaseChart.setBgImage", self.this, img, align)
	def setTransparentColor(self, c) :
		_r("BaseChart.setTransparentColor", self.this, c)
	def setAntiAlias(self, antiAliasShape = 1, antiAliasText = AutoAntiAlias) :
		_r("BaseChart.setAntiAlias", self.this, antiAliasShape, antiAliasText)
	def setSearchPath(self, path) :
		_r("BaseChart.setSearchPath", self.this, path)
	def addTitle2(self, alignment, text, font = "", fontSize = 12, fontColor = TextColor, 
		bgColor = Transparent, edgeColor = Transparent) :
		return TextBox(_r("BaseChart.addTitle2", self.this, 
			alignment, text, font, fontSize, fontColor, bgColor, edgeColor))
	def addTitle(self, text, font = "", fontSize = 12, fontColor = TextColor, 
		bgColor = Transparent, edgeColor = Transparent) :
		return TextBox(_r("BaseChart.addTitle", self.this, 
			text, font, fontSize, fontColor, bgColor, edgeColor))
	def addLegend(self, x, y, vertical = 1, font = "", fontSize = 10) :
		return LegendBox(_r("BaseChart.addLegend", self.this, 
			x, y, vertical, font, fontSize))
	def getLegend(self) :
		return LegendBox(_r("BaseChart.getLegend", self.this))
	#//////////////////////////////////////////////////////////////////////////////////////
	#//	drawing primitives
	#//////////////////////////////////////////////////////////////////////////////////////
	def getDrawArea(self) :
		return DrawArea(_r("BaseChart.getDrawArea", self.this))
	def addDrawObj(self, obj) :
		_r("BaseChart.addDrawObj", obj.this)
		return obj
	def addText(self, x, y, text, font = "", fontSize = 8, fontColor = TextColor, 
		alignment = TopLeft, angle = 0, vertical = 0) :
		return TextBox(_r("BaseChart.addText", self.this,
			x, y, text, font, fontSize, fontColor, alignment, angle, vertical))
	def addLine(self, x1, y1, x2, y2, color = LineColor, lineWidth = 1) :
		return Line(_r("BaseChart.addLine", self.this,
			x1, y1, x2, y2, color, lineWidth))
	#//////////////////////////////////////////////////////////////////////////////////////
	#//	color management methods
	#//////////////////////////////////////////////////////////////////////////////////////
	def setColor(self, paletteEntry, color) :
		_r("BaseChart.setColor", self.this, paletteEntry, color)
	def setColors(self, colors) :
		_r("BaseChart.setColors", self.this, colors)
	def setColors2(self, paletteEntry, colors) :
		_r("BaseChart.setColors2", self.this, paletteEntry, colors)
	def getColor(self, paletteEntry) :
		return _r("BaseChart.getColor", self.this, paletteEntry)
	def halfColor(self, c) :
		return _r("BaseChart.halfColor", self.this, c);
	def autoColor(self) :
		return _r("BaseChart.autoColor", self.this);
	def dashLineColor(self, color, dashPattern = DashLine) :
		return _r("BaseChart.dashLineColor", self.this, color, dashPattern)
	def patternColor(self, c, h = None, startX = 0, startY = 0) :
		if h == None :
			return self.patternColor2(c)
		return _r("BaseChart.patternColor", self.this, c, h, startX, startY)
	def patternColor2(self, filename, startX = 0, startY = 0) :
		return _r("BaseChart.patternColor2", self.this, filename, startX, startY)
	def gradientColor(self, startX, startY = 90, endX = 1, endY = 0, startColor = 0, endColor = None) :
		if endColor == None :
			return self.gradientColor2(startX, startY, endX, endY, startColor)
		else :
			return _r("BaseChart.gradientColor", self.this, startX, startY, endX, endY, startColor, endColor)
	def gradientColor2(self, c, angle = 90, scale = 1, startX = 0, startY = 0) :
		return _r("BaseChart.gradientColor2", self.this, c, angle, scale, startX, startY)
	#/////////////////////////////////////////////////////////////////////////////////////
	#//	locale support
	#//////////////////////////////////////////////////////////////////////////////////////
	def setDefaultFonts(self, normal, bold = "", italic = "", boldItalic = "") :
		_r("BaseChart.setDefaultFonts", self.this, normal, bold, italic, boldItalic)
	def setFontTable(self, index, font) :
		_r("BaseChart.setFontTable", self.this, index, font)
	def setNumberFormat(self, thousandSeparator = "~", decimalPointChar = ".", signChar = "-") :
		_r("BaseChart.setNumberFormat", self.this, thousandSeparator, decimalPointChar, signChar)
	def setMonthNames(self, names) :
		_r("BaseChart.setMonthNames", self.this, names)
	def setWeekDayNames(self, names) :
		_r("BaseChart.setWeekDayNames", self.this, names)
	def setAMPM(self, AM, PM) :
		_r("BaseChart.setAMPM", self.this, AM, PM)
	#//////////////////////////////////////////////////////////////////////////////////////
	#//	chart creation methods
	#//////////////////////////////////////////////////////////////////////////////////////
	def layout(self) :
		_r("BaseChart.layout", self.this)
	def makeChart(self, filename) :
		return _r("BaseChart.makeChart", self.this, filename)
	def makeChart2(self, format) :
		return _r("BaseChart.makeChart2", self.this, format)
	def makeChart3(self) :
		return DrawArea(_r("BaseChart.makeChart3", self.this))
	def makeTmpFile(self, path, imageFormat = PNG, lifeTime = 600) :
		filename = tmpFile2(path, lifeTime) + "." + {JPG:"jpg", GIF:"gif", BMP:"bmp", WMP:"wbmp"}.get(imageFormat, "png")
		if self.makeChart(path + "/" + filename) :
			return filename
		else :
			return ""		
	def getHTMLImageMap(self, url, queryFormat = "", extraAttr = "", offsetX = 0, offsetY = 0) :
		return _r("BaseChart.getHTMLImageMap", self.this, url, queryFormat, extraAttr, offsetX, offsetY)


class MultiChart(BaseChart) :
	def __init__(self, width, height, bgColor = BackgroundColor, edgeColor = Transparent, raisedEffect = 0) :
		self.this = _r("MultiChart.create", width, height, bgColor, edgeColor, raisedEffect)
		self.dependencies = []
	def addChart(self, x, y, c) :
		_r("MultiChart.addChart", self.this, x, y, c.this)
		self.dependencies.append(c)


#///////////////////////////////////////////////////////////////////////////////////
#//	bindings to piechart.h
#///////////////////////////////////////////////////////////////////////////////////

class Sector :
	def __init__(self, this) :
		self.this = this
	def setExplode(self, distance = -1) :
		_r("Sector.setExplode", self.this, distance)
	def setLabelFormat(self, formatString) :
		_r("Sector.setLabelFormat", self.this, formatString)
	def setLabelStyle(self, font = "", fontSize = 8, fontColor = TextColor) :
		return TextBox(_r("Sector.setLabelStyle", self.this, font, fontSize, fontColor))
	def setLabelPos(self, pos, joinLineColor = -1) :
		_r("Sector.setLabelPos", self.this, pos, joinLineColor)
	def setLabelLayout(self, layoutMethod, pos = -1) :
		_r("Sector.setLabelLayout", self.this, layoutMethod, pos)
	def setJoinLine(self, joinLineColor, joinLineWidth = 1) :
		_r("Sector.setJoinLine", self.this, joinLineColor, joinLineWidth)	
	def setColor(self, color, edgeColor = -1, joinLineColor = -1) :
		_r("Sector.setColor", self.this, color, edgeColor, joinLineColor)
	def getImageCoor(self, offsetX = 0, offsetY = 0) :
		return _r("Sector.getImageCoor", self.this, offsetX, offsetY)
	def getLabelCoor(self, offsetX = 0, offsetY = 0) :
		return _r("Sector.getLabelCoor", self.this, offsetX, offsetY)

class PieChart(BaseChart) :
	def __init__(self, width, height, bgColor = BackgroundColor, edgeColor = Transparent, raisedEffect = 0) :
		self.this = _r("PieChart.create", width, height, bgColor, edgeColor, raisedEffect)
	def setPieSize(self, x, y, r) :
		_r("PieChart.setPieSize", self.this, x, y, r)
	def set3D(self, depth = -1, angle = -1, shadowMode = 0) :
		if type(depth) == type([]) or type(depth) == type(()) :
			self.set3D2(depth, angle, shadowMode)
		else :
			_r("PieChart.set3D", self.this, depth, angle, shadowMode)
	def set3D2(self, depth, angle = 45, shadowMode = 0) :
		_r("PieChart.set3D2", self.this, depth, angle, shadowMode)
	def setStartAngle(self, startAngle, clockWise = 1) :
		_r("PieChart.setStartAngle", self.this, startAngle, clockWise)
	def setExplode(self, sectorNo, distance = -1) :
		_r("PieChart.setExplode", self.this, sectorNo, distance)
	def setExplodeGroup(self, startSector, endSector, distance = -1) :
		_r("PieChart.setExplodeGroup", self.this, startSector, endSector, distance)
	def setLabelFormat(self, formatString) :
		_r("PieChart.setLabelFormat", self.this, formatString)
	def setLabelStyle(self, font = "", fontSize = 8, fontColor = TextColor) :
		return TextBox(_r("PieChart.setLabelStyle", self.this, font,
			fontSize, fontColor))
	def setLabelPos(self, pos, joinLineColor = -1) :
		_r("PieChart.setLabelPos", self.this, pos, joinLineColor)
	def setLabelLayout(self, layoutMethod, pos = -1, topBound = -1, bottomBound = -1) :
		_r("PieChart.setLabelLayout", self.this, layoutMethod, pos, topBound, bottomBound)
	def setJoinLine(self, joinLineColor, joinLineWidth = 1) :
		_r("PieChart.setJoinLine", self.this, joinLineColor, joinLineWidth)
	def setLineColor(self, edgeColor, joinLineColor = -1) :
		_r("PieChart.setLineColor", self.this, edgeColor, joinLineColor)
	def setData(self, data, labels = []) :
		_r("PieChart.setData", self.this, data, labels)
	def addExtraField(self, texts) :
		_r("PieChart.addExtraField", self.this, texts)
	def sector(self, sectorNo) :
		return Sector(_r("PieChart.sector", self.this, sectorNo))
	

#///////////////////////////////////////////////////////////////////////////////////
#//	bindings to axis.h
#///////////////////////////////////////////////////////////////////////////////////
class Axis :
	def __init__(self, this) :
		self.this = this
	def setLabelStyle(self, font = "", fontSize = 8, fontColor = TextColor, fontAngle = 0) :
		return TextBox(_r("Axis.setLabelStyle", self.this, font, fontSize, fontColor, fontAngle))
	def setLabelFormat(self, formatString) :
		_r("Axis.setLabelFormat", self.this, formatString)
	def setLabelGap(self, d) :
		_r("Axis.setLabelGap", self.this, d)
	def setTitle(self, text, font = "", fontSize = 8, fontColor = TextColor) :
		return TextBox(_r("Axis.setTitle", self.this, text, font, fontSize, fontColor))
	def setTitlePos(self, alignment, titleGap = 6) :
		_r("Axis.setTitlePos", self.this, alignment, titleGap)
	def setColors(self, axisColor, labelColor = TextColor, titleColor = -1, tickColor = -1) :
		_r("Axis.setColors", self.this, axisColor, labelColor, titleColor, tickColor)
	def setTickLength(self, majorTickLen, minorTickLen = None) :
		if minorTickLen == None :
			_r("Axis.setTickLength", self.this, majorTickLen)
		else :
			self.setTickLength2(majorTickLen, minorTickLen)
	def setTickLength2(self, majorTickLen, minorTickLen) :
		_r("Axis.setTickLength2", self.this, majorTickLen, minorTickLen)
	def setTickWidth(self, majorTickWidth, minorTickWidth = -1) :
		_r("Axis.setTickWidth", self.this, majorTickWidth, minorTickWidth)
	def setTickColor(self, majorTickColor, minorTickColor = -1) :
		_r("Axis.setTickColor", self.this, majorTickColor, minorTickColor)

	def setWidth(self, width) :
		_r("Axis.setWidth", self.this, width)
	def setLength(self, length) :
		_r("Axis.setLength", self.this, length)
	def setPos(self, x, y, align = Center) :
		_r("Axis.setPos", self.this, x, y, align)
	def setTopMargin(self, topMargin) :
		self.setMargin(topMargin)
	def setMargin(self, topMargin, bottomMargin = 0) :
		_r("Axis.setMargin", self.this, topMargin, bottomMargin)
	def setIndent(self, indent) :
		_r("Axis.setIndent", self.this, indent)

	def setAutoScale(self, topExtension = 0.1, bottomExtension = 0.1, zeroAffinity = 0.8) :
		_r("Axis.setAutoScale", self.this, topExtension, bottomExtension, zeroAffinity)
	def setRounding(self, roundMin, roundMax) :
		_r("Axis.setRounding", self.this, roundMin, roundMax)
	def setTickDensity(self, majorTickDensity, minorTickDensity = 20) :
		_r("Axis.setTickDensity", self.this, majorTickDensity, minorTickDensity)
	def setReverse(self, b = 1) :
		_r("Axis.setReverse", self.this, b)
		
	def setLabels(self, labels, formatString = None) :
		if formatString == None :
			return TextBox(_r("Axis.setLabels", self.this, labels))
		else :
			return self.setLabels2(labels, formatString)
	def setLabels2(self, labels, formatString = "") :
		return TextBox(_r("Axis.setLabels2", self.this, labels, formatString))

	def setLinearScale(self, lowerLimit = None, upperLimit = None, majorTickInc = 0, minorTickInc = 0) :
		if lowerLimit == None :
			self.setLinearScale3()
		elif upperLimit == None :
			self.setLinearScale3(lowerLimit)
		elif type(majorTickInc) == type([]) or type(majorTickInc) == type(()) :
			self.setLinearScale2(lowerLimit, upperLimit, majorTickInc)
		else :
			_r("Axis.setLinearScale", self.this, lowerLimit, upperLimit, majorTickInc, minorTickInc)
	def setLinearScale2(self, lowerLimit, upperLimit, labels) :
		_r("Axis.setLinearScale2", self.this, lowerLimit, upperLimit, labels)
	def setLinearScale3(self, formatString = "") :
		_r("Axis.setLinearScale3", self.this, formatString)

	def setLogScale(self, lowerLimit = None, upperLimit = None, majorTickInc = 0, minorTickInc = 0) :
		if lowerLimit == None :
			self.setLogScale3()
		elif upperLimit == None :
			self.setLogScale3(lowerLimit)
		elif type(majorTickInc) == type([]) or type(majorTickInc) == type(()) :
			self.setLogScale2(lowerLimit, upperLimit, majorTickInc)
		else :
			_r("Axis.setLogScale", self.this, lowerLimit, upperLimit, majorTickInc, minorTickInc)
	def setLogScale2(self, lowerLimit, upperLimit, labels = 0) :
		if type(labels) == type([]) or type(labels) == type(()) :
			_r("Axis.setLogScale2", self.this, lowerLimit, upperLimit, labels)
		else :
			#compatibility with ChartDirector Ver 2.5
			self.setLogScale(lowerLimit, upperLimit, labels)
	def setLogScale3(self, formatString = "") :
		if type(formatString) != type("") :
			#compatibility with ChartDirector Ver 2.5
			if formatString :
				self.setLogScale3()
			else :
				self.setLinearScale3()
		else :
			_r("Axis.setLogScale3", self.this, formatString)

	def setDateScale(self, lowerLimit = None, upperLimit = None, majorTickInc = 0, minorTickInc = 0) :
		if lowerLimit == None :
			self.setDateScale3()
		elif upperLimit == None :
			self.setDateScale3(lowerLimit)
		elif type(majorTickInc) == type([]) or type(majorTickInc) == type(()) :
			self.setDateScale2(lowerLimit, upperLimit, majorTickInc)
		else :
			_r("Axis.setDateScale", self.this, lowerLimit, upperLimit, majorTickInc, minorTickInc)
	def setDateScale2(self, lowerLimit, upperLimit, labels) :
		_r("Axis.setDateScale2", self.this, lowerLimit, upperLimit, labels)
	def setDateScale3(self, formatString = "") :
		_r("Axis.setDateScale3", self.this, formatString)

	def addLabel(self, pos, label) :
		_r("Axis.addLabel", self.this, pos, label)
	def addMark(self, value, lineColor, text = "", font = "", fontSize = 8) :
		return Mark(_r("Axis.addMark", self.this, value, lineColor, text, font, fontSize))
	def addZone(self, startValue, endValue, color) :
		_r("Axis.addZone", self.this, startValue, endValue, color)

	def getCoor(self, v) :
		return _r("Axis.getCoor", self.this, v)
	def getLength(self) :
		return _r("Axis.getLength", self.this)
	def getMinValue(self) :
		return _r("Axis.getMinValue", self.this)
	def getMaxValue(self) :
		return _r("Axis.getMaxValue", self.this)
	def getScaleType(self) :
		return _r("Axis.getScaleType", self.this)

	def getTicks(self) :
		return _r("Axis.getTicks", self.this)
	def getLabel(self, i) :
		return _r("Axis.getLabel", self.this, i)


class AngularAxis :
	defaultArgs = {
		"setLabelStyle":(TextBox, 4, "", 8, TextColor, 0),
		"setReverse":(None, 1, 1),
		"setLabels2":(TextBox, 2, "")
		}
	def __init__(self, this) :
		self.this = this
	def __getattr__(self, name) :
		if name[:2] == "__" :
			raise AttributeError 
		return MethodWrapper(self, name)
	def setLabels(self, labels, formatString = None) :
		if formatString == None :
			return TextBox(_r("AngularAxis.setLabels", self.this, labels))
		else :
			return self.setLabels2(labels, formatString)
	def setLinearScale(self, lowerLimit, upperLimit, majorTickInc = 0, minorTickInc = 0) :
		if type(majorTickInc) == type([]) or type(majorTickInc) == type(()) :
			self.setLinearScale2(lowerLimit, upperLimit, majorTickInc)
		else :
			_r("AngularAxis.setLinearScale", self.this, lowerLimit, upperLimit, majorTickInc, minorTickInc)
	#
	#Methods handled by MethodWrapper
	#================================
	#setLabelStyle, setLabelGap, setLabels2, addLabel, setLinearScale2
	#getCoor, getTicks, getLabel
	#
	
			
class Mark(TextBox) :
	def __init__(self, this) :
		self.this = this
	def setValue(self, value) :
		_r("Mark.setValue", self.this, value)
	def setMarkColor(self, lineColor, textColor = -1, tickColor = -1) :
		_r("Mark.setMarkColor", self.this, lineColor, textColor, tickColor)
	def setLineWidth(self, w) :
		_r("Mark.setLineWidth", self.this, w)
	def setDrawOnTop(self, b) :
		_r("Mark.setDrawOnTop", self.this, b)
	def getLine(self) :
		return _r("Mark.getLine", self.this)


#///////////////////////////////////////////////////////////////////////////////////
#//	bindings to layer.h
#///////////////////////////////////////////////////////////////////////////////////
class DataSet :
	def __init__(self, this) :
		self.this = this
	def setData(self, data) :
		_r("DataSet.setData", self.this, data)
	def setDataName(self, name) :
		_r("DataSet.setDataName", self.this, name)
	def setDataColor(self, dataColor, edgeColor = -1, shadowColor = -1, shadowEdgeColor = -1) :
		_r("DataSet.setDataColor", self.this, dataColor, edgeColor, shadowColor, shadowEdgeColor)
	def setUseYAxis2(self, b = 1) :
		_r("DataSet.setUseYAxis2", self.this, b)
	def setLineWidth(self, w) :
		_r("DataSet.setLineWidth", self.this, w)
	def setDataLabelFormat(self, formatString) :
		_r("DataSet.setDataLabelFormat", self.this, formatString)
	def setDataLabelStyle(self, font = "", fontSize = 8, fontColor = TextColor, fontAngle = 0) :
		return TextBox(_r("DataSet.setDataLabelStyle", self.this, font, fontSize, fontColor, fontAngle))
	def setDataSymbol(self, symbol, size = None, fillColor = -1, edgeColor = -1, lineWidth = 1) :
		if size == None :
			try :
				symbol = int(symbol)
				size = 5
			except :
				self.setDataSymbol2(symbol)
				return
		_r("DataSet.setDataSymbol", self.this, symbol, size, fillColor, edgeColor, lineWidth)
	def setDataSymbol2(self, image) :
		if hasattr(image, "this") :
			self.setDataSymbol3(image)
		_r("DataSet.setDataSymbol2", self.this, image)
	def setDataSymbol3(self, image) :
		_r("DataSet.setDataSymbol3", self.this, image.this)


class Layer :

	#obsoleted constants - for compatibility only
	Overlay = 0
	Stack = 1
	Depth = 2
	Side = 3

	def __init__(self, this) :
		self.this = this
	def setSize(self, x, y, w, h, swapXY = 0) :
		_r("Layer.setSize", self.this, x, y, w, h, swapXY)
	def setBorderColor(self, color, raisedEffect = 0) :
		_r("Layer.setBorderColor", self.this, color, raisedEffect)
	def set3D(self, d = -1, zGap = 0) :
		_r("Layer.set3D", self.this, d, zGap)
	def set3D2(self, xDepth, yDepth, xGap, yGap) :
		_r("Layer.set3D2", self.this, xDepth, yDepth, xGap, yGap)
	def setLineWidth(self, w) :
		_r("Layer.setLineWidth", self.this, w)
	def setDataCombineMethod(self, m) :
		_r("Layer.setDataCombineMethod", self.this, m)
	def setLegend(self, m) :
		_r("Layer.setLegend", self.this, m)
	def addDataSet(self, data, color = -1, name = "") :
		return DataSet(_r("Layer.addDataSet", self.this, data, color, name))
	def addDataGroup(self, name = "") :
		_r("Layer.addDataGroup", self.this, name)
	def addExtraField(self, texts) :
		_r("Layer.addExtraField", self.this, texts)
	def getDataSet(self, dataSet) :
		return DataSet(_r("Layer.getDataSet", self.this, dataSet))
	def setUseYAxis2(self, b = 1) :
		_r("Layer.setUseYAxis2", self.this, b)
	def setXData(self, xData, dummy = None) :
		if dummy != None :
			self.setXData2(xData, dummy)
		else :
			_r("Layer.setXData", self.this, xData)
	def setXData2(self, minValue, maxValue) :
		_r("Layer.setXData2", self.this, minValue, maxValue)
	def getMinX(self) :
		return _r("Layer.getMinX", self.this)
	def getMaxX(self) :
		return _r("Layer.getMaxX", self.this)
	def getMaxY(self, yAxis = 1) :
		return _r("Layer.getMaxY", self.this, yAxis)
	def getMinY(self, yAxis = 1) :
		return _r("Layer.getMinY", self.this, yAxis)
	def getDepthX(self) :
		return _r("Layer.getDepthX", self.this)
	def getDepthY(self) :
		return _r("Layer.getDepthY", self.this)
	def getXCoor(self, v) :
		return _r("Layer.getXCoor", self.this, v)
	def getYCoor(self, v, yAxis = 1) :
		return _r("Layer.getYCoor", self.this, v, yAxis)
	def xZoneColor(self, threshold, upperColor, lowerColor) :
		return _r("Layer.xZoneColor", self.this, threshold, upperColor, lowerColor)
	def yZoneColor(self, threshold, upperColor, lowerColor, yAxis = 1) :
		return _r("Layer.yZoneColor", self.this, threshold, upperColor, lowerColor, yAxis)
	def setDataLabelFormat(self, formatString) :
		_r("Layer.setDataLabelFormat", self.this, formatString)
	def setDataLabelStyle(self, font = "", fontSize = 8, fontColor = TextColor, fontAngle = 0) :
		return TextBox(_r("Layer.setDataLabelStyle", self.this, font, fontSize, fontColor, fontAngle))
	def setAggregateLabelFormat(self, formatString) :
		_r("Layer.setAggregateLabelFormat", self.this, formatString)
	def setAggregateLabelStyle(self, font = "", fontSize = 8, fontColor = TextColor, fontAngle = 0) :
		return TextBox(_r("Layer.setAggregateLabelStyle", self.this, font, fontSize, fontColor, fontAngle))
	def addCustomDataLabel(self, dataSet, dataItem, label, font = "", fontSize = 8, fontColor = TextColor, fontAngle = 0) :
		return TextBox(_r("Layer.addCustomDataLabel", self.this, dataSet, dataItem, label, font, fontSize, fontColor, fontAngle))
	def addCustomAggregateLabel(self, dataItem, label, font = "", fontSize = 8, fontColor = TextColor, fontAngle = 0) :
		return TextBox(_r("Layer.addCustomAggregateLabel", self.this, dataItem, label, font, fontSize, fontColor, fontAngle))
	def getImageCoor(self, dataSet, dataItem = None, offsetX = 0, offsetY = 0) :
		if dataItem == None :
			return self.getImageCoor2(dataItem)
		else :
			return _r("Layer.getImageCoor", self.this, dataSet, dataItem, offsetX, offsetY)
	def getImageCoor2(self, dataItem, offsetX = 0, offsetY = 0) :
		return _r("Layer.getImageCoor2", self.this, dataItem, offsetX, offsetY)
	def getHTMLImageMap(self, url, queryFormat = "", extraAttr = "", offsetX = 0, offsetY = 0) :
		return _r("Layer.getHTMLImageMap", self.this, url, queryFormat, extraAttr, offsetX, offsetY)


#///////////////////////////////////////////////////////////////////////////////////
#//	bindings to barlayer.h
#///////////////////////////////////////////////////////////////////////////////////
class BarLayer(Layer) :
	def __init__(self, this) :
		self.this = this
	def setBarGap(self, barGap, subBarGap = 0.2) :
		_r("BarLayer.setBarGap", self.this, barGap, subBarGap)
	def setBarWidth(self, barWidth, subBarWidth = -1) :
		_r("BarLayer.setBarWidth", self.this, barWidth, subBarWidth)
	def setMinLabelSize(self, s) :
		_r("BarLayer.setMinLabelSize", self.this, s)


#///////////////////////////////////////////////////////////////////////////////////
#//	bindings to linelayer.h
#///////////////////////////////////////////////////////////////////////////////////

class LineLayer(Layer) :
	def __init__(self, this) :
		self.this = this
	def setGapColor(self, lineColor, lineWidth = -1) :
		_r("LineLayer.setGapColor", self.this, lineColor, lineWidth)
	def setImageMapWidth(self, width) :
		_r("LineLayer.setImageMapWidth", self.this, width)
	def setSymbolScale(self, zDataX, scaleTypeX = PixelScale, zDataY = [], scaleTypeY = PixelScale) :
		_r("LineLayer.setSymbolScale", self.this, zDataX, scaleTypeX, zDataY, scaleTypeY)
	def getLine(self, dataSet = 0) :
		return _r("LineLayer.getLine", self.this, dataSet)

class ScatterLayer(LineLayer) :
	pass

class InterLineLayer(LineLayer) :
	pass
	
class SplineLayer(LineLayer) :
	def setTension(self, t) :
		_r("SplineLayer.setTension", self.this, t)
		
class StepLineLayer(LineLayer) :
	def setAlignment(self, a) :
		_r("StepLineLayer.setAlignment", self.this, a)
	
	
#///////////////////////////////////////////////////////////////////////////////////
#//	bindings to arealayer.h
#///////////////////////////////////////////////////////////////////////////////////
class AreaLayer(Layer) :
	def __init__(self, this) :
		self.this = this
	def setMinLabelSize(self, s) :
		_r("AreaLayer.setMinLabelSize", self.this, s)

#///////////////////////////////////////////////////////////////////////////////////
#//	bindings to trendlayer.h
#///////////////////////////////////////////////////////////////////////////////////
class TrendLayer(Layer) :
	def __init__(self, this) :
		self.this = this
	def setImageMapWidth(self, width) :
		_r("TrendLayer.setImageMapWidth", self.this, width)
	def getLine(self) :
		return _r("TrendLayer.getLine", self.this)
	def addConfidenceBand(self, confidence, upperFillColor, upperEdgeColor = Transparent, upperLineWidth = 1,
		lowerFillColor = -1, lowerEdgeColor = -1, lowerLineWidth = -1) :
		_r("TrendLayer.addConfidenceBand", self.this, confidence, upperFillColor, upperEdgeColor, upperLineWidth, 
			lowerFillColor, lowerEdgeColor, lowerLineWidth)
	def addPredictionBand(self, confidence, upperFillColor, upperEdgeColor = Transparent, upperLineWidth = 1, 
		lowerFillColor = -1, lowerEdgeColor = -1, lowerLineWidth = -1) :
		_r("TrendLayer.addPredictionBand", self.this, confidence, upperFillColor, upperEdgeColor, upperLineWidth, 
			lowerFillColor, lowerEdgeColor, lowerLineWidth)
	def getSlope(self) :
		return _r("TrendLayer.getSlope", self.this)
	def getIntercept(self) :
		return _r("TrendLayer.getIntercept", self.this)
	def getCorrelation(self) :
		return _r("TrendLayer.getCorrelation", self.this)
	def getStdError(self) :
		return _r("TrendLayer.getStdError", self.this)
			
#///////////////////////////////////////////////////////////////////////////////////
#//	bindings to hloclayer.h
#///////////////////////////////////////////////////////////////////////////////////
class HLOCLayer(Layer) :
	def __init__(self, this) :
		self.this = this
	def setDataGap(self, gap) :
		_r("HLOCLayer.setDataGap", self.this, gap)
	def setChartType(self, t) :
		_r("HLOCLayer.setChartType", self.this, t)

class CandleStickLayer(HLOCLayer) :
	pass

class BoxWhiskerLayer(HLOCLayer) :
	pass

#///////////////////////////////////////////////////////////////////////////////////
#//	bindings to xychart.h
#///////////////////////////////////////////////////////////////////////////////////
class PlotArea :
	def __init__(self, this) :
		self.this = this
	def setBackground(self, color, altBgColor = -1, edgeColor = LineColor) :
		_r("PlotArea.setBackground", self.this, color, altBgColor, edgeColor)
	def setBackground2(self, img, align = Center) :
		_r("PlotArea.setBackground2", self.this, img, align)
	def setGridColor(self, hGridColor, vGridColor = Transparent, minorHGridColor = -1, minorVGridColor = -1) :
		_r("PlotArea.setGridColor", self.this, hGridColor, vGridColor, minorHGridColor, minorVGridColor)
	def setGridWidth(self, hGridWidth, vGridWidth = -1, minorHGridWidth = -1, minorVGridWidth = -1) :
		_r("PlotArea.setGridWidth", self.this, hGridWidth, vGridWidth, minorHGridWidth, minorVGridWidth)

class XYChart(BaseChart) :
	def __init__(self, width, height, bgColor = BackgroundColor, edgeColor = Transparent, raisedEffect = 0) :
		self.this = _r("XYChart.create", width, height, bgColor, edgeColor, raisedEffect)
	def yAxis(self) :
		return Axis(_r("XYChart.yAxis", self.this))
	def yAxis2(self) :
		return Axis(_r("XYChart.yAxis2", self.this))
	def syncYAxis(self, slope = 1, intercept = 0) :
		_r("XYChart.syncYAxis", self.this, slope, intercept)
	def setYAxisOnRight(self, b = 1) :
		_r("XYChart.setYAxisOnRight", self.this, b)
	def setXAxisOnTop(self, b = 1) :
		_r("XYChart.setXAxisOnTop", self.this, b)
	def xAxis(self) :
		return Axis(_r("XYChart.xAxis", self.this))
	def xAxis2(self) :
		return Axis(_r("XYChart.xAxis2", self.this))
	def swapXY(self, b = 1) :
		_r("XYChart.swapXY", self.this, b)	
	def setPlotArea(self, x, y, width, height, bgColor = Transparent, altBgColor = -1, 
		edgeColor = LineColor, hGridColor = 0xc0c0c0, vGridColor = Transparent) :
		return PlotArea(_r("XYChart.setPlotArea", self.this, 
			x, y, width, height, bgColor, altBgColor, edgeColor, hGridColor, vGridColor))
	def setClipping(self, margin = 0) :
		_r("XYChart.setClipping", self.this, margin)
	def addBarLayer(self, data = None, color = -1, name = "", depth = 0) :
		if data != None :
			return BarLayer(_r("XYChart.addBarLayer", self.this, data, color, name, depth))
		else :
			return self.addBarLayer2()
	def addBarLayer2(self, dataCombineMethod = Layer.Side, depth = 0) :
		return BarLayer(_r("XYChart.addBarLayer2", self.this, dataCombineMethod, depth))
	def addBarLayer3(self, data, colors = [], names = [], depth = 0) :
		return BarLayer(_r("XYChart.addBarLayer3", self.this, data, colors, names, depth))
	def addLineLayer(self, data = None, color = -1, name = "", depth = 0) :
		if data != None :
			return LineLayer(_r("XYChart.addLineLayer", self.this, data, color, name, depth))
		else :
			return self.addLineLayer2()
	def addLineLayer2(self, dataCombineMethod = Layer.Overlay, depth = 0) :
		return LineLayer(_r("XYChart.addLineLayer2", self.this, dataCombineMethod, depth))
	def addAreaLayer(self, data = None, color = -1, name = "", depth = 0) :
		if data != None :
			return AreaLayer(_r("XYChart.addAreaLayer", self.this, data, color, name, depth))
		else :
			return self.addAreaLayer2()
	def addAreaLayer2(self, dataCombineMethod = Layer.Stack, depth = 0) :
		return AreaLayer(_r("XYChart.addAreaLayer2", self.this, dataCombineMethod, depth))
	def addHLOCLayer(self, highData = None, lowData = [], openData = [], closeData = [], color = -1) :
		if highData != None :
			return HLOCLayer(_r("XYChart.addHLOCLayer", self.this, highData, lowData, openData, closeData, color))
		else :
			return self.addHLOCLayer2()
	def addHLOCLayer2(self) :
		return HLOCLayer(_r("XYChart.addHLOCLayer2", self.this))
	def addScatterLayer(self, xData, yData, name = "", symbol = SquareSymbol, symbolSize = 5, fillColor = -1, edgeColor = -1) :
		return ScatterLayer(_r("XYChart.addScatterLayer", self.this, xData, yData, name, symbol, symbolSize, fillColor, edgeColor))
	def addCandleStickLayer(self, highData, lowData, openData, closeData, riseColor = 0xffffff, fallColor = 0x0, edgeColor = LineColor) :
		return CandleStickLayer(_r("XYChart.addCandleStickLayer", self.this, highData, lowData, openData, closeData, riseColor, fallColor, edgeColor))
	def addBoxWhiskerLayer(self, boxTop, boxBottom, maxData = [], minData = [], midData = [], fillColor = -1, whiskerColor = LineColor, edgeColor = LineColor) :
		return BoxWhiskerLayer(_r("XYChart.addBoxWhiskerLayer", self.this, boxTop, boxBottom, maxData, minData, midData, fillColor, whiskerColor, edgeColor))
	def addTrendLayer(self, data, color = -1, name = "", depth = 0) :
		return TrendLayer(_r("XYChart.addTrendLayer", self.this, data, color, name, depth))
	def addTrendLayer2(self, xData, yData, color = -1, name = "", depth = 0) :
		return TrendLayer(_r("XYChart.addTrendLayer2", self.this, xData, yData, color, name, depth))
	def addSplineLayer(self, data = [], color = -1, name = "") :
		return SplineLayer(_r("XYChart.addSplineLayer", self.this, data, color, name))
	def addStepLineLayer(self, data = [], color = -1, name = "") :
		return StepLineLayer(_r("XYChart.addStepLineLayer", self.this, data, color, name))
	def addInterLineLayer(self, line1, line2, color12, color21 = -1) :
		return InterLineLayer(_r("XYChart.addInterLineLayer", self.this, line1, line2, color12, color21))


#///////////////////////////////////////////////////////////////////////////////////
#//	bindings to polarchart.h
#///////////////////////////////////////////////////////////////////////////////////
class PolarLayer :
	defaultArgs = {
		"setData":(None, 3, -1, ""),
		"setSymbolScale":(None, 2, PixelScale),
		"getImageCoor":(None, 3, 0, 0),
		"getHTMLImageMap":(None, 5, "", "", 0, 0),
		"setDataLabelStyle":(TextBox, 4, "", 8, TextColor, 0),
		"addCustomDataLabel":(TextBox, 6, "", 8, TextColor, 0)
	}
	def __init__(self, this) :
		self.this = this
	def __getattr__(self, name) :
		if name[:2] == "__" :
			raise AttributeError 
		return MethodWrapper(self, name)
	def setDataSymbol(self, symbol, size = None, fillColor = -1, edgeColor = -1, lineWidth = 1) :
		if size == None :
			try :
				symbol = int(symbol)
				size = 7
			except :
				self.setDataSymbol2(symbol)
				return
		_r("PolarLayer.setDataSymbol", self.this, symbol, size, fillColor, edgeColor, lineWidth)
	def setDataSymbol2(self, image) :
		if hasattr(image, "this") :
			self.setDataSymbol3(image)
		_r("PolarLayer.setDataSymbol2", self.this, image)
	def setDataSymbol3(self, image) :
		_r("PolarLayer.setDataSymbol3", self.this, image.this)
	#
	#Methods handled by MethodWrapper
	#================================
	#setData, setAngles, setBorderColor, setLineWidth, setSymbolScale, getMaxR, getMinR
	#setImageMapWidth, getImageCoor, getHTMLImageMap, setDataLabelFormat, setDataLabelStyle, addCustomDataLabel
	#
	

class PolarAreaLayer(PolarLayer) :
	pass


class PolarLineLayer(PolarLayer) :
	defaultArgs = InheritedDictionary(PolarLayer.defaultArgs, {
		"setGapColor":(None, 2, -1)
	})
	#
	#Methods handled by MethodWrapper
	#================================
	#setCloseLoop, setGapColor
	#


class PolarSplineLineLayer(PolarLineLayer) :
	pass
	#
	#Methods handled by MethodWrapper
	#================================
	#setTension
	#


class PolarSplineAreaLayer(PolarAreaLayer) :
	pass
	#
	#Methods handled by MethodWrapper
	#================================
	#setTension
	#


class PolarChart(BaseChart) :
	defaultArgs = {
		"setPlotArea":(None, 6, Transparent, Transparent, 1),	
		"setGridColor":(None, 4, LineColor, 1, LineColor, 1),
		"setGridStyle":(None, 2, 1),
		"setStartAngle":(None, 2, 1),
		"angularAxis":(AngularAxis, 0),
		"radialAxis":(Axis, 0),	
		"addAreaLayer":(PolarAreaLayer, 3, -1, ""),
		"addLineLayer":(PolarLineLayer, 3, -1, ""),
		"addSplineLineLayer":(PolarSplineLineLayer, 3, -1, ""),
		"addSplineAreaLayer":(PolarSplineAreaLayer, 3, -1, ""),
	}
	def __init__(self, width, height, bgColor = BackgroundColor, edgeColor = Transparent, raisedEffect = 0) :
		self.this = _r("PolarChart.create", width, height, bgColor, edgeColor, raisedEffect)
	def __getattr__(self, name) :
		if name[:2] == "__" :
			raise AttributeError 
		return MethodWrapper(self, name)

	#
	#Methods handled by MethodWrapper
	#================================
	#setPlotArea, setGridColor, setGridStyle, setStartAngle, angularAxis, radialAxis, 
	#getXCoor, getYCoor, addExtraField, addAreaLayer, addLineLayer, addSplineLineLayer, addSplineAreaLayer
	#


#///////////////////////////////////////////////////////////////////////////////////
#//	bindings to chartdir.h
#///////////////////////////////////////////////////////////////////////////////////
def getCopyright() :
	return _r("getCopyright")

def getVersion() :
	return _r("getVersion")

def getDescription() :
	return _r("getDescription")

def getBootLog() :
	return _r("getBootLog")

def libgTTFTest(font = "", fontIndex = 0, fontHeight = 8, fontWidth = 8, angle = 0) :
	return _r("testFont", font, fontIndex, fontHeight, fontWidth, angle)

def testFont(font = "", fontIndex = 0, fontHeight = 8, fontWidth = 8, angle = 0) :
	return _r("testFont", font, fontIndex, fontHeight, fontWidth, angle)

def setLicenseCode(licCode) :
    return _r("setLicenseCode", licCode)

def chartTime(y, m = None, d = 1, h = 0, n = 0, s = 0) :
	if m == None :
		return chartTime2(y)
	else :
		return _r("chartTime", y, m, d, h, n, s)

def chartTime2(t) :
	return _r("chartTime2", t)


#///////////////////////////////////////////////////////////////////////////////////
#//	bindings to rantable.h
#///////////////////////////////////////////////////////////////////////////////////
class RanTable :
	defaultArgs = {
		"setCol2":(None, 6, -1E+308, 1E+308),
		"setDateCol":(None, 4, 0),
		"setHLOCCols":(None, 6, 0, 1E+308)
		}
	this = None
	def __init__(self, seed, noOfCols, noOfRows) :
		self.this = _r("RanTable.create", seed, noOfCols, noOfRows)
	def __del__(self) :
		if self.this != None :
			_r("RanTable.destroy", self.this)
	def __getattr__(self, name) :
		if name[:2] == "__" :
			raise AttributeError 
		return MethodWrapper(self, name)
	def setCol(self, colNo, minValue, maxValue, p4 = None, p5 = -1E+308, p6 = 1E+308) :
		if p4 == None :
			_r("RanTable.setCol", self.this, colNo, minValue, maxValue)
		else :
			self.setCol2(colNo, minValue, maxValue, p4, p5, p6)
	#
	#Methods handled by MethodWrapper
	#================================
	#setCol2, setDateCol, setHLOCCols, getCol
	#
	

#///////////////////////////////////////////////////////////////////////////////////
#//	bindings to datafilter.h
#///////////////////////////////////////////////////////////////////////////////////
class ArrayMathMethodWrapper(MethodWrapper) :
	def __call__(self, *args) :
		ret = apply(MethodWrapper.__call__, (self,) + args)
		if ret == self.obj.this :
			return self.obj
		else :
			return ret

class ArrayMath :
	defaultArgs = {
		"delta":(None, 1, 1),
		"trim":(None, 2, 0, -1),
		"insert":(None, 2, -1),
		"insert2":(None, 3, -1),
		"selectGTZ":(None, 2, [], 0),
		"selectGEZ":(None, 2, [], 0),
		"selectLTZ":(None, 2, [], 0),
		"selectLEZ":(None, 2, [], 0),
		"selectEQZ":(None, 2, [], 0),
		"selectNEZ":(None, 2, [], 0),
		"selectStartOfHour":(None, 2, 1, 300),
		"selectStartOfDay":(None, 2, 1, 3 * 3600),
		"selectStartOfWeek":(None, 2, 1, 2 * 86400),
		"selectStartOfMonth":(None, 2, 1, 5 * 86400),
		"selectStartOfYear":(None, 2, 1, 60 * 86400),
		"movCorr":(None, 2, []),
		"lowess":(None, 2, 0.25, 0),
		"lowess2":(None, 3, 0.25, 0)
		}
	this = None
	def __init__(self, a) :
		self.this = _r("ArrayMath.create", a)
	def __del__(self) :
		if self.this != None :
			_r("ArrayMath.destroy", self.this)
	def __getattr__(self, name) :
		if name[:2] == "__" :
			raise AttributeError 
		return ArrayMathMethodWrapper(self, name)
	def binOp(self, op, b) :
		if type(b) == type([]) or type(b) == type(()) :
			_r("ArrayMath." + op, self.this, b)
			return self
		else :
			return getattr(self, op + "2")(b)
	def add(self, b) :
		return self.binOp("add", b)
	def sub(self, b) :
		return self.binOp("sub", b)
	def mul(self, b) :
		return self.binOp("mul", b)
	def div(self, b) :
		return self.binOp("div", b)

	#
	#Methods handled by MethodWrapper
	#================================
	#add2, sub2, mul2, div2, delta, abs, acc
	#trim, insert, insert2, replace
	#selectGTZ, selectGEZ, selectLTZ, selectLEZ, selectEQZ, selectNEZ
	#selectStartOfHour, selectStartOfDay, selectStartOfWeek, selectStartOfMonth, selectStartOfYear
	#movAvg, expAvg, movMed, movPercentile, movMax, movMin, movStdDev, movCorr, lowess, lowess2
	#result, max, min, maxIndex, minIndex, avg, sum, med, percentile
	#


#///////////////////////////////////////////////////////////////////////////////////
#//	Utility functions
#///////////////////////////////////////////////////////////////////////////////////

#
#	Create a unique temporary file name and automatically removes old temporary files 
#
import os, time, string
def tmpFile(path = "/tmp/tmp_charts", lifeTime = 600) :
	#for compatibility with ChartDirector Ver 2.5
	return path + "/" + tmpFile2(path, lifeTime)

def tmpFile2(path, lifeTime) :
	#normalize the path and remove trailing slash
	path = string.replace(path, "\\", "/")
	if path[-1] == "/" :
		path = path[:-1]
	#
	#remove old temporary files
	#
	try :
		garbage = []
		currentTime = time.time()
		for p in os.listdir(path) :
			filename = "%s/%s" % (path, p)
			filestat = os.stat(filename)
			if abs(currentTime - filestat[9]) > lifeTime :
				garbage.append(filename)
		for p in garbage :
			os.unlink(p)
	except Exception, msg:
		#make the directory in case it does not exist
		fields = string.split(path, "/")
		if fields[0] == '' :
			fields[0:2] = ['/' + fields[1]]
		for i in range(0, len(fields)) :
			try :
				os.mkdir(string.join(fields[:i + 1], "/"), 0777)
			except :
				pass
	#
	#get unique file name. use Apache mod_perl environmental variable "UNIQUE_ID" if available, 
	#otherwise generate it ourselves.
	#
	if os.environ.has_key("UNIQUE_ID") :
		return os.environ["UNIQUE_ID"]
	else :
		return "%s%s%s%s" % (os.environ.get("REMOTE_ADDR", "localhost"), 
			os.environ.get("REMOTE_PORT", ""), os.getpid(), time.time())

#
#	Print in binary format
#
def binaryPrint(s) :
	import sys
	try :
	    #Make sure we use binary mode if we are running on windows
	    import msvcrt, os
	    msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
	except :
	    pass
	#use stdout instead of print because print will add an extra new line character at the end
	sys.stdout.write(s)