/*
|
* Copyright (C) 2012 Advanced Software Engineering Limited.
|
*
|
* This file is part of the ChartDirector software. Usage of this file is
|
* subjected to the ChartDirector license agreement. See the LICENSE.TXT
|
* file that comes with the ChartDirector software release, or visit
|
* Advanced Software Engineering's web site at www.advsofteng.com or
|
* email to support@advsofteng.com for information.
|
*
|
*/
|
|
#ifndef CCHARTDIR_HDR
|
#define CCHARTDIR_HDR
|
|
#include <string.h>
|
#include "bchartdir.h"
|
#include "memblock.h"
|
|
class AutoDestroy
|
{
|
public :
|
virtual ~AutoDestroy() {}
|
};
|
|
class GarbagePtr
|
{
|
private :
|
AutoDestroy *ptr;
|
public :
|
GarbagePtr(AutoDestroy *ptr, GarbagePtr *next) : ptr(ptr), next(next) {}
|
~GarbagePtr() { delete ptr; }
|
GarbagePtr *next;
|
};
|
|
class GarbageContainer
|
{
|
private :
|
GarbagePtr *root;
|
public :
|
GarbageContainer() : root(0) {}
|
virtual ~GarbageContainer() { while (0 != root) { GarbagePtr *temp = root; root = root->next; delete temp; } }
|
void reg(AutoDestroy *g) { root = new GarbagePtr(g, root); }
|
};
|
|
//
|
// Utility to convert from WCHAR string to UTF8 string
|
//
|
class WCHARtoUTF8
|
{
|
public :
|
WCHARtoUTF8(const wchar_t *w_string) : utf8_string(0)
|
{
|
if (0 == w_string)
|
utf8_string = 0;
|
else
|
{
|
int string_len = 0;
|
while (w_string[string_len]) ++string_len;
|
char *ptr = utf8_string = new char[string_len * 3 + 1];
|
for (int w = *w_string; w != 0; w = *(++w_string))
|
{
|
// only support 16 bit unicode
|
int uw = w & 0xffff;
|
if (uw < 0x80)
|
*(ptr++) = (char)uw;
|
else if (uw < 0x800)
|
{
|
*(ptr++) = (char)(0xC0 | (uw >> 6));
|
*(ptr++) = (char)(0x80 | (uw & 0x3F));
|
}
|
else
|
{
|
*(ptr++) = (char)(0xE0 | (uw >> 12));
|
*(ptr++) = (char)(0x80 | ((uw >> 6) & 0x3F));
|
*(ptr++) = (char)(0x80 | (uw & 0x3F));
|
}
|
}
|
*ptr = 0;
|
}
|
}
|
|
operator const char*()
|
{
|
return utf8_string;
|
}
|
|
~WCHARtoUTF8()
|
{
|
delete[] utf8_string;
|
}
|
|
private :
|
char *utf8_string;
|
|
//disable assignment
|
WCHARtoUTF8(const WCHARtoUTF8 &rhs);
|
WCHARtoUTF8 &operator=(const WCHARtoUTF8 &rhs);
|
};
|
|
//
|
// Utility to convert from UTF8 string to WCHAR string
|
//
|
class UTF8toWCHAR
|
{
|
public :
|
UTF8toWCHAR(const char *utf8_string) : w_string(0)
|
{
|
if (0 == utf8_string)
|
w_string = 0;
|
else
|
{
|
int string_len = 0;
|
while (utf8_string[string_len]) ++string_len;
|
wchar_t *ptr = w_string = new wchar_t[string_len + 1];
|
for (int i = 0; i < string_len; ++i)
|
{
|
int c = utf8_string[i];
|
if (((c & 0xf0) == 0xe0) && (i + 2 < string_len))
|
{
|
*ptr = (wchar_t)(((c & 0xf) << 12) | ((utf8_string[++i] & 0x3f) << 6));
|
*ptr = (*ptr) | (utf8_string[++i] & 0x3f);
|
++ptr;
|
}
|
else if (((c & 0xe0) == 0xc0) && (i + 1 < string_len))
|
*(ptr++) = (wchar_t)(((c & 0x1f) << 6) | ((utf8_string[++i] & 0x3f) << 6));
|
else
|
*(ptr++) = (wchar_t)c;
|
}
|
|
*ptr = 0;
|
}
|
}
|
|
operator const wchar_t*()
|
{
|
return w_string;
|
}
|
|
~UTF8toWCHAR()
|
{
|
delete[] w_string;
|
}
|
|
private :
|
wchar_t *w_string;
|
|
//disable assignment
|
UTF8toWCHAR(const UTF8toWCHAR &rhs);
|
UTF8toWCHAR &operator=(const UTF8toWCHAR &rhs);
|
};
|
|
///////////////////////////////////////////////////////////////////////////////////////
|
// constants
|
///////////////////////////////////////////////////////////////////////////////////////
|
|
namespace Chart
|
{
|
static const double NoValue = 1.7e308;
|
static const double LogTick = 1.6e308;
|
static const double LinearTick = 1.5e308;
|
static const double TickInc = 1.0e200;
|
static const double MinorTickOnly = -1.7e308;
|
static const double MicroTickOnly = -1.6e308;
|
enum { AutoGrid = -2 };
|
static const double TouchBar = -1.7E-100;
|
static const double DataBound = -1.7E-100;
|
|
enum Alignment
|
{
|
TopLeft = 7, TopCenter = 8, TopRight = 9,
|
Left = 4, Center = 5, Right = 6,
|
BottomLeft = 1, BottomCenter = 2, BottomRight = 3,
|
Top = TopCenter, Bottom = BottomCenter,
|
TopLeft2 = 10, TopRight2 = 11,
|
BottomLeft2 = 12, BottomRight2 = 13
|
};
|
|
enum
|
{
|
DashLine = 0x0505,
|
DotLine = 0x0202,
|
DotDashLine = 0x05050205,
|
AltDashLine = 0x0A050505
|
};
|
|
static const int goldGradient[] = {0, 0xFFE743, 0x60, 0xFFFFE0, 0xB0, 0xFFF0B0, 0x100, 0xFFE743};
|
static const int silverGradient[] = {0, 0xC8C8C8, 0x60, 0xF8F8F8, 0xB0, 0xE0E0E0, 0x100, 0xC8C8C8};
|
static const int redMetalGradient[] = {0, 0xE09898, 0x60, 0xFFF0F0, 0xB0, 0xF0D8D8, 0x100, 0xE09898};
|
static const int blueMetalGradient[] = {0, 0x9898E0, 0x60, 0xF0F0FF, 0xB0, 0xD8D8F0, 0x100, 0x9898E0};
|
static const int greenMetalGradient[] = {0, 0x98E098, 0x60, 0xF0FFF0, 0xB0, 0xD8F0D8, 0x100, 0x98E098};
|
|
static inline int metalColor(int c, int angle = 90) { return CChart_metalColor(c, angle); }
|
static inline int goldColor(int angle = 90) { return metalColor(0xffee44, angle); }
|
static inline int silverColor(int angle = 90) { return metalColor(0xdddddd, angle); }
|
|
static inline int brushedMetalColor(int c, int texture = 2, int angle = 90) { return metalColor(c, angle) | ((texture & 0x3) << 18); }
|
static inline int brushedSilverColor(int texture = 2, int angle = 90) {return brushedMetalColor(0xdddddd, texture, angle); }
|
static inline int brushedGoldColor(int texture = 2, int angle = 90) {return brushedMetalColor(0xffee44, texture, angle); }
|
|
enum AntiAliasMode { NoAntiAlias, AntiAlias, AutoAntiAlias, ClearType, CompatAntiAlias = 6 };
|
enum PaletteMode { TryPalette, ForcePalette, NoPalette };
|
enum DitherMethod { Quantize, OrderedDither, ErrorDiffusion };
|
|
enum CDFilterType { BoxFilter, LinearFilter, QuadraticFilter, BSplineFilter, HermiteFilter,
|
CatromFilter, MitchellFilter, SincFilter, LanczosFilter, GaussianFilter, HanningFilter,
|
HammingFilter, BlackmanFilter, BesselFilter };
|
|
enum
|
{
|
Transparent = 0xff000000,
|
Palette = 0xffff0000,
|
BackgroundColor = 0xffff0000,
|
LineColor = 0xffff0001,
|
TextColor = 0xffff0002,
|
DataColor = 0xffff0008,
|
SameAsMainColor = 0xffff0007
|
};
|
|
enum ImgFormat { PNG, GIF, JPG, WMP, BMP, SVG, SVGZ };
|
|
static const int oldDefaultPalette[] =
|
{
|
0xffffff, 0x000000, 0x000000, 0x808080,
|
0x808080, 0x808080, 0x808080, 0x808080,
|
0xff0000, 0x00ff00, 0x0000ff, 0xffff00,
|
0xff00ff, 0x66ffff, 0xffcc33, 0xcccccc,
|
0x9966ff, 0x339966, 0x999900, 0xcc3300,
|
0x99cccc, 0x006600, 0x660066, 0xcc9999,
|
-1
|
};
|
|
static const int 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
|
};
|
|
static const int 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
|
};
|
|
static const int transparentPalette[] =
|
{
|
0xffffff, 0x000000, 0x000000, 0x808080,
|
0x808080, 0x808080, 0x808080, 0x808080,
|
0x80ff0000, 0x8000ff00, 0x800000ff, 0x80ffff00,
|
0x80ff00ff, 0x8066ffff, 0x80ffcc33, 0x80cccccc,
|
0x809966ff, 0x80339966, 0x80999900, 0x80cc3300,
|
0x8099cccc, 0x80006600, 0x80660066, 0x80cc9999,
|
0x80ff9966, 0x8099ff99, 0x809999ff, 0x80cc6600,
|
0x8033cc33, 0x80cc99ff, 0x80ff6666, 0x8099cc66,
|
0x80009999, 0x80cc3333, 0x809933ff, 0x80ff0000,
|
0x800000ff, 0x8000ff00, 0x80ffcc99, 0x80999999,
|
-1
|
};
|
|
enum { SideLayout, CircleLayout };
|
|
enum
|
{
|
DefaultShading = 0,
|
FlatShading = 1,
|
LocalGradientShading = 2,
|
GlobalGradientShading = 3,
|
ConcaveShading = 4,
|
RoundedEdgeNoGlareShading = 5,
|
RoundedEdgeShading = 6,
|
RadialShading = 7,
|
RingShading = 8
|
};
|
|
enum SymbolType
|
{
|
NoSymbol = 0,
|
SquareSymbol = 1,
|
DiamondSymbol = 2,
|
TriangleSymbol = 3,
|
RightTriangleSymbol = 4,
|
LeftTriangleSymbol = 5,
|
InvertedTriangleSymbol = 6,
|
CircleSymbol = 7,
|
CrossSymbol = 8,
|
Cross2Symbol = 9,
|
ChartDir_PolygonSymbol = 11,
|
ChartDir_Polygon2Symbol = 12,
|
ChartDir_StarSymbol = 13,
|
ChartDir_CustomSymbol = 14
|
};
|
|
enum
|
{
|
NoShape = 0,
|
SquareShape = 1,
|
DiamondShape = 2,
|
TriangleShape = 3,
|
RightTriangleShape = 4,
|
LeftTriangleShape = 5,
|
InvertedTriangleShape = 6,
|
CircleShape = 7,
|
CircleShapeNoShading = 10,
|
GlassSphereShape = 15,
|
GlassSphere2Shape = 16,
|
SolidSphereShape = 17
|
};
|
|
static inline int CrossShape(double width = 0.5)
|
{ return CrossSymbol | (((int)(((width < 0) ? 0 : ((width > 1) ? 1 : width)) * 4095 + 0.5)) << 12); }
|
static inline int Cross2Shape(double width = 0.5)
|
{ return Cross2Symbol | (((int)(((width < 0) ? 0 : ((width > 1) ? 1 : width)) * 4095 + 0.5)) << 12); }
|
static inline int PolygonShape(int side)
|
{ return ChartDir_PolygonSymbol | (((side < 0) ? 0 : ((side > 100) ? 100 : side)) << 12); }
|
static inline int Polygon2Shape(int side)
|
{ return ChartDir_Polygon2Symbol | (((side < 0) ? 0 : ((side > 100) ? 100 : side)) << 12); }
|
static inline int StarShape(int side)
|
{ return ChartDir_StarSymbol | (((side < 0) ? 0 : ((side > 100) ? 100 : side)) << 12); }
|
|
enum DataCombineMethod { Overlay, Stack, Depth, Side, Percentage };
|
|
enum LegendMode { NormalLegend, ReverseLegend, NoLegend };
|
|
enum ScaleType { PixelScale, XAxisScale, YAxisScale, EndPoints,
|
AngularAxisScale = XAxisScale, RadialAxisScale = YAxisScale };
|
|
enum
|
{
|
MonotonicNone = 0,
|
MonotonicX = 1,
|
MonotonicY = 2,
|
MonotonicXY = 3,
|
MonotonicAuto = 4
|
};
|
|
enum
|
{
|
ConstrainedLinearRegression = 0,
|
LinearRegression = 1,
|
ExponentialRegression = -1,
|
LogarithmicRegression = -2
|
};
|
|
static inline int PolynomialRegression(int n) { return n; }
|
|
enum { HLOCDefault, HLOCOpenClose, HLOCUpDown };
|
|
enum { DiamondPointer, TriangularPointer, ArrowPointer, ArrowPointer2, LinePointer, PencilPointer };
|
|
enum
|
{
|
SmoothShading = 0,
|
TriangularShading = 1,
|
RectangularShading = 2,
|
TriangularFrame = 3,
|
RectangularFrame = 4
|
};
|
|
enum
|
{
|
ChartBackZ = 0x100,
|
ChartFrontZ = 0xffff,
|
PlotAreaZ = 0x1000,
|
GridLinesZ = 0x2000
|
};
|
|
enum
|
{
|
XAxisSymmetric = 1,
|
XAxisSymmetricIfNeeded = 2,
|
YAxisSymmetric = 4,
|
YAxisSymmetricIfNeeded = 8,
|
XYAxisSymmetric = 16,
|
XYAxisSymmetricIfNeeded = 32
|
};
|
|
enum
|
{
|
XAxisAtOrigin = 1,
|
YAxisAtOrigin = 2,
|
XYAxisAtOrigin = 3
|
};
|
|
enum
|
{
|
ChartDir_StartOfHourFilterTag = 1,
|
ChartDir_StartOfDayFilterTag = 2,
|
ChartDir_StartOfWeekFilterTag = 3,
|
ChartDir_StartOfMonthFilterTag = 4,
|
ChartDir_StartOfYearFilterTag = 5,
|
ChartDir_RegularSpacingFilterTag = 6,
|
ChartDir_AllPassFilterTag = 7,
|
ChartDir_NonePassFilterTag = 8,
|
ChartDir_SelectItemFilterTag = 9
|
};
|
|
static inline int StartOfHourFilter(int labelStep = 1, double initialMargin = 0.05)
|
{ return CChart_encodeFilter(ChartDir_StartOfHourFilterTag, labelStep, initialMargin); }
|
static inline int StartOfDayFilter(int labelStep = 1, double initialMargin = 0.05)
|
{ return CChart_encodeFilter(ChartDir_StartOfDayFilterTag, labelStep, initialMargin); }
|
static inline int StartOfWeekFilter(int labelStep = 1, double initialMargin = 0.05)
|
{ return CChart_encodeFilter(ChartDir_StartOfWeekFilterTag, labelStep, initialMargin); }
|
static inline int StartOfMonthFilter(int labelStep = 1, double initialMargin = 0.05)
|
{ return CChart_encodeFilter(ChartDir_StartOfMonthFilterTag, labelStep, initialMargin); }
|
static inline int StartOfYearFilter(int labelStep = 1, double initialMargin = 0.05)
|
{ return CChart_encodeFilter(ChartDir_StartOfYearFilterTag, labelStep, initialMargin); }
|
static inline int RegularSpacingFilter(int labelStep = 1, int initialMargin = 0)
|
{ return CChart_encodeFilter(ChartDir_RegularSpacingFilterTag, labelStep, initialMargin / 4095.0); }
|
static inline int AllPassFilter()
|
{ return CChart_encodeFilter(ChartDir_AllPassFilterTag, 0, 0); }
|
static inline int NonePassFilter()
|
{ return CChart_encodeFilter(ChartDir_NonePassFilterTag, 0, 0); }
|
static inline int SelectItemFilter(int item)
|
{ return CChart_encodeFilter(ChartDir_SelectItemFilterTag, item, 0); }
|
|
static inline int getVersion() { return CChart_getVersion(); }
|
static inline const char *getDescription() { return CChart_getDescription(); }
|
static inline const char *getCopyright() { return CChart_getCopyright(); }
|
static inline void getBootLog(char *buffer) { CChart_getBootLog(buffer); }
|
|
static inline bool testFont(const char *font, int fontIndex, double fontHeight,
|
double fontWidth, double angle, char *buffer)
|
{ return CChart_testFont(font, fontIndex, fontHeight, fontWidth, angle, buffer); }
|
|
static inline bool isLicensed() { return CChart_isLicensed(); }
|
static inline bool getLicenseAttr(const char *key, char *buffer)
|
{ return CChart_getLicenseAttr(key, buffer); }
|
static inline bool setLicenseFile(const char *filename = 0, char *buffer = 0)
|
{ return CChart_setLicenseFile(filename, buffer); }
|
static inline bool setLicenseCode(const char *licCode, char *buffer = 0)
|
{ return CChart_setLicenseCode(licCode, buffer); }
|
|
static inline double chartTime(int y, int m, int d, int h = 0, int n = 0, int s = 0)
|
{ return CChart_chartTime(y, m, d, h, n, s); }
|
static inline double chartTime2(int t) { return CChart_chartTime2(t); }
|
static inline int getChartYMD(double t) { return CChart_getChartYMD(t); }
|
static inline int getChartWeekDay(double t) { return ((int)(t / 86400 + 1)) % 7; }
|
|
enum
|
{
|
NormalGlare = 3,
|
ReducedGlare = 2,
|
NoGlare = 1
|
};
|
|
static inline int glassEffect(int glareSize = Chart::NormalGlare, int glareDirection = Chart::Top,
|
int raisedEffect = 5)
|
{ return CChart_glassEffect(glareSize, glareDirection, raisedEffect); }
|
static inline int softLighting(int direction = Chart::Top, int raisedEffect = 4)
|
{ return CChart_softLighting(direction, raisedEffect); }
|
static inline int barLighting(double startBrightness = 0.75, double endBrightness = 1.5)
|
{ return CChart_barLighting(startBrightness, endBrightness); }
|
static inline int cylinderEffect(int orientation = Chart::Center, double ambientIntensity = 0.5,
|
double diffuseIntensity = 0.5, double specularIntensity = 0.75, int shininess = 8)
|
{ return CChart_cylinderEffect(orientation, ambientIntensity, diffuseIntensity, specularIntensity, shininess); }
|
|
enum
|
{
|
AggregateSum = 0,
|
AggregateAvg = 1,
|
AggregateStdDev = 2,
|
AggregateMin = 3,
|
AggregateMed = 4,
|
AggregateMax = 5,
|
AggregatePercentile = 6,
|
AggregateFirst = 7,
|
AggregateLast = 8,
|
AggregateCount = 9
|
};
|
|
enum
|
{
|
DirectionHorizontal = 0,
|
DirectionVertical = 1,
|
DirectionHorizontalVertical = 2
|
};
|
|
//
|
// Ver 5.1
|
//
|
static inline double bSearch(DoubleArray a, double v)
|
{ return CChart_bSearch(a.data, a.len, v); }
|
static inline int ClearTypeMono(double gamma = 0)
|
{ return CChart_ClearTypeMono(gamma); }
|
static inline int ClearTypeColor(double gamma = 0)
|
{ return CChart_ClearTypeColor(gamma); }
|
static inline int phongLighting(double ambientIntensity = 0.5, double diffuseIntensity = 0.5,
|
double specularIntensity = 0.75, int shininess = 8)
|
{ return CChart_phongLighting(ambientIntensity, diffuseIntensity, specularIntensity, shininess); }
|
|
} //namespace Chart
|
|
|
///////////////////////////////////////////////////////////////////////////////////////
|
// Class wrappers
|
///////////////////////////////////////////////////////////////////////////////////////
|
|
class TTFText
|
{
|
private :
|
//disable copying
|
TTFText(const TTFText &rhs);
|
TTFText &operator=(const TTFText &rhs);
|
|
TTFTextInternal *ptr;
|
|
public :
|
//obsoleted - for compatibility only
|
enum AntiAliasMode { NoAntiAlias, AntiAlias, AutoAntiAlias };
|
//obsoleted - for compatibility only
|
static void destroy(TTFText *t) { t->destroy(); }
|
|
TTFText(TTFTextInternal *ptr) : ptr(ptr) {}
|
~TTFText() { CTTFText_destroy(ptr); }
|
void destroy() { delete this; }
|
|
int getWidth() const { return CTTFText_getWidth(ptr); }
|
int getHeight() const { return CTTFText_getHeight(ptr); }
|
int getLineHeight() const { return CTTFText_getLineHeight(ptr); }
|
int getLineDistance() const { return CTTFText_getLineDistance(ptr); }
|
|
void draw(int x, int y, int color, int alignment = Chart::TopLeft) const
|
{ CTTFText_draw(ptr, x, y, color, alignment); }
|
};
|
|
|
class DrawArea : public AutoDestroy
|
{
|
private :
|
//disable copying
|
DrawArea(const DrawArea &rhs);
|
DrawArea &operator=(const DrawArea &rhs);
|
|
DrawAreaInternal *ptr;
|
bool own_this;
|
|
public :
|
//obsoleted constants - for compatibility only
|
enum PaletteMode { TryPalette, ForcePalette, NoPalette };
|
//obsoleted constants - for compatibility only
|
enum DitherMethod { Quantize, OrderedDither, ErrorDiffusion };
|
|
DrawArea() : ptr(CDrawArea_create()), own_this(true) {}
|
static DrawArea* create() { return new DrawArea(); }
|
DrawArea(DrawAreaInternal *ptr) : ptr(ptr), own_this(false) {}
|
~DrawArea() { if (own_this) CDrawArea_destroy(ptr); }
|
void destroy() { delete this; }
|
DrawAreaInternal *getInternalPtr() { return ptr; }
|
const DrawAreaInternal *getInternalPtr() const { return ptr; }
|
|
void enableVectorOutput() { CDrawArea_enableVectorOutput(ptr); }
|
|
void setSize(int width, int height, int bgColor = 0xffffff)
|
{ CDrawArea_setSize(ptr, width, height, bgColor); }
|
void resize(int newWidth, int newHeight, int filter = Chart::LinearFilter, double blur = 1)
|
{ CDrawArea_resize(ptr, newWidth, newHeight, filter, blur); }
|
int getWidth() const { return CDrawArea_getWidth(ptr); }
|
int getHeight() const { return CDrawArea_getHeight(ptr); }
|
void setClipRect(int left, int top, int right, int bottom)
|
{ CDrawArea_setClipRect(ptr, left, top, right, bottom); }
|
void setBgColor(int c) { CDrawArea_setBgColor(ptr, c); }
|
|
void move(double xOffset, double yOffset, int bgColor = 0xffffff, int filter = Chart::LinearFilter,
|
double blur = 1) { CDrawArea_move(ptr, xOffset, yOffset, bgColor, filter, blur); }
|
void rotate(double angle, int bgColor = 0xffffff, double cx = -1, double cy = -1,
|
int filter = Chart::LinearFilter, double blur = 1)
|
{ CDrawArea_rotate(ptr, angle, bgColor, cx, cy, filter, blur); }
|
void hFlip() { CDrawArea_hFlip(ptr); }
|
void vFlip() { CDrawArea_vFlip(ptr); }
|
void clone(DrawArea *d, int x, int y, int align, int newWidth = -1, int newHeight = -1,
|
int filter = Chart::LinearFilter, double blur = 1) const
|
{ CDrawArea_clone(ptr, d->ptr, x, y, align, newWidth, newHeight, filter, blur); }
|
|
void pixel(int x, int y, int c) { CDrawArea_pixel(ptr, x, y, c); }
|
int getPixel(int x, int y) const { return CDrawArea_getPixel(ptr, x, y); }
|
|
void hline(int x1, int x2, int y, int c) { CDrawArea_hline(ptr, x1, x2, y, c); }
|
void vline(int y1, int y2, int x, int c) { CDrawArea_vline(ptr, y1, y2, x, c); }
|
void line(double x1, double y1, double x2, double y2, int c, int lineWidth = 1)
|
{ CDrawArea_line(ptr, x1, y1, x2, y2, c, lineWidth); }
|
void arc(int cx, int cy, int rx, int ry, double a1, double a2, int c)
|
{ CDrawArea_arc(ptr, cx, cy, rx, ry, a1, a2, c); }
|
|
void rect(int x1, int y1, int x2, int y2, int edgeColor, int fillColor, int raisedEffect = 0)
|
{ CDrawArea_rect(ptr, x1, y1, x2, y2, edgeColor, fillColor, raisedEffect); }
|
void polygon(const int *x, const int *y, int noOfPoints, int edgeColor, int fillColor)
|
{ polygon(IntArray(x, noOfPoints), IntArray(y, noOfPoints), edgeColor, fillColor); }
|
void polygon(IntArray x, IntArray y, int edgeColor, int fillColor)
|
{ CDrawArea_polygon2(ptr, x.data, x.len, y.data, y.len, edgeColor, fillColor); }
|
void polygon(DoubleArray x, DoubleArray y, int edgeColor, int fillColor)
|
{ CDrawArea_polygon(ptr, x.data, x.len, y.data, y.len, edgeColor, fillColor); }
|
void surface(double x1, double y1, double x2, double y2, int depthX, int depthY,
|
int edgeColor, int fillColor)
|
{ CDrawArea_surface(ptr, x1, y1, x2, y2, depthX, depthY, edgeColor, fillColor); }
|
void sector(int cx, int cy, int rx, int ry, double a1, double a2, int edgeColor, int fillColor)
|
{ CDrawArea_sector(ptr, cx, cy, rx, ry, a1, a2, edgeColor, fillColor); }
|
void cylinder(int cx, int cy, int rx, int ry, double a1, double a2,
|
int depthX, int depthY, int edgeColor, int fillColor)
|
{ CDrawArea_cylinder(ptr, cx, cy, rx, ry, a1, a2, depthX, depthY, edgeColor, fillColor); }
|
void circle(int cx, int cy, int rx, int ry, int edgeColor, int fillColor)
|
{ CDrawArea_circle(ptr, cx, cy, rx, ry, edgeColor, fillColor); }
|
void ringSector(int cx, int cy, int rx, int ry, int rx2, int ry2,
|
double a1, double a2, int edgeColor, int fillColor)
|
{ CDrawArea_ringSector(ptr, cx, cy, rx, ry, rx2, ry2, a1, a2, edgeColor, fillColor); }
|
void ring(int cx, int cy, int rx, int ry, int rx2, int ry2, int edgeColor, int fillColor)
|
{ CDrawArea_ring(ptr, cx, cy, rx, ry, rx2, ry2, edgeColor, fillColor); }
|
|
void fill(int x, int y, int color) { CDrawArea_fill(ptr, x, y, color); }
|
void fill(int x, int y, int color, int borderColor) { CDrawArea_fill2(ptr, x, y, color, borderColor); }
|
|
void text(const char *str, const char *font, double fontSize,
|
int x, int y, int color)
|
{ CDrawArea_text(ptr, str, font, fontSize, x, y, color); }
|
void text(const wchar_t *str, const char *font, double fontSize,
|
int x, int y, int color)
|
{ CDrawArea_textw(ptr, str, font, fontSize, x, y, color); }
|
void text(const char *str, const char *font, int fontIndex, double fontHeight, double fontWidth,
|
double angle, bool vertical, int x, int y, int color, int alignment = Chart::TopLeft)
|
{ CDrawArea_text2(ptr, str, font, fontIndex, fontHeight, fontWidth, angle, vertical, x, y, color, alignment); }
|
void text(const wchar_t *str, const char *font, int fontIndex, double fontHeight, double fontWidth,
|
double angle, bool vertical, int x, int y, int color, int alignment = Chart::TopLeft)
|
{ CDrawArea_text2w(ptr, str, font, fontIndex, fontHeight, fontWidth, angle, vertical, x, y, color, alignment); }
|
TTFText* text(const char *str, const char *font, double fontSize)
|
{ return new TTFText(CDrawArea_text3(ptr, str, font, fontSize)); }
|
TTFText* text(const wchar_t *str, const char *font, double fontSize)
|
{ return new TTFText(CDrawArea_text3w(ptr, str, font, fontSize)); }
|
TTFText* text(const wchar_t *text, const char *font, int fontIndex,
|
double fontHeight, double fontWidth, double angle, bool vertical)
|
{ return new TTFText(CDrawArea_text4w(ptr, text, font, fontIndex, fontHeight, fontWidth, angle, vertical)); }
|
TTFText* text(const char *text, const char *font, int fontIndex,
|
double fontHeight, double fontWidth, double angle, bool vertical)
|
{ return new TTFText(CDrawArea_text4(ptr, text, font, fontIndex, fontHeight, fontWidth, angle, vertical)); }
|
void close(TTFText *text) { delete text; }
|
|
void merge(const DrawArea *d, int x, int y, int align, int transparency)
|
{ CDrawArea_merge(ptr, d->ptr, x, y, align, transparency); }
|
void tile(const DrawArea *d, int transparency)
|
{ CDrawArea_tile(ptr, d->ptr, transparency); }
|
|
void setSearchPath(const char *path) { CDrawArea_setSearchPath(ptr, path); }
|
bool loadGIF(const char *filename) { return CDrawArea_loadGIF(ptr, filename); }
|
bool loadPNG(const char *filename) { return CDrawArea_loadPNG(ptr, filename); }
|
bool loadJPG(const char *filename) { return CDrawArea_loadJPG(ptr, filename); }
|
bool loadWMP(const char *filename) { return CDrawArea_loadWMP(ptr, filename); }
|
bool load(const char *filename) { return CDrawArea_load(ptr, filename); }
|
|
void rAffineTransform(double a, double b, double c, double d, double e, double f,
|
int bgColor = 0xffffff, int filter = Chart::LinearFilter, double blur = 1)
|
{ CDrawArea_rAffineTransform(ptr, a, b, c, d, e, f, bgColor, filter, blur); }
|
void affineTransform(double a, double b, double c, double d, double e, double f,
|
int bgColor = 0xffffff, int filter = Chart::LinearFilter, double blur = 1)
|
{ CDrawArea_affineTransform(ptr, a, b, c, d, e, f, bgColor, filter, blur); }
|
void sphereTransform(int xDiameter, int yDiameter, int bgColor = 0xffffff,
|
int filter = Chart::LinearFilter, double blur = 1)
|
{ CDrawArea_sphereTransform(ptr, xDiameter, yDiameter, bgColor, filter, blur); }
|
void hCylinderTransform(int yDiameter, int bgColor = 0xffffff,
|
int filter = Chart::LinearFilter, double blur = 1)
|
{ CDrawArea_hCylinderTransform(ptr, yDiameter, bgColor, filter, blur); }
|
void vCylinderTransform(int xDiameter, int bgColor = 0xffffff,
|
int filter = Chart::LinearFilter, double blur = 1)
|
{ CDrawArea_vCylinderTransform(ptr, xDiameter, bgColor, filter, blur); }
|
void vTriangleTransform(int tHeight = -1, int bgColor = 0xffffff,
|
int filter = Chart::LinearFilter, double blur = 1)
|
{ CDrawArea_vTriangleTransform(ptr, tHeight, bgColor, filter, blur); }
|
void hTriangleTransform(int tWidth = -1, int bgColor = 0xffffff,
|
int filter = Chart::LinearFilter, double blur = 1)
|
{ CDrawArea_hTriangleTransform(ptr, tWidth, bgColor, filter, blur); }
|
void shearTransform(double xShear, double yShear = 0, int bgColor = 0xffffff,
|
int filter = Chart::LinearFilter, double blur = 1)
|
{ CDrawArea_shearTransform(ptr, xShear, yShear, bgColor, filter, blur); }
|
void waveTransform(int period, double amplitude, double direction = 0,
|
double startAngle = 0, bool longitudinal = false, int bgColor = 0xffffff,
|
int filter = Chart::LinearFilter, double blur = 1)
|
{ CDrawArea_waveTransform(ptr, period, amplitude, direction, startAngle, longitudinal, bgColor, filter, blur); }
|
|
bool out(const char *filename) { return CDrawArea_out(ptr, filename); }
|
|
bool outGIF(const char *filename) { return CDrawArea_outGIF(ptr, filename); }
|
bool outPNG(const char *filename) { return CDrawArea_outPNG(ptr, filename); }
|
bool outJPG(const char *filename, int quality = 80) { return CDrawArea_outJPG(ptr, filename, quality); }
|
bool outWMP(const char *filename) { return CDrawArea_outWMP(ptr, filename); }
|
bool outBMP(const char *filename) { return CDrawArea_outBMP(ptr, filename); }
|
bool outSVG(const char *filename, const char *options = 0) { return CDrawArea_outSVG(ptr, filename, options); }
|
|
bool outGIF(const char **data, int *len) { return CDrawArea_outGIF2(ptr, data, len); }
|
bool outPNG(const char **data, int *len) { return CDrawArea_outPNG2(ptr, data, len); }
|
bool outJPG(const char **data, int *len, int quality = 80) { return CDrawArea_outJPG2(ptr, data, len, quality); }
|
bool outWMP(const char **data, int *len) { return CDrawArea_outWMP2(ptr, data, len); }
|
bool outBMP(const char **data, int *len) { return CDrawArea_outBMP2(ptr, data, len); }
|
|
MemBlock outGIF() { const char *data; int len; outGIF(&data, &len); return MemBlock(data, len); }
|
MemBlock outPNG() { const char *data; int len; outPNG(&data, &len); return MemBlock(data, len); }
|
MemBlock outJPG(int quality = 80) { const char *data; int len; outJPG(&data, &len, quality); return MemBlock(data, len); }
|
MemBlock outWMP() { const char *data; int len; outWMP(&data, &len); return MemBlock(data, len); }
|
MemBlock outBMP() { const char *data; int len; outBMP(&data, &len); return MemBlock(data, len); }
|
MemBlock outSVG2(const char *options = 0)
|
{ const char *data; int len; CDrawArea_outSVG2(ptr, &data, &len, options); return MemBlock(data, len); }
|
MemBlock outSVG() { return outSVG2(); }
|
|
void setPaletteMode(int p) { CDrawArea_setPaletteMode(ptr, p); }
|
void setDitherMethod(int m) { CDrawArea_setDitherMethod(ptr, m); }
|
void setTransparentColor(int c) { CDrawArea_setTransparentColor(ptr, c); }
|
void setAntiAliasText(int a) { CDrawArea_setAntiAliasText(ptr, a); }
|
void setAntiAlias(bool shapeAntiAlias = true, int textAntiAlias = Chart::AutoAntiAlias)
|
{ CDrawArea_setAntiAlias(ptr, shapeAntiAlias, textAntiAlias); }
|
void setInterlace(bool i) { CDrawArea_setInterlace(ptr, i); }
|
|
void setColorTable(const int *colors, int noOfColors, int offset)
|
{ CDrawArea_setColorTable(ptr, colors, noOfColors, offset); }
|
void setColorTable(IntArray colors, int offset)
|
{ setColorTable(colors.data, colors.len, offset); }
|
int getARGBColor(int c) { return CDrawArea_getARGBColor(ptr, c); }
|
int halfColor(int c) { return CDrawArea_halfColor(ptr, c); }
|
int adjustBrightness(int c, double brightness) { return CDrawArea_adjustBrightness(ptr, c, brightness); }
|
|
int dashLineColor(int color, int patternCode = Chart::DashLine)
|
{ return CDrawArea_dashLineColor(ptr, color, patternCode); }
|
int patternColor(const int *c, int w, int h, int startX = 0, int startY = 0)
|
{ return patternColor(IntArray(c, w * h), startX, startY); }
|
int patternColor(IntArray colorArray, int height, int startX = 0, int startY = 0)
|
{ return CDrawArea_patternColor(ptr, colorArray.data, colorArray.len, height, startX, startY); }
|
int patternColor(const char *filename, int startX = 0, int startY = 0)
|
{ return CDrawArea_patternColor2(ptr, filename, startX, startY); }
|
int gradientColor(int startX, int startY, int endX, int endY, int startColor, int endColor)
|
{ return CDrawArea_gradientColor(ptr, startX, startY, endX, endY, startColor, endColor); }
|
int gradientColor(IntArray colorArray, double angle = 90, double scale = 1.0, int startX = 0, int startY = 0)
|
{ return CDrawArea_gradientColor2(ptr, colorArray.data, colorArray.len, angle, scale, startX, startY); }
|
int gradientColor(const int *c, double angle = 90, double scale = 1, int startX = 0, int startY = 0)
|
{ return CDrawArea_gradientColor2a(ptr, c, angle, scale, startX, startY); }
|
int linearGradientColor(int startX, int startY, int endX, int endY, int startColor, int endColor, bool periodic = false)
|
{ return CDrawArea_linearGradientColor(ptr, startX, startY, endX, endY, startColor, endColor, periodic); }
|
int linearGradientColor(int startX, int startY, int endX, int endY, IntArray c, bool periodic = false)
|
{ return CDrawArea_linearGradientColor2(ptr, startX, startY, endX, endY, c.data, c.len, periodic); }
|
int radialGradientColor(int cx, int cy, int rx, int ry, int startColor, int endColor, bool periodic = false)
|
{ return CDrawArea_radialGradientColor(ptr, cx, cy, rx, ry, startColor, endColor, periodic); }
|
int radialGradientColor(int cx, int cy, int rx, int ry, IntArray c, bool periodic = false)
|
{ return CDrawArea_radialGradientColor2(ptr, cx, cy, rx, ry, c.data, c.len, periodic); }
|
|
int reduceColors(int colorCount, bool blackAndWhite = false)
|
{ return CDrawArea_reduceColors(ptr, colorCount, blackAndWhite); }
|
|
void setDefaultFonts(const char *normal, const char *bold = 0, const char *italic = 0,
|
const char *boldItalic = 0)
|
{ CDrawArea_setDefaultFonts(ptr, normal, bold, italic, boldItalic); }
|
void setFontTable(int index, const char *font)
|
{ CDrawArea_setFontTable(ptr, index, font); }
|
|
//
|
// Ver 5.1
|
//
|
void initDynamicLayer()
|
{ CDrawArea_initDynamicLayer(ptr); }
|
void removeDynamicLayer(bool keepOriginal = false)
|
{ CDrawArea_removeDynamicLayer(ptr, keepOriginal); }
|
};
|
|
|
class DrawObj : public AutoDestroy
|
{
|
private :
|
//disable copying
|
DrawObj(const DrawObj &rhs);
|
DrawObj &operator=(const DrawObj &rhs);
|
|
DrawObjInternal *ptr;
|
|
public :
|
DrawObj(DrawObjInternal *ptr) : ptr(ptr) {}
|
void destroy() { delete this; }
|
DrawObjInternal *getInternalPtr() { return ptr; }
|
|
void setZOrder(int z) { CDrawObj_setZOrder(ptr, z); }
|
void paint(DrawArea *d) { CDrawObj_paint(ptr, d->getInternalPtr()); }
|
};
|
|
|
class Box : public DrawObj
|
{
|
private :
|
//disable copying
|
Box(const Box &rhs);
|
Box &operator=(const Box &rhs);
|
|
BoxInternal *ptr;
|
|
public :
|
Box(BoxInternal *ptr) : DrawObj(Box2DrawObj(ptr)), ptr(ptr) {}
|
~Box() {}
|
|
void setPos(int x, int y) { CBox_setPos(ptr, x, y); }
|
void setSize(int w, int h) { CBox_setSize(ptr, w, h); }
|
void setBackground(int color, int edgeColor = -1, int raisedEffect = 0)
|
{ CBox_setBackground(ptr, color, edgeColor, raisedEffect); }
|
void setRoundedCorners(int r1 = 10, int r2 = -1, int r3 = -1, int r4 = -1)
|
{ CBox_setRoundedCorners(ptr, r1, r2, r3, r4); }
|
int getLeftX() const { return CBox_getLeftX(ptr); }
|
int getTopY() const { return CBox_getTopY(ptr); }
|
int getWidth() const { return CBox_getWidth(ptr); }
|
int getHeight() const { return CBox_getHeight(ptr); }
|
const char *getImageCoor(int offsetX = 0, int offsetY = 0)
|
{ return CBox_getImageCoor(ptr, offsetX, offsetY); }
|
};
|
|
|
class TextBox : public Box
|
{
|
private :
|
//disable copying
|
TextBox(const TextBox &rhs);
|
TextBox &operator=(const TextBox &rhs);
|
|
TextBoxInternal *ptr;
|
|
public :
|
TextBox(TextBoxInternal *ptr) : Box(TextBox2Box(ptr)), ptr(ptr) {}
|
~TextBox() {}
|
|
void setText(const char *text) { CTextBox_setText(ptr, text); }
|
void setAlignment(int a) { CTextBox_setAlignment(ptr, a); }
|
void setFontStyle(const char *font, int fontIndex = 0)
|
{ CTextBox_setFontStyle(ptr, font, fontIndex); }
|
void setFontSize(double fontHeight, double fontWidth = 0)
|
{ CTextBox_setFontSize(ptr, fontHeight, fontWidth); }
|
void setFontAngle(double angle, bool vertical = false)
|
{ CTextBox_setFontAngle(ptr, angle, vertical); }
|
void setFontColor(int color) { CTextBox_setFontColor(ptr, color); }
|
void setMargin(int m) { CTextBox_setMargin(ptr, m); }
|
void setMargin(int leftMargin, int rightMargin, int topMargin, int bottomMargin)
|
{ CTextBox_setMargin2(ptr, leftMargin, rightMargin, topMargin, bottomMargin); }
|
void setWidth(int width) { CTextBox_setWidth(ptr, width); }
|
void setHeight(int height) { CTextBox_setHeight(ptr, height); }
|
void setMaxWidth(int maxWidth) { CTextBox_setMaxWidth(ptr, maxWidth); }
|
void setTruncate(int maxWidth, int maxLines = 1)
|
{ CTextBox_setTruncate(ptr, maxWidth, maxLines); }
|
};
|
|
|
//for compatibility with ChartDirector Ver 1.5 C++ code
|
typedef TextBox TextStyle;
|
|
|
class Line : public DrawObj
|
{
|
private :
|
//disable copying
|
Line(const Line &rhs);
|
Line &operator=(const Line &rhs);
|
|
LineInternal *ptr;
|
|
public :
|
Line(LineInternal *ptr) : DrawObj(Line2DrawObj(ptr)), ptr(ptr) {}
|
~Line() {}
|
|
void setPos(int x1, int y1, int x2, int y2) { CLine_setPos(ptr, x1, y1, x2, y2); }
|
void setColor(int c) { CLine_setColor(ptr, c); }
|
void setWidth(int w) { CLine_setWidth(ptr, w); };
|
};
|
|
|
class CDMLTable : public DrawObj, protected GarbageContainer
|
{
|
private :
|
//disable copying
|
CDMLTable(const CDMLTable &rhs);
|
CDMLTable &operator=(const CDMLTable &rhs);
|
|
CDMLTableInternal *ptr;
|
|
TextBox *makeTextBox(TextBoxInternal *p)
|
{ if (!p) return 0; TextBox *ret = new TextBox(p); reg(ret); return ret; }
|
|
public :
|
CDMLTable(CDMLTableInternal *ptr) : DrawObj(CDMLTable2DrawObj(ptr)), ptr(ptr) {}
|
~CDMLTable() {}
|
|
void setPos(int x, int y, int alignment = Chart::TopLeft)
|
{ CCDMLTable_setPos(ptr, x, y, alignment); }
|
|
TextBox *insertCol(int col) { return makeTextBox(CCDMLTable_insertCol(ptr, col)); }
|
TextBox *appendCol() { return makeTextBox(CCDMLTable_appendCol(ptr)); }
|
int getColCount() const { return CCDMLTable_getColCount(ptr); }
|
|
TextBox *insertRow(int row) { return makeTextBox(CCDMLTable_insertRow(ptr, row)); }
|
TextBox *appendRow() { return makeTextBox(CCDMLTable_appendRow(ptr)); }
|
int getRowCount() const { return CCDMLTable_getRowCount(ptr); }
|
|
TextBox *setText(int col, int row, const char *text)
|
{ return makeTextBox(CCDMLTable_setText(ptr, col, row, text)); }
|
TextBox *setCell(int col, int row, int width, int height, const char *text)
|
{ return makeTextBox(CCDMLTable_setCell(ptr, col, row, width, height, text)); }
|
TextBox *getCell(int col, int row)
|
{ return makeTextBox(CCDMLTable_getCell(ptr, col, row)); }
|
|
TextBox *getColStyle(int col) { return makeTextBox(CCDMLTable_getColStyle(ptr, col)); }
|
TextBox *getRowStyle(int row) { return makeTextBox(CCDMLTable_getRowStyle(ptr, row)); }
|
TextBox *getStyle() { return makeTextBox(CCDMLTable_getStyle(ptr)); }
|
|
void layout() { CCDMLTable_layout(ptr); }
|
|
int getColWidth(int col) const { return CCDMLTable_getColWidth(ptr, col); }
|
int getRowHeight(int row) const { return CCDMLTable_getRowHeight(ptr, row); }
|
int getWidth() const { return CCDMLTable_getWidth(ptr); }
|
int getHeight() const { return CCDMLTable_getHeight(ptr); }
|
};
|
|
|
class LegendBox : public TextBox
|
{
|
private :
|
//disable copying
|
LegendBox(const LegendBox &rhs);
|
LegendBox &operator=(const LegendBox &rhs);
|
|
LegendBoxInternal *ptr;
|
|
public :
|
LegendBox(LegendBoxInternal *ptr) : TextBox(LegendBox2TextBox(ptr)), ptr(ptr) {}
|
~LegendBox() {}
|
|
void setCols(int noOfCols) { CLegendBox_setCols(ptr, noOfCols); }
|
void setReverse(bool b = true) { CLegendBox_setReverse(ptr, b); }
|
void setLineStyleKey(bool b = true) { CLegendBox_setLineStyleKey(ptr, b); }
|
|
void addKey(const char *text, int color, int lineWidth = 0, const DrawArea *drawarea = 0)
|
{ CLegendBox_addKey(ptr, text, color, lineWidth, drawarea ? drawarea->getInternalPtr() : 0); }
|
void addKey(int pos, const char *text, int color, int lineWidth = 0, const DrawArea *drawarea = 0)
|
{ CLegendBox_addKey2(ptr, pos, text, color, lineWidth, drawarea ? drawarea->getInternalPtr() : 0); }
|
void setKeySize(int width, int height = -1, int gap = -1)
|
{ CLegendBox_setKeySize(ptr, width, height, gap); }
|
void setKeySpacing(int keySpacing, int lineSpacing = -1)
|
{ CLegendBox_setKeySpacing(ptr, keySpacing, lineSpacing); }
|
void setKeyBorder(int edgeColor, int raisedEffect = 0)
|
{ CLegendBox_setKeyBorder(ptr, edgeColor, raisedEffect); }
|
|
const char *getImageCoor(int dataItem, int offsetX = 0, int offsetY = 0)
|
{ return CLegendBox_getImageCoor(ptr, dataItem, offsetX, offsetY); }
|
const char *getHTMLImageMap(const char *url, const char *queryFormat = 0, const char *extraAttr = 0,
|
int offsetX = 0, int offsetY = 0)
|
{ return CLegendBox_getHTMLImageMap(ptr, url, queryFormat, extraAttr, offsetX, offsetY); }
|
};
|
|
|
class BaseChart : protected GarbageContainer
|
{
|
private :
|
//disable copying
|
BaseChart(const BaseChart &rhs);
|
BaseChart &operator=(const BaseChart &rhs);
|
|
BaseChartInternal *ptr;
|
int *refCount;
|
DrawArea *dynamicLayerCache;
|
|
public :
|
//obsoleted constants - for compatibility only
|
enum ImgFormat {PNG, GIF, JPG, WMP};
|
|
BaseChart() : ptr(0), refCount(new int), dynamicLayerCache(0) { *refCount = 1; }
|
BaseChart(BaseChart *rhs) : ptr(rhs->ptr), refCount(rhs->refCount), dynamicLayerCache(0) { ++(*refCount); }
|
void init(BaseChartInternal *ptr) { this->ptr = ptr; }
|
~BaseChart() { if (--(*refCount) == 0) { CBaseChart_destroy(ptr); delete refCount; } }
|
void destroy() { delete this; }
|
BaseChartInternal *getInternalPtr() { return ptr; }
|
const BaseChartInternal *getInternalPtr() const { return ptr; }
|
|
void enableVectorOutput() { CBaseChart_enableVectorOutput(ptr); }
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
// set overall chart
|
//////////////////////////////////////////////////////////////////////////////////////
|
void setSize(int width, int height) { CBaseChart_setSize(ptr, width, height); }
|
int getWidth() const { return CBaseChart_getWidth(ptr); }
|
int getHeight() const { return CBaseChart_getHeight(ptr); }
|
void setBackground(int color, int edgeColor = Chart::Transparent, int raisedEffect = 0)
|
{ CBaseChart_setBackground(ptr, color, edgeColor, raisedEffect); }
|
void setBorder(int color) //deprecated - use setBackground
|
{ CBaseChart_setBorder(ptr, color); }
|
void setRoundedFrame(int extColor = 0xffffff, int r1 = 10, int r2 = -1, int r3 = -1, int r4 = -1)
|
{ CBaseChart_setRoundedFrame(ptr, extColor, r1, r2, r3, r4); }
|
void setWallpaper(const char *img) { CBaseChart_setWallpaper(ptr, img); }
|
void setBgImage(const char *img, int align = Chart::Center)
|
{ CBaseChart_setBgImage(ptr, img, align); }
|
void setDropShadow(int color = 0xaaaaaa, int offsetX = 5, int offsetY = 0x7fffffff, int blurRadius = 5)
|
{ CBaseChart_setDropShadow(ptr, color, offsetX, offsetY, blurRadius) ; }
|
void setTransparentColor(int c)
|
{ CBaseChart_setTransparentColor(ptr, c); }
|
void setAntiAlias(bool shapeAntiAlias = true, int textAntiAlias = Chart::AutoAntiAlias)
|
{ CBaseChart_setAntiAlias(ptr, shapeAntiAlias, textAntiAlias); }
|
void setSearchPath(const char *path)
|
{ CBaseChart_setSearchPath(ptr, path); }
|
|
TextBox *addTitle(const char *text, const char *font = 0, double fontSize = 12,
|
int fontColor = Chart::TextColor, int bgColor = Chart::Transparent, int edgeColor = Chart::Transparent)
|
{ TextBox *ret = new TextBox(CBaseChart_addTitle(ptr, text, font, fontSize, fontColor, bgColor, edgeColor)); reg(ret); return ret;}
|
TextBox *addTitle(int alignment, const char *text, const char *font = 0, double fontSize = 12,
|
int fontColor = Chart::TextColor, int bgColor = Chart::Transparent, int edgeColor = Chart::Transparent)
|
{ TextBox *ret = new TextBox(CBaseChart_addTitle2(ptr, alignment, text, font, fontSize, fontColor, bgColor, edgeColor)); reg(ret); return ret; }
|
LegendBox *addLegend(int x, int y, bool vertical = true, const char *font = 0,
|
double fontSize = 10)
|
{ LegendBox *ret = new LegendBox(CBaseChart_addLegend(ptr, x, y, vertical, font, fontSize)); reg(ret); return ret; }
|
LegendBox *addLegend2(int x, int y, int noOfCols, const char *font = 0, double fontSize = 10)
|
{ LegendBox *ret = new LegendBox(CBaseChart_addLegend2(ptr, x, y, noOfCols, font, fontSize)); reg(ret); return ret; }
|
LegendBox *getLegend() { LegendBox *ret = new LegendBox(CBaseChart_getLegend(ptr)); reg(ret); return ret; }
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
// drawing primitives
|
//////////////////////////////////////////////////////////////////////////////////////
|
DrawArea *getDrawArea() { DrawArea *ret = new DrawArea(CBaseChart_getDrawArea(ptr)); reg(ret); return ret; }
|
TextBox *addText(int x, int y, const char *text, const char *font = 0, double fontSize = 8,
|
int fontColor = Chart::TextColor, int alignment = Chart::TopLeft, double angle = 0, bool vertical = false)
|
{ TextBox *ret = new TextBox(CBaseChart_addText(ptr, x, y, text, font, fontSize, fontColor, alignment, angle, vertical)); reg(ret); return ret; }
|
Line *addLine(int x1, int y1, int x2, int y2, int color = Chart::LineColor, int lineWidth = 1)
|
{ Line *ret = new Line(CBaseChart_addLine(ptr, x1, y1, x2, y2, color, lineWidth)); reg(ret); return ret; }
|
CDMLTable *addTable(int x, int y, int alignment, int col, int row)
|
{ CDMLTable *ret = new CDMLTable(CBaseChart_addTable(ptr, x, y, alignment, col, row)); reg(ret); return ret; }
|
void addExtraField(StringArray texts) { CBaseChart_addExtraField(ptr, texts.data, texts.len); }
|
void addExtraField(DoubleArray numbers) { CBaseChart_addExtraField2(ptr, numbers.data, numbers.len); }
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
// color management methods
|
//////////////////////////////////////////////////////////////////////////////////////
|
void setColor(int paletteEntry, int color)
|
{ setColors(paletteEntry, IntArray(&color, 1)); }
|
void setColors(int paletteEntry, const int *colors)
|
{ for (int i = 0; i < 0xffff; ++i) if (colors[i] == -1) { setColors(paletteEntry, IntArray(colors, i)); return; } }
|
void setColors(int paletteEntry, IntArray colors)
|
{ CBaseChart_setColors(ptr, paletteEntry, colors.data, colors.len); }
|
void setColors(const int *colors) { setColors(0, colors); }
|
void setColors(IntArray colors) { setColors(0, colors); }
|
int getColor(int paletteEntry) { return CBaseChart_getColor(ptr, paletteEntry); }
|
int halfColor(int c) { return CBaseChart_halfColor(ptr, c); }
|
int adjustBrightness(int c, double brightness) { return CBaseChart_adjustBrightness(ptr, c, brightness); }
|
|
int dashLineColor(int color, int patternCode = Chart::DashLine)
|
{ return CBaseChart_dashLineColor(ptr, color, patternCode); }
|
int patternColor(const int *c, int w, int h, int startX = 0, int startY = 0)
|
{ return patternColor(IntArray(c, w * h), startX, startY); }
|
int patternColor(IntArray colorArray, int height, int startX = 0, int startY = 0)
|
{ return CBaseChart_patternColor(ptr, colorArray.data, colorArray.len, height, startX, startY); }
|
int patternColor(const char *filename, int startX = 0, int startY = 0)
|
{ return CBaseChart_patternColor2(ptr, filename, startX, startY); }
|
int gradientColor(int startX, int startY, int endX, int endY, int startColor, int endColor)
|
{ return CBaseChart_gradientColor(ptr, startX, startY, endX, endY, startColor, endColor); }
|
int gradientColor(IntArray colorArray, double angle = 90, double scale = 1.0, int startX = 0, int startY = 0)
|
{ return CBaseChart_gradientColor2(ptr, colorArray.data, colorArray.len, angle, scale, startX, startY); }
|
int gradientColor(const int *c, double angle = 90, double scale = 1, int startX = 0, int startY = 0)
|
{ return CBaseChart_gradientColor2a(ptr, c, angle, scale, startX, startY); }
|
int linearGradientColor(int startX, int startY, int endX, int endY, int startColor, int endColor, bool periodic = false)
|
{ return CBaseChart_linearGradientColor(ptr, startX, startY, endX, endY, startColor, endColor, periodic); }
|
int linearGradientColor(int startX, int startY, int endX, int endY, IntArray c, bool periodic = false)
|
{ return CBaseChart_linearGradientColor2(ptr, startX, startY, endX, endY, c.data, c.len, periodic); }
|
int radialGradientColor(int cx, int cy, int rx, int ry, int startColor, int endColor, bool periodic = false)
|
{ return CBaseChart_radialGradientColor(ptr, cx, cy, rx, ry, startColor, endColor, periodic); }
|
int radialGradientColor(int cx, int cy, int rx, int ry, IntArray c, bool periodic = false)
|
{ return CBaseChart_radialGradientColor2(ptr, cx, cy, rx, ry, c.data, c.len, periodic); }
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
// locale support
|
//////////////////////////////////////////////////////////////////////////////////////
|
void setDefaultFonts(const char *normal, const char *bold = 0, const char *italic = 0,
|
const char *boldItalic = 0)
|
{ CBaseChart_setDefaultFonts(ptr, normal, bold, italic, boldItalic); }
|
void setFontTable(int index, const char *font)
|
{ CBaseChart_setFontTable(ptr, index, font); }
|
|
void setNumberFormat(char thousandSeparator = '~', char decimalPointChar = '.', char signChar = '-')
|
{ CBaseChart_setNumberFormat(ptr, thousandSeparator, decimalPointChar, signChar); }
|
void setMonthNames(StringArray names)
|
{ CBaseChart_setMonthNames(ptr, names.data, names.len); }
|
void setWeekDayNames(StringArray names)
|
{ CBaseChart_setWeekDayNames(ptr, names.data, names.len); }
|
void setAMPM(const char *am, const char *pm)
|
{ CBaseChart_setAMPM(ptr, am, pm); }
|
const char *formatValue(double value, const char *formatString)
|
{ return CBaseChart_formatValue(ptr, value, formatString); }
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
// chart creation methods
|
//////////////////////////////////////////////////////////////////////////////////////
|
LegendBox *layoutLegend() { LegendBox *ret = new LegendBox(CBaseChart_layoutLegend(ptr)); reg(ret); return ret; }
|
void layout() { CBaseChart_layout(ptr); }
|
bool makeChart(const char *filename)
|
{ return CBaseChart_makeChart(ptr, filename); }
|
bool makeChart(int format, const char **data, int *len)
|
{ return CBaseChart_makeChart2(ptr, format, data, len); }
|
MemBlock makeChart(int format)
|
{ const char *data; int len; makeChart(format, &data, &len); return MemBlock(data, len); }
|
DrawArea *makeChart()
|
{ DrawArea *ret = new DrawArea(CBaseChart_makeChart3(ptr)); reg(ret); return ret; }
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
// image map support
|
//////////////////////////////////////////////////////////////////////////////////////
|
const char *getHTMLImageMap(const char *url, const char *queryFormat = 0, const char *extraAttr = 0,
|
int offsetX = 0, int offsetY = 0)
|
{ return CBaseChart_getHTMLImageMap(ptr, url, queryFormat, extraAttr, offsetX, offsetY); }
|
const char *getChartMetrics() { return CBaseChart_getChartMetrics(ptr); }
|
|
//
|
// Ver 5.1
|
//
|
int getAbsOffsetX() const
|
{ return CBaseChart_getAbsOffsetX(ptr); }
|
int getAbsOffsetY() const
|
{ return CBaseChart_getAbsOffsetY(ptr); }
|
|
DrawArea *initDynamicLayer() {
|
DrawAreaInternal *retPtr = CBaseChart_initDynamicLayer(ptr);
|
if ((0 == dynamicLayerCache) || (retPtr != dynamicLayerCache->getInternalPtr())) {
|
dynamicLayerCache = new DrawArea(retPtr); reg(dynamicLayerCache);
|
}
|
return dynamicLayerCache;
|
}
|
void removeDynamicLayer()
|
{ CBaseChart_removeDynamicLayer(ptr); }
|
|
const char *getJsChartModel(const char *options = 0)
|
{ return CBaseChart_getJsChartModel(ptr, options); }
|
};
|
|
|
class MultiChart : public BaseChart
|
{
|
private :
|
//disable copying
|
MultiChart(const MultiChart &rhs);
|
MultiChart &operator=(const MultiChart &rhs);
|
|
MultiChartInternal *ptr;
|
|
const BaseChart *mainChart;
|
BaseChart **charts;
|
int chartCount;
|
int maxChartCount;
|
|
public :
|
MultiChart(int width, int height, int bgColor = Chart::BackgroundColor,
|
int edgeColor = Chart::Transparent, int raisedEffect = 0) :
|
mainChart(0), charts(0), chartCount(0), maxChartCount(0)
|
{ ptr = CMultiChart_create(width, height, bgColor, edgeColor, raisedEffect);
|
init(MultiChart2BaseChart(ptr)); mainChart = 0; }
|
static MultiChart *create(int width, int height, int bgColor = Chart::BackgroundColor,
|
int edgeColor = Chart::Transparent, int raisedEffect = 0)
|
{ return new MultiChart(width, height, bgColor, edgeColor, raisedEffect); }
|
~MultiChart() { delete[] charts; }
|
void addChart(int x, int y, BaseChart *c) {
|
if (0 != c) {
|
CMultiChart_addChart(ptr, x, y, c->getInternalPtr());
|
if (chartCount == maxChartCount) {
|
maxChartCount = (maxChartCount < 10) ? 10 : maxChartCount * 2;
|
BaseChart **temp = new BaseChart*[maxChartCount];
|
for (int i = 0; i < chartCount; ++i) temp[i] = charts[i];
|
delete[] charts; charts = temp;
|
}
|
charts[chartCount++] = c;
|
}
|
}
|
BaseChart *getChart(int i = 0) {
|
if (i == -1)
|
return (BaseChart *)mainChart;
|
if ((i >= 0) && (i < chartCount))
|
return charts[i];
|
return 0;
|
}
|
int getChartCount() {
|
return chartCount;
|
}
|
void setMainChart(const BaseChart *c)
|
{ CMultiChart_setMainChart(ptr, c->getInternalPtr()); mainChart = c;}
|
};
|
|
|
class Sector : public AutoDestroy, protected GarbageContainer
|
{
|
private :
|
//disable copying
|
Sector(const Sector &rhs);
|
Sector &operator=(const Sector &rhs);
|
|
SectorInternal *ptr;
|
|
public :
|
Sector(SectorInternal *ptr) : ptr(ptr) {}
|
~Sector() {}
|
|
void setExplode(int distance = -1)
|
{ CSector_setExplode(ptr, distance); }
|
void setLabelFormat(const char *formatString)
|
{ CSector_setLabelFormat(ptr, formatString); }
|
TextBox *setLabelStyle(const char *font = 0, double fontSize = 8,
|
int fontColor = Chart::TextColor)
|
{ TextBox *ret = new TextBox(CSector_setLabelStyle(ptr, font, fontSize, fontColor)); reg(ret); return ret;}
|
void setLabelPos(int pos, int joinLineColor = -1)
|
{ CSector_setLabelPos(ptr, pos, joinLineColor); }
|
void setLabelLayout(int layoutMethod, int pos = -1)
|
{ CSector_setLabelLayout(ptr, layoutMethod, pos); }
|
void setJoinLine(int joinLineColor, int joinLineWidth = 1)
|
{ CSector_setJoinLine(ptr, joinLineColor, joinLineWidth); }
|
void setColor(int color, int edgeColor = -1, int joinLineColor = -1)
|
{ CSector_setColor(ptr, color, edgeColor, joinLineColor); }
|
void setStyle(int shadingMethod, int edgeColor = -1, int edgeWidth = -1)
|
{ CSector_setStyle(ptr, shadingMethod, edgeColor, edgeWidth); }
|
const char *getImageCoor(int offsetX = 0, int offsetY = 0)
|
{ return CSector_getImageCoor(ptr, offsetX, offsetY); }
|
const char *getLabelCoor(int offsetX = 0, int offsetY = 0)
|
{ return CSector_getLabelCoor(ptr, offsetX, offsetY); }
|
};
|
|
|
class PieChart : public BaseChart
|
{
|
private :
|
//disable copying
|
PieChart(const PieChart &rhs);
|
PieChart &operator=(const PieChart &rhs);
|
|
PieChartInternal *ptr;
|
|
public :
|
PieChart(int width, int height, int bgColor = Chart::BackgroundColor,
|
int edgeColor = Chart::Transparent, int raisedEffect = 0)
|
{ ptr = CPieChart_create(width, height, bgColor, edgeColor, raisedEffect);
|
init(PieChart2BaseChart(ptr)); }
|
static PieChart *create(int width, int height, int bgColor = Chart::BackgroundColor,
|
int edgeColor = Chart::Transparent, int raisedEffect = 0)
|
{ return new PieChart(width, height, bgColor, edgeColor, raisedEffect); }
|
|
void setPieSize(int x, int y, int r)
|
{ CPieChart_setPieSize(ptr, x, y, r); }
|
void setDonutSize(int x, int y, int r, int r2)
|
{ CPieChart_setDonutSize(ptr, x, y, r, r2); }
|
void set3D(int depth = -1, double angle = -1, bool shadowMode = false)
|
{ CPieChart_set3D(ptr, depth, angle, shadowMode); }
|
void set3D(DoubleArray depths, double angle = 45, bool shadowMode = false)
|
{ CPieChart_set3D2(ptr, depths.data, depths.len, angle, shadowMode); }
|
void setSectorStyle(int shadingMethod, int edgeColor = -1, int edgeWidth = -1)
|
{ CPieChart_setSectorStyle(ptr, shadingMethod, edgeColor, edgeWidth); }
|
void setStartAngle(double startAngle, bool clockWise = true)
|
{ CPieChart_setStartAngle(ptr, startAngle, clockWise); }
|
void setExplode(int sectorNo = -1, int distance = -1)
|
{ CPieChart_setExplode(ptr, sectorNo, distance); }
|
void setExplodeGroup(int startSector, int endSector, int distance = -1)
|
{ CPieChart_setExplodeGroup(ptr, startSector, endSector, distance); }
|
|
void setLabelFormat(const char *formatString)
|
{ CPieChart_setLabelFormat(ptr, formatString); }
|
TextBox *setLabelStyle(const char *font = 0, double fontSize = 8,
|
int fontColor = Chart::TextColor)
|
{ TextBox *ret = new TextBox(CPieChart_setLabelStyle(ptr, font, fontSize, fontColor)); reg(ret); return ret;}
|
void setLabelPos(int pos, int joinLineColor = -1)
|
{ CPieChart_setLabelPos(ptr, pos, joinLineColor); }
|
void setLabelLayout(int layoutMethod, int pos = -1, int topBound = -1, int bottomBound = -1)
|
{ CPieChart_setLabelLayout(ptr, layoutMethod, pos, topBound, bottomBound); }
|
void setJoinLine(int joinLineColor, int joinLineWidth = 1)
|
{ CPieChart_setJoinLine(ptr, joinLineColor, joinLineWidth); }
|
void setLineColor(int edgeColor, int joinLineColor = -1)
|
{ CPieChart_setLineColor(ptr, edgeColor, joinLineColor); }
|
|
void setData(int noOfPoints, const double *data, const char* const* labels = 0)
|
{ setData(DoubleArray(data, noOfPoints), StringArray(labels, labels ? noOfPoints : 0)); }
|
void setData(DoubleArray data, StringArray labels = StringArray())
|
{ CPieChart_setData(ptr, data.data, data.len, labels.data, labels.len); }
|
|
Sector *getSector(int sectorNo)
|
{ SectorInternal *p = CPieChart_sector(ptr, sectorNo); if (!p) return 0;
|
Sector *ret = new Sector(p); reg(ret); return ret; }
|
Sector *sector(int sectorNo) { return getSector(sectorNo); }
|
};
|
|
|
class LineObj;
|
class Mark : public TextBox
|
{
|
private :
|
//disable copying
|
Mark(const Mark &rhs);
|
Mark &operator=(const Mark &rhs);
|
|
MarkInternal *ptr;
|
|
public :
|
Mark(MarkInternal *ptr) : TextBox(Mark2TextBox(ptr)), ptr(ptr) {}
|
~Mark() {}
|
|
void setValue(double value) { CMark_setValue(ptr, value); }
|
void setMarkColor(int lineColor, int textColor = -1, int tickColor = -1)
|
{ CMark_setMarkColor(ptr, lineColor, textColor, tickColor); }
|
void setLineWidth(int w) { CMark_setLineWidth(ptr, w); }
|
void setDrawOnTop(bool b) { CMark_setDrawOnTop(ptr, b); }
|
LineObj *getLine() { return (LineObj *)CMark_getLine(ptr); }
|
};
|
|
|
class Axis : public AutoDestroy, protected GarbageContainer
|
{
|
private :
|
//disable copying
|
Axis(const Axis &rhs);
|
Axis &operator=(const Axis &rhs);
|
|
AxisInternal *ptr;
|
|
public :
|
Axis(AxisInternal *ptr) : ptr(ptr) {}
|
~Axis() {}
|
AxisInternal *getInternalPtr() { return ptr; }
|
const AxisInternal *getInternalPtr() const { return ptr; }
|
|
TextBox *setLabelStyle(const char *font = 0, double fontSize = 8,
|
int fontColor = Chart::TextColor, double fontAngle = 0)
|
{ TextBox *ret = new TextBox(CAxis_setLabelStyle(ptr, font, fontSize, fontColor, fontAngle)); reg(ret); return ret; }
|
void setLabelFormat(const char *formatString)
|
{ CAxis_setLabelFormat(ptr, formatString); }
|
void setLabelGap(int d)
|
{ CAxis_setLabelGap(ptr, d); }
|
|
void setMultiFormat(int filter1, const char *format1, int filter2, const char *format2, int labelSpan = 1, bool promoteFirst = true)
|
{ CAxis_setMultiFormat(ptr, filter1, format1, filter2, format2, labelSpan, promoteFirst); }
|
void setMultiFormat(int filterId, const char *formatString, int labelSpan = 1, bool promoteFirst = true)
|
{ CAxis_setMultiFormat2(ptr, filterId, formatString, labelSpan, promoteFirst); }
|
void setFormatCondition(const char *condition, double operand = 0)
|
{ CAxis_setFormatCondition(ptr, condition, operand); }
|
|
TextBox *setTitle(const char *text, const char *font = 0,
|
double fontSize = 8, int fontColor = Chart::TextColor)
|
{ TextBox *ret = new TextBox(CAxis_setTitle(ptr, text, font, fontSize, fontColor)); reg(ret); return ret; }
|
void setTitlePos(int alignment, int titleGap = 3)
|
{ CAxis_setTitlePos(ptr, alignment, titleGap); }
|
|
void setColors(int axisColor, int labelColor = Chart::TextColor, int titleColor = -1,
|
int tickColor = -1)
|
{ CAxis_setColors(ptr, axisColor, labelColor, titleColor, tickColor); }
|
|
void setTickLength(int majorTickLen)
|
{ CAxis_setTickLength(ptr, majorTickLen); }
|
void setTickLength(int majorTickLen, int minorTickLen)
|
{ CAxis_setTickLength2(ptr, majorTickLen, minorTickLen); }
|
void setTickWidth(int majorTickWidth, int minorTickWidth = -1)
|
{ CAxis_setTickWidth(ptr, majorTickWidth, minorTickWidth); }
|
void setTickColor(int majorTickColor, int minorTickColor = -1)
|
{ CAxis_setTickColor(ptr, majorTickColor, minorTickColor); }
|
|
void setWidth(int width) { CAxis_setWidth(ptr, width); }
|
void setLength(int length) { CAxis_setLength(ptr, length); }
|
void setOffset(int x, int y) { CAxis_setOffset(ptr, x, y); }
|
|
void setAngle(double startAngle) { CAxis_setAngle(ptr, startAngle); }
|
void setTopMargin(int topMargin) //obsoleted - use setMargin(int, int)
|
{ setMargin(topMargin); }
|
void setMargin(int topMargin, int bottomMargin = 0)
|
{ CAxis_setMargin(ptr, topMargin, bottomMargin); }
|
void setIndent(bool indent) { CAxis_setIndent(ptr, indent); }
|
void setTickOffset(double offset) { CAxis_setTickOffset(ptr, offset); }
|
void setLabelOffset(double offset) { CAxis_setLabelOffset(ptr, offset); }
|
|
void setAutoScale(double topExtension = 0.1, double bottomExtension = 0.1, double zeroAffinity = 0.8)
|
{ CAxis_setAutoScale(ptr, topExtension, bottomExtension, zeroAffinity); }
|
void setRounding(bool roundMin, bool roundMax)
|
{ CAxis_setRounding(ptr, roundMin, roundMax); }
|
void setTickDensity(int majorTickSpacing, int minorTickSpacing = -1)
|
{ CAxis_setTickDensity(ptr, majorTickSpacing, minorTickSpacing); }
|
void setReverse(bool b = true)
|
{ CAxis_setReverse(ptr, b); }
|
void setMinTickInc(double inc) { CAxis_setMinTickInc(ptr, inc); }
|
|
TextBox *setLabels(int noOfLabels, const char* const* text) //obsoleted - use setLabels(StringArray)
|
{ return setLabels(StringArray(text, noOfLabels)); }
|
TextBox *setLabels(StringArray labels)
|
{ TextBox *ret = new TextBox(CAxis_setLabels(ptr, labels.data, labels.len)); reg(ret); return ret; }
|
TextBox *setLabels(DoubleArray labels, const char *formatString = 0)
|
{ TextBox *ret = new TextBox(CAxis_setLabels2(ptr, labels.data, labels.len, formatString)); reg(ret); return ret; }
|
CDMLTable *makeLabelTable()
|
{ CDMLTable *ret = new CDMLTable(CAxis_makeLabelTable(ptr)); reg(ret); return ret; }
|
CDMLTable *getLabelTable()
|
{ CDMLTableInternal *p = CAxis_getLabelTable(ptr); if (!p) return 0;
|
CDMLTable *ret = new CDMLTable(p); reg(ret); return ret; }
|
|
void setLabelStep(int majorTickStep, int minorTickStep = 0, int majorTickOffset = 0, int minorTickOffset = -0x7fffffff)
|
{ CAxis_setLabelStep(ptr, majorTickStep, minorTickStep, majorTickOffset, minorTickOffset); }
|
|
void setLinearScale(const char *formatString = 0)
|
{ CAxis_setLinearScale3(ptr, formatString); }
|
void setLinearScale(double lowerLimit, double upperLimit, StringArray labels)
|
{ CAxis_setLinearScale2(ptr, lowerLimit, upperLimit, labels.data, labels.len); }
|
void setLinearScale(double lowerLimit, double upperLimit, double majorTickInc = 0, double minorTickInc = 0)
|
{ CAxis_setLinearScale(ptr, lowerLimit, upperLimit, majorTickInc, minorTickInc); }
|
|
void setLogScale(bool logScale) //obsoleted - use setLogScale(const char *)/setLinearScale(const char *)
|
{ if (logScale) setLogScale(); else setLinearScale(); }
|
|
void setLogScale(const char *formatString = 0)
|
{ CAxis_setLogScale3(ptr, formatString); }
|
void setLogScale(double lowerLimit, double upperLimit, StringArray labels)
|
{ CAxis_setLogScale2(ptr, lowerLimit, upperLimit, labels.data, labels.len); }
|
void setLogScale(double lowerLimit, double upperLimit, double majorTickInc = 0, double minorTickInc = 0)
|
{ CAxis_setLogScale(ptr, lowerLimit, upperLimit, majorTickInc, minorTickInc); }
|
|
void setDateScale(const char *formatString = 0)
|
{ CAxis_setDateScale3(ptr, formatString); }
|
void setDateScale(double lowerLimit, double upperLimit, StringArray labels)
|
{ CAxis_setDateScale2(ptr, lowerLimit, upperLimit, labels.data, labels.len); }
|
void setDateScale(double lowerLimit, double upperLimit, double majorTickInc = 0, double minorTickInc = 0)
|
{ CAxis_setDateScale(ptr, lowerLimit, upperLimit, majorTickInc, minorTickInc); }
|
|
void syncAxis(const Axis *axis, double slope = 1, double intercept = 0)
|
{ CAxis_syncAxis(ptr, axis->ptr, slope, intercept); }
|
void copyAxis(const Axis *axis)
|
{ CAxis_copyAxis(ptr, axis->ptr); }
|
|
void addLabel(double pos, const char *label)
|
{ CAxis_addLabel(ptr, pos, label); }
|
|
Mark *addMark(double value, int lineColor, const char *text = 0,
|
const char *font = 0, double fontSize = 8)
|
{ Mark *ret = new Mark(CAxis_addMark(ptr, value, lineColor, text, font, fontSize)); reg(ret); return ret; }
|
void addZone(double startValue, double endValue, int color)
|
{ CAxis_addZone(ptr, startValue, endValue, color); }
|
|
int getCoor(double v) const { return CAxis_getCoor(ptr, v); }
|
int getX() { return CAxis_getX(ptr); }
|
int getY() { return CAxis_getY(ptr); }
|
int getAlignment() { return CAxis_getAlignment(ptr); }
|
double getMinValue() const { return CAxis_getMinValue(ptr); }
|
double getMaxValue() const { return CAxis_getMaxValue(ptr); }
|
int getThickness() const { return CAxis_getThickness(ptr); }
|
|
DoubleArray getTicks() const
|
{ const double *d; int len; CAxis_getTicks(ptr, &d, &len); return DoubleArray(d, len); }
|
const char *getLabel(double i) const { return CAxis_getLabel(ptr, i); }
|
const char *getFormattedLabel(double v, const char *formatString = 0)
|
{ return CAxis_getFormattedLabel(ptr, v, formatString); }
|
|
const char *getAxisImageMap(int noOfSegments, int mapWidth, const char *url, const char *queryFormat = 0,
|
const char *extraAttr = 0, int offsetX = 0, int offsetY = 0) const
|
{ return CAxis_getAxisImageMap(ptr, noOfSegments, mapWidth, url, queryFormat, extraAttr, offsetX, offsetY); }
|
const char *getHTMLImageMap(const char *url, const char *queryFormat = 0, const char *extraAttr = 0,
|
int offsetX = 0, int offsetY = 0) const
|
{ return CAxis_getHTMLImageMap(ptr, url, queryFormat, extraAttr, offsetX, offsetY); }
|
};
|
|
//
|
// for compatibility
|
//
|
typedef Axis BaseAxis;
|
typedef BaseAxis XAxis;
|
typedef BaseAxis YAxis;
|
|
//
|
// In this version, PolarChart RadialAxis is the same as the XYChart Axis
|
//
|
typedef Axis RadialAxis;
|
|
//
|
// AngularAxis for PolarChart
|
//
|
class AngularAxis : public AutoDestroy, protected GarbageContainer
|
{
|
private :
|
//disable copying
|
AngularAxis(const AngularAxis &rhs);
|
AngularAxis &operator=(const AngularAxis &rhs);
|
|
AngularAxisInternal *ptr;
|
|
public :
|
AngularAxis(AngularAxisInternal *ptr) : ptr(ptr) {}
|
~AngularAxis() {}
|
|
TextBox *setLabelStyle(const char *font = "bold", double fontSize = 10,
|
int fontColor = Chart::TextColor, double fontAngle = 0)
|
{ TextBox *ret = new TextBox(CAngularAxis_setLabelStyle(ptr, font, fontSize, fontColor, fontAngle)); reg(ret); return ret; }
|
void setLabelGap(int d) { CAngularAxis_setLabelGap(ptr, d); }
|
|
TextBox *setLabels(StringArray labels)
|
{ TextBox *ret = new TextBox(CAngularAxis_setLabels(ptr, labels.data, labels.len)); reg(ret); return ret; }
|
TextBox *setLabels(DoubleArray labels, const char *formatString = 0)
|
{ TextBox *ret = new TextBox(CAngularAxis_setLabels2(ptr, labels.data, labels.len, formatString)); reg(ret); return ret; }
|
void addLabel(double pos, const char *label)
|
{ CAngularAxis_addLabel(ptr, pos, label); }
|
|
void setLinearScale(double lowerLimit, double upperLimit, StringArray labels)
|
{ CAngularAxis_setLinearScale2(ptr, lowerLimit, upperLimit, labels.data, labels.len); }
|
void setLinearScale(double lowerLimit, double upperLimit, double majorTickInc = 0, double minorTickInc = 0)
|
{ CAngularAxis_setLinearScale(ptr, lowerLimit, upperLimit, majorTickInc, minorTickInc); }
|
|
void addZone(double startValue, double endValue, double startRadius, double endRadius,
|
int fillColor, int edgeColor = -1)
|
{ CAngularAxis_addZone(ptr, startValue, endValue, startRadius, endRadius, fillColor, edgeColor); }
|
void addZone(double startValue, double endValue, int fillColor, int edgeColor = -1)
|
{ CAngularAxis_addZone2(ptr, startValue, endValue, fillColor, edgeColor); }
|
|
const char *getAxisImageMap(int noOfSegments, int mapWidth, const char *url, const char *queryFormat = 0,
|
const char *extraAttr = 0, int offsetX = 0, int offsetY = 0) const
|
{ return CAngularAxis_getAxisImageMap(ptr, noOfSegments, mapWidth, url, queryFormat, extraAttr, offsetX, offsetY); }
|
const char *getHTMLImageMap(const char *url, const char *queryFormat = 0, const char *extraAttr = 0,
|
int offsetX = 0, int offsetY = 0) const
|
{ return CAngularAxis_getHTMLImageMap(ptr, url, queryFormat, extraAttr, offsetX, offsetY); }
|
};
|
|
|
class ColorAxis : public Axis
|
{
|
private :
|
//disable copying
|
ColorAxis(const ColorAxis &rhs);
|
ColorAxis &operator=(const ColorAxis &rhs);
|
|
ColorAxisInternal *ptr;
|
|
public :
|
ColorAxis(ColorAxisInternal *ptr) : Axis(ColorAxis2Axis(ptr)), ptr(ptr) {}
|
~ColorAxis() {}
|
|
void setColorGradient(bool isContinuous = true, IntArray colors = IntArray(), int underflowColor = -1, int overflowColor = -1)
|
{ CColorAxis_setColorGradient(ptr, isContinuous, colors.data, colors.len, overflowColor, underflowColor); }
|
void setAxisPos(int x, int y, int alignment) { CColorAxis_setAxisPos(ptr, x, y, alignment); }
|
void setLevels(int maxLevels) { CColorAxis_setLevels(ptr, maxLevels); }
|
void setCompactAxis(bool b = true) { CColorAxis_setCompactAxis(ptr, b); }
|
void setAxisBorder(int edgeColor, int raisedEffect = 0) { CColorAxis_setAxisBorder(ptr, edgeColor, raisedEffect); }
|
void setBoundingBox(int fillColor, int edgeColor = Chart::Transparent, int raisedEffect = 0)
|
{ CColorAxis_setBoundingBox(ptr, fillColor, edgeColor, raisedEffect); }
|
void setBoxMargin(int m) { CColorAxis_setBoxMargin(ptr, m); }
|
void setBoxMargin(int leftMargin, int rightMargin, int topMargin, int bottomMargin)
|
{ CColorAxis_setBoxMargin2(ptr, leftMargin, rightMargin, topMargin, bottomMargin); }
|
void setRoundedCorners(int r1 = 10, int r2 = -1, int r3 = -1, int r4 = -1)
|
{ CColorAxis_setRoundedCorners(ptr, r1, r2, r3, r4); }
|
int getBoxWidth() const { return CColorAxis_getBoxWidth(ptr); }
|
int getBoxHeight() const { return CColorAxis_getBoxHeight(ptr); }
|
int getColor(double z) const { return CColorAxis_getColor(ptr, z); }
|
};
|
|
|
class DataSet : public AutoDestroy, protected GarbageContainer
|
{
|
private :
|
//disable copying
|
DataSet(const DataSet &rhs);
|
DataSet &operator=(const DataSet &rhs);
|
|
DataSetInternal *ptr;
|
Axis *useYAxisCache;
|
|
public :
|
DataSet(DataSetInternal *ptr) : ptr(ptr), useYAxisCache(0) {}
|
~DataSet() {}
|
DataSetInternal *getInternalPtr() { return ptr; }
|
const DataSetInternal *getInternalPtr() const { return ptr; }
|
|
void setData(int noOfPoints, const double *data)
|
{ setData(DoubleArray(data, noOfPoints)); }
|
void setData(DoubleArray data)
|
{ CDataSet_setData(ptr, data.data, data.len); }
|
double getValue(int i )
|
{ return CDataSet_getValue(ptr, i); }
|
double getPosition(int i )
|
{ return CDataSet_getPosition(ptr, i); }
|
|
void setDataName(const char *name)
|
{ CDataSet_setDataName(ptr, name); }
|
const char *getDataName()
|
{ return CDataSet_getDataName(ptr); }
|
void setDataColor(int dataColor, int edgeColor = -1,
|
int shadowColor = -1, int shadowEdgeColor = -1)
|
{ CDataSet_setDataColor(ptr, dataColor, edgeColor, shadowColor, shadowEdgeColor); }
|
int getDataColor()
|
{ return CDataSet_getDataColor(ptr); }
|
|
void setDataSymbol(int symbol, int size = 5, int fillColor = -1, int edgeColor = -1, int lineWidth = 1)
|
{ CDataSet_setDataSymbol(ptr, symbol, size, fillColor, edgeColor, lineWidth); }
|
void setDataSymbol(const char *image)
|
{ CDataSet_setDataSymbol2(ptr, image); }
|
void setDataSymbol(const DrawArea *obj)
|
{ CDataSet_setDataSymbol3(ptr, obj->getInternalPtr()); }
|
void setDataSymbol(IntArray polygon, int size = 11, int fillColor = -1, int edgeColor = -1)
|
{ CDataSet_setDataSymbol4(ptr, polygon.data, polygon.len, size, fillColor, edgeColor); }
|
void setLineWidth(int w)
|
{ CDataSet_setLineWidth(ptr, w); }
|
|
void setDataLabelFormat(const char *formatString)
|
{ CDataSet_setDataLabelFormat(ptr, formatString); }
|
TextBox *setDataLabelStyle(const char *font = 0, double fontSize = 8,
|
int fontColor = Chart::TextColor, double fontAngle = 0)
|
{ TextBox *ret = new TextBox(CDataSet_setDataLabelStyle(ptr, font, fontSize, fontColor, fontAngle)); reg(ret); return ret;}
|
|
void setUseYAxis2(bool b = true) { CDataSet_setUseYAxis2(ptr, b); }
|
void setUseYAxis(const Axis* a) { CDataSet_setUseYAxis(ptr, a->getInternalPtr()); }
|
Axis *getUseYAxis() {
|
AxisInternal *retPtr = CDataSet_getUseYAxis(ptr);
|
if ((0 == useYAxisCache) || (retPtr != useYAxisCache->getInternalPtr())) {
|
useYAxisCache = new Axis(retPtr); reg(useYAxisCache);
|
}
|
return useYAxisCache;
|
}
|
|
const char *getLegendIcon()
|
{ return CDataSet_getLegendIcon(ptr); }
|
};
|
|
|
class Layer : public AutoDestroy, protected GarbageContainer
|
{
|
private :
|
//disable copying
|
Layer(const Layer &rhs);
|
Layer &operator=(const Layer &rhs);
|
|
LayerInternal *ptr;
|
|
DataSet **dataSetCache;
|
int dataSetCacheCount;
|
int maxDataSetCacheCount;
|
|
DataSet *regDataSet(DataSetInternal *ptr) {
|
if (!ptr) return 0;
|
for (int i = 0; i < dataSetCacheCount; ++i)
|
if (dataSetCache[i]->getInternalPtr() == ptr) return dataSetCache[i];
|
DataSet *ret = new DataSet(ptr); reg(ret);
|
if (dataSetCacheCount >= maxDataSetCacheCount) {
|
maxDataSetCacheCount = (maxDataSetCacheCount < 10) ? 10 : maxDataSetCacheCount * 2;
|
DataSet **temp = new DataSet*[maxDataSetCacheCount];
|
for (int i = 0; i < dataSetCacheCount; ++i) temp[i] = dataSetCache[i];
|
delete[] dataSetCache; dataSetCache = temp;
|
}
|
return dataSetCache[dataSetCacheCount++] = ret;
|
}
|
|
public :
|
Layer(LayerInternal *ptr) : ptr(ptr), dataSetCache(0), dataSetCacheCount(0), maxDataSetCacheCount(0) {}
|
~Layer() { delete[] dataSetCache; }
|
LayerInternal *getInternalPtr() { return ptr; }
|
const LayerInternal *getInternalPtr() const { return ptr; }
|
|
void moveFront(Layer *layer = 0) { CLayer_moveFront(ptr, layer ? layer->ptr : 0); }
|
void moveBack(Layer *layer = 0) { CLayer_moveBack(ptr, layer ? layer->ptr : 0); }
|
|
void set3D(int d = -1, int zGap = 0) { CLayer_set3D(ptr, d, zGap); }
|
void setLineWidth(int w) { CLayer_setLineWidth(ptr, w); }
|
void setBorderColor(int color, int lightingEffect = 0)
|
{ CLayer_setBorderColor(ptr, color, lightingEffect); }
|
void setLegend(int m) { CLayer_setLegend(ptr, m); }
|
void setLegendOrder(int dataSetOrder, int layerOrder = -1)
|
{ CLayer_setLegendOrder(ptr, dataSetOrder, layerOrder); }
|
const char *getLegendIcon(int dataSetNo) const
|
{ return CLayer_getLegendIcon(ptr, dataSetNo); }
|
|
//obsoleted constants - for compatibility only
|
enum DataCombineMethod { Overlay, Stack, Depth, Side };
|
|
void setDataCombineMethod(int m) { CLayer_setDataCombineMethod(ptr, m); }
|
void setBaseLine(double baseLine) { CLayer_setBaseLine(ptr, baseLine); }
|
|
DataSet *addDataSet(int noOfPoints, const double *d, int color = -1, const char *name = 0)
|
{ return addDataSet(DoubleArray(d, noOfPoints), color, name); }
|
DataSet *addDataSet(DoubleArray data, int color = -1, const char *name = 0)
|
{ return regDataSet(CLayer_addDataSet(ptr, data.data, data.len, color, name)); }
|
void addDataGroup(const char *name = 0) { CLayer_addDataGroup(ptr, name); }
|
void addExtraField(StringArray texts) { CLayer_addExtraField(ptr, texts.data, texts.len); }
|
void addExtraField(DoubleArray numbers) { CLayer_addExtraField2(ptr, numbers.data, numbers.len); }
|
|
DataSet *getDataSet(int i)
|
{ return regDataSet(CLayer_getDataSet(ptr, i)); }
|
DataSet *getDataSetByZ(int i)
|
{ return regDataSet(CLayer_getDataSetByZ(ptr, i)); }
|
int getDataSetCount()
|
{ return CLayer_getDataSetCount(ptr); }
|
|
void setUseYAxis2(bool b = true) { CLayer_setUseYAxis2(ptr, b); }
|
void setUseYAxis(const Axis* a) { CLayer_setUseYAxis(ptr, a->getInternalPtr()); }
|
|
void setXData(DoubleArray xData) { CLayer_setXData(ptr, xData.data, xData.len); }
|
void setXData(double minValue, double maxValue) { CLayer_setXData2(ptr, minValue, maxValue); }
|
double getXPosition(int i)
|
{ return CLayer_getXPosition(ptr, i); }
|
double getNearestXValue(double target)
|
{ return CLayer_getNearestXValue(ptr, target); }
|
int getXIndexOf(double xValue, double tolerance = 0)
|
{ return CLayer_getXIndexOf(ptr, xValue, tolerance); }
|
void alignLayer(const Layer *layer, int dataSet) { CLayer_alignLayer(ptr, layer->getInternalPtr(), dataSet); }
|
|
int getXCoor(double v) const { return CLayer_getXCoor(ptr, v); }
|
int getYCoor(double v, bool yAxis = true) const { return CLayer_getYCoor(ptr, v, yAxis); }
|
int getYCoor(double v, const Axis *yAxis) const
|
{ if (0 == yAxis) return getYCoor(v); else return CLayer_getYCoor2(ptr, v, yAxis->getInternalPtr()); }
|
int xZoneColor(double threshold, int belowColor, int aboveColor)
|
{ return CLayer_xZoneColor(ptr, threshold, belowColor, aboveColor); }
|
int yZoneColor(double threshold, int belowColor, int aboveColor, bool yAxis = true)
|
{ return CLayer_yZoneColor(ptr, threshold, belowColor, aboveColor, yAxis); }
|
int yZoneColor(double threshold, int belowColor, int aboveColor, const Axis *yAxis)
|
{ if (0 == yAxis) return yZoneColor(threshold, belowColor, aboveColor);
|
else return CLayer_yZoneColor2(ptr, threshold, belowColor, aboveColor, yAxis->getInternalPtr()); }
|
|
//*** Note ***: The default value -0x7fffffff is maintained for compatibility
|
const char *getImageCoor(int dataSet, int dataItem = -0x7fffffff, int offsetX = 0, int offsetY = 0)
|
{ return CLayer_getImageCoor(ptr, dataSet, dataItem, offsetX, offsetY); }
|
const char *getImageCoor2(int dataItem, int offsetX = 0, int offsetY = 0)
|
{ return CLayer_getImageCoor2(ptr, dataItem, offsetX, offsetY); }
|
const char *getHTMLImageMap(const char *url, const char *queryFormat = 0,
|
const char *extraAttr = 0, int offsetX = 0, int offsetY = 0)
|
{ return CLayer_getHTMLImageMap(ptr, url, queryFormat, extraAttr, offsetX, offsetY); }
|
void setHTMLImageMap(const char *url, const char *queryFormat = 0, const char *extraAttr = 0)
|
{ CLayer_setHTMLImageMap(ptr, url, queryFormat, extraAttr); }
|
|
void setDataLabelFormat(const char *formatString)
|
{ CLayer_setDataLabelFormat(ptr, formatString); }
|
TextBox *setDataLabelStyle(const char *font = 0, double fontSize = 8,
|
int fontColor = Chart::TextColor, double fontAngle = 0)
|
{ TextBox *ret = new TextBox(CLayer_setDataLabelStyle(ptr, font, fontSize, fontColor, fontAngle)); reg(ret); return ret;}
|
|
void setAggregateLabelFormat(const char *formatString)
|
{ CLayer_setAggregateLabelFormat(ptr, formatString); }
|
TextBox *setAggregateLabelStyle(const char *font = 0, double fontSize = 8,
|
int fontColor = Chart::TextColor, double fontAngle = 0)
|
{ TextBox *ret = new TextBox(CLayer_setAggregateLabelStyle(ptr, font, fontSize, fontColor, fontAngle)); reg(ret); return ret;}
|
|
TextBox *addCustomDataLabel(int dataSet, int dataItem, const char *label,
|
const char *font = 0, double fontSize = 8, int fontColor = Chart::TextColor, double fontAngle = 0)
|
{ TextBox *ret = new TextBox(CLayer_addCustomDataLabel(ptr, dataSet, dataItem, label, font, fontSize, fontColor, fontAngle)); reg(ret); return ret;}
|
TextBox *addCustomAggregateLabel(int dataItem, const char *label, const char *font = 0,
|
double fontSize = 8, int fontColor = Chart::TextColor, double fontAngle = 0)
|
{ TextBox *ret = new TextBox(CLayer_addCustomAggregateLabel(ptr, dataItem, label, font, fontSize, fontColor, fontAngle)); reg(ret); return ret;}
|
TextBox *addCustomGroupLabel(int dataGroup, int dataItem, const char *label,
|
const char *font = 0, double fontSize = 8, int fontColor = Chart::TextColor, double fontAngle = 0)
|
{ TextBox *ret = new TextBox(CLayer_addCustomGroupLabel(ptr, dataGroup, dataItem, label, font, fontSize, fontColor, fontAngle)); reg(ret); return ret;}
|
};
|
|
|
class BarLayer : public Layer
|
{
|
private :
|
//disable copying
|
BarLayer(const BarLayer &rhs);
|
BarLayer &operator=(const BarLayer &rhs);
|
|
BarLayerInternal *ptr;
|
|
public :
|
BarLayer(BarLayerInternal *ptr) : Layer(BarLayer2Layer(ptr)), ptr(ptr) {}
|
~BarLayer() {}
|
|
void setBarGap(double barGap, double subBarGap = Chart::NoValue)
|
{ CBarLayer_setBarGap(ptr, barGap, subBarGap); }
|
void setBarWidth(int barWidth, int subBarWidth = -1)
|
{ CBarLayer_setBarWidth(ptr, barWidth, subBarWidth); }
|
void setMinLabelSize(int s)
|
{ CBarLayer_setMinLabelSize(ptr, s); }
|
void setMinImageMapSize(int s)
|
{ CBarLayer_setMinImageMapSize(ptr, s); }
|
|
void setBarShape(int shape, int dataGroup = -1, int dataItem = -1)
|
{ CBarLayer_setBarShape(ptr, shape, dataGroup, dataItem); }
|
void setBarShape(IntArray shape, int dataGroup = -1, int dataItem = -1)
|
{ CBarLayer_setBarShape2(ptr, shape.data, shape.len, dataGroup, dataItem); }
|
void setIconSize(int height, int width = -1)
|
{ CBarLayer_setIconSize(ptr, height, width); }
|
void setOverlapRatio(double overlapRatio, bool firstOnTop = true)
|
{ CBarLayer_setOverlapRatio(ptr, overlapRatio, firstOnTop); }
|
};
|
|
|
class InterLineLayer : public Layer
|
{
|
private :
|
//disable copying
|
InterLineLayer(const InterLineLayer &rhs);
|
InterLineLayer &operator=(const InterLineLayer &rhs);
|
|
InterLineLayerInternal *ptr;
|
|
public :
|
InterLineLayer(InterLineLayerInternal *ptr) : Layer(InterLineLayer2Layer(ptr)), ptr(ptr) {}
|
~InterLineLayer() {}
|
|
void setGapColor(int gapColor12, int gapColor21 = -1)
|
{ CInterLineLayer_setGapColor(ptr, gapColor12, gapColor21); }
|
};
|
|
|
class LineLayer : public Layer
|
{
|
private :
|
//disable copying
|
LineLayer(const LineLayer &rhs);
|
LineLayer &operator=(const LineLayer &rhs);
|
|
LineLayerInternal *ptr;
|
|
public :
|
LineLayer(LineLayerInternal *ptr) : Layer(LineLayer2Layer(ptr)), ptr(ptr) {}
|
~LineLayer() {}
|
|
void setSymbolScale(DoubleArray zDataX, int scaleTypeX = Chart::PixelScale,
|
DoubleArray zDataY = DoubleArray(), int scaleTypeY = Chart::PixelScale)
|
{ CLineLayer_setSymbolScale(ptr, zDataX.data, zDataX.len, scaleTypeX,
|
zDataY.data, zDataY.len, scaleTypeY); }
|
|
void setGapColor(int lineColor, int lineWidth = -1)
|
{ CLineLayer_setGapColor(ptr, lineColor, lineWidth); }
|
void setImageMapWidth(int width)
|
{ CLineLayer_setImageMapWidth(ptr, width); }
|
void setFastLineMode(bool b = true)
|
{ CLineLayer_setFastLineMode(ptr, b); }
|
LineObj *getLine(int dataSet = 0)
|
{ return (LineObj *)CLineLayer_getLine(ptr, dataSet); }
|
};
|
|
|
//In the current version, a Scatter chart is implemented as a
|
//special configuration of a Line chart.
|
typedef LineLayer ScatterLayer;
|
|
class SplineLayer : public LineLayer
|
{
|
private :
|
//disable copying
|
SplineLayer(const SplineLayer &rhs);
|
SplineLayer &operator=(const SplineLayer &rhs);
|
|
SplineLayerInternal *ptr;
|
|
public :
|
SplineLayer(SplineLayerInternal *ptr) : LineLayer(SplineLayer2LineLayer(ptr)), ptr(ptr) {}
|
~SplineLayer() {}
|
|
void setTension(double tension) { CSplineLayer_setTension(ptr, tension); }
|
void setMonotonicity(int m) { CSplineLayer_setMonotonicity(ptr, m); }
|
};
|
|
|
class StepLineLayer : public LineLayer
|
{
|
private :
|
//disable copying
|
StepLineLayer(const StepLineLayer &rhs);
|
StepLineLayer &operator=(const StepLineLayer &rhs);
|
|
StepLineLayerInternal *ptr;
|
|
public :
|
StepLineLayer(StepLineLayerInternal *ptr) : LineLayer(StepLineLayer2LineLayer(ptr)), ptr(ptr) {}
|
~StepLineLayer() {}
|
|
void setAlignment(int a) { CStepLineLayer_setAlignment(ptr, a); }
|
};
|
|
|
class AreaLayer : public Layer
|
{
|
private :
|
//disable copying
|
AreaLayer(const AreaLayer &rhs);
|
AreaLayer &operator=(const AreaLayer &rhs);
|
|
AreaLayerInternal *ptr;
|
|
public :
|
AreaLayer(AreaLayerInternal *ptr) : Layer(AreaLayer2Layer(ptr)), ptr(ptr) {}
|
~AreaLayer() {}
|
|
void setMinLabelSize(int s) { CAreaLayer_setMinLabelSize(ptr, s); }
|
void setGapColor(int fillColor) { CAreaLayer_setGapColor(ptr, fillColor); }
|
};
|
|
|
class BaseBoxLayer : public Layer
|
{
|
private :
|
//disable copying
|
BaseBoxLayer(const BaseBoxLayer &rhs);
|
BaseBoxLayer &operator=(const BaseBoxLayer &rhs);
|
|
BaseBoxLayerInternal *ptr;
|
|
public :
|
BaseBoxLayer(BaseBoxLayerInternal *ptr) : Layer(BaseBoxLayer2Layer(ptr)), ptr(ptr) {}
|
~BaseBoxLayer() {}
|
|
void setDataGap(double gap) { CBaseBoxLayer_setDataGap(ptr, gap); }
|
void setDataWidth(int width) { CBaseBoxLayer_setDataWidth(ptr, width); }
|
void setMinImageMapSize(int size) { CBaseBoxLayer_setMinImageMapSize(ptr, size); }
|
};
|
|
|
class HLOCLayer : public BaseBoxLayer
|
{
|
private :
|
//disable copying
|
HLOCLayer(const HLOCLayer &rhs);
|
HLOCLayer &operator=(const HLOCLayer &rhs);
|
|
HLOCLayerInternal *ptr;
|
|
public :
|
HLOCLayer(HLOCLayerInternal *ptr) : BaseBoxLayer(HLOCLayer2BaseBoxLayer(ptr)), ptr(ptr) {}
|
~HLOCLayer() {}
|
|
void setColorMethod(int colorMethod, int riseColor, int fallColor = -1,
|
double leadValue = -1.7E308)
|
{ CHLOCLayer_setColorMethod(ptr, colorMethod, riseColor, fallColor, leadValue); }
|
};
|
|
|
class CandleStickLayer : public BaseBoxLayer
|
{
|
private :
|
//disable copying
|
CandleStickLayer(const CandleStickLayer &rhs);
|
CandleStickLayer &operator=(const CandleStickLayer &rhs);
|
|
CandleStickLayerInternal *ptr;
|
|
public :
|
CandleStickLayer(CandleStickLayerInternal *ptr) : BaseBoxLayer(CandleStickLayer2BaseBoxLayer(ptr)), ptr(ptr) {}
|
~CandleStickLayer() {}
|
};
|
|
|
class BoxWhiskerLayer : public BaseBoxLayer
|
{
|
private :
|
//disable copying
|
BoxWhiskerLayer(const BoxWhiskerLayer &rhs);
|
BoxWhiskerLayer &operator=(const BoxWhiskerLayer &rhs);
|
|
BoxWhiskerLayerInternal *ptr;
|
|
public :
|
BoxWhiskerLayer(BoxWhiskerLayerInternal *ptr) : BaseBoxLayer(BoxWhiskerLayer2BaseBoxLayer(ptr)), ptr(ptr) {}
|
~BoxWhiskerLayer() {}
|
|
void setBoxColors(IntArray colors, StringArray names = StringArray())
|
{ CBoxWhiskerLayer_setBoxColors(ptr, colors.data, colors.len, names.data, names.len); }
|
void setBoxColor(int item, int boxColor)
|
{ CBoxWhiskerLayer_setBoxColor(ptr, item, boxColor); }
|
void setWhiskerBrightness(double whiskerBrightness)
|
{ CBoxWhiskerLayer_setWhiskerBrightness(ptr, whiskerBrightness); }
|
};
|
|
|
class TrendLayer : public Layer
|
{
|
private :
|
//disable copying
|
TrendLayer(const TrendLayer &rhs);
|
TrendLayer &operator=(const TrendLayer &rhs);
|
|
TrendLayerInternal *ptr;
|
|
public :
|
TrendLayer(TrendLayerInternal *ptr) : Layer(TrendLayer2Layer(ptr)), ptr(ptr) {}
|
~TrendLayer() {}
|
|
void setRegressionType(int regressionType) { CTrendLayer_setRegressionType(ptr, regressionType); }
|
|
void addConfidenceBand(double confidence, int upperFillColor, int upperEdgeColor = Chart::Transparent,
|
int upperLineWidth = 1, int lowerFillColor = -1, int lowerEdgeColor = -1, int lowerLineWidth = -1)
|
{ CTrendLayer_addConfidenceBand(ptr, confidence, upperFillColor, upperEdgeColor,
|
upperLineWidth, lowerFillColor, lowerEdgeColor, lowerLineWidth); }
|
void addPredictionBand(double confidence, int upperFillColor, int upperEdgeColor = Chart::Transparent,
|
int upperLineWidth = 1, int lowerFillColor = -1, int lowerEdgeColor = -1, int lowerLineWidth = -1)
|
{ CTrendLayer_addPredictionBand(ptr, confidence, upperFillColor, upperEdgeColor,
|
upperLineWidth, lowerFillColor, lowerEdgeColor, lowerLineWidth); }
|
|
double getSlope() { return CTrendLayer_getSlope(ptr); }
|
double getIntercept() { return CTrendLayer_getIntercept(ptr); }
|
double getCorrelation() { return CTrendLayer_getCorrelation(ptr); }
|
double getStdError() { return CTrendLayer_getStdError(ptr); }
|
double getCoefficient(int i) { return CTrendLayer_getCoefficient(ptr, i); }
|
|
void setImageMapWidth(int width) { CTrendLayer_setImageMapWidth(ptr, width); }
|
LineObj *getLine() { return (LineObj *)CTrendLayer_getLine(ptr); }
|
};
|
|
|
class VectorLayer : public Layer
|
{
|
private :
|
//disable copying
|
VectorLayer(const VectorLayer &rhs);
|
VectorLayer &operator=(const VectorLayer &rhs);
|
|
VectorLayerInternal *ptr;
|
|
public :
|
VectorLayer(VectorLayerInternal *ptr) : Layer(VectorLayer2Layer(ptr)), ptr(ptr) {}
|
~VectorLayer() {}
|
|
void setVector(DoubleArray lengths, DoubleArray directions, int lengthScale = Chart::PixelScale)
|
{ CVectorLayer_setVector(ptr, lengths.data, lengths.len, directions.data, directions.len, lengthScale); }
|
void setArrowHead(int width, int height = 0) { CVectorLayer_setArrowHead(ptr, width, height); }
|
void setArrowHead(IntArray polygon) { CVectorLayer_setArrowHead2(ptr, polygon.data, polygon.len); }
|
void setArrowStem(IntArray polygon) { CVectorLayer_setArrowStem(ptr, polygon.data, polygon.len); }
|
void setArrowAlignment(int alignment) { CVectorLayer_setArrowAlignment(ptr, alignment); }
|
void setIconSize(int height, int width = 0) { CVectorLayer_setIconSize(ptr, height, width); }
|
void setVectorMargin(double startMargin, double endMargin = Chart::NoValue)
|
{ CVectorLayer_setVectorMargin(ptr, startMargin, endMargin); }
|
};
|
|
|
class ContourLayer : public Layer
|
{
|
private :
|
//disable copying
|
ContourLayer(const ContourLayer &rhs);
|
ContourLayer &operator=(const ContourLayer &rhs);
|
|
ContourLayerInternal *ptr;
|
|
public :
|
ContourLayer(ContourLayerInternal *ptr) : Layer(ContourLayer2Layer(ptr)), ptr(ptr) {}
|
~ContourLayer() {}
|
|
void setZData(DoubleArray zData) { CContourLayer_setZData(ptr, zData.data, zData.len); }
|
void setZBounds(double minZ, double maxZ)
|
{ CContourLayer_setZBounds(ptr, minZ, maxZ); }
|
void setSmoothInterpolation(bool b) { CContourLayer_setSmoothInterpolation(ptr, b); }
|
void setContourColor(int contourColor, int minorContourColor = -1)
|
{ CContourLayer_setContourColor(ptr, contourColor, minorContourColor); }
|
void setContourWidth(int contourWidth, int minorContourWidth = -1)
|
{ CContourLayer_setContourWidth(ptr, contourWidth, minorContourWidth); }
|
void setExactContour(bool contour, bool markContour)
|
{ CContourLayer_setExactContour(ptr, contour, markContour); }
|
void setExactContour(bool contour = true)
|
{ setExactContour(contour, contour); }
|
ColorAxis *setColorAxis(int x, int y, int alignment, int length, int orientation)
|
{ ColorAxis *ret = new ColorAxis(CContourLayer_setColorAxis(ptr, x, y, alignment, length, orientation)); reg(ret); return ret; }
|
ColorAxis *colorAxis()
|
{ ColorAxis *ret = new ColorAxis(CContourLayer_colorAxis(ptr)); reg(ret); return ret; }
|
};
|
|
|
class PlotArea : public AutoDestroy
|
{
|
private :
|
//disable copying
|
PlotArea(const PlotArea &rhs);
|
PlotArea &operator=(const PlotArea &rhs);
|
|
PlotAreaInternal *ptr;
|
|
public :
|
PlotArea(PlotAreaInternal *ptr) : ptr(ptr) {}
|
~PlotArea() {}
|
|
void setBackground(int color, int altBgColor = -1, int edgeColor = -1)
|
{ CPlotArea_setBackground(ptr, color, altBgColor, edgeColor); }
|
void setBackground(const char *img, int align = Chart::Center)
|
{ CPlotArea_setBackground2(ptr, img, align); }
|
void set4QBgColor(int Q1Color, int Q2Color, int Q3Color, int Q4Color, int edgeColor = -1)
|
{ CPlotArea_set4QBgColor(ptr, Q1Color, Q2Color, Q3Color, Q4Color, edgeColor); }
|
void setAltBgColor(bool horizontal, int color1, int color2, int edgeColor = -1)
|
{ CPlotArea_setAltBgColor(ptr, horizontal, color1, color2, edgeColor); }
|
void setGridColor(int hGridColor, int vGridColor = Chart::Transparent,
|
int minorHGridColor = -1, int minorVGridColor = -1)
|
{ CPlotArea_setGridColor(ptr, hGridColor, vGridColor, minorHGridColor, minorVGridColor); }
|
void setGridWidth(int hGridWidth, int vGridWidth = -1,
|
int minorHGridWidth = -1, int minorVGridWidth = -1)
|
{ CPlotArea_setGridWidth(ptr, hGridWidth, vGridWidth, minorHGridWidth, minorVGridWidth); }
|
void setGridAxis(const Axis *xGridAxis, const Axis *yGridAxis)
|
{ CPlotArea_setGridAxis(ptr, xGridAxis ? xGridAxis->getInternalPtr() : 0, yGridAxis ? yGridAxis->getInternalPtr() : 0); }
|
void moveGridBefore(Layer *layer = 0) { CPlotArea_moveGridBefore(ptr, layer ? layer->getInternalPtr() : 0); }
|
|
int getLeftX() const { return CPlotArea_getLeftX(ptr); }
|
int getTopY() const { return CPlotArea_getTopY(ptr); }
|
int getWidth() const { return CPlotArea_getWidth(ptr); }
|
int getHeight() const { return CPlotArea_getHeight(ptr); }
|
int getRightX() const { return CPlotArea_getRightX(ptr); }
|
int getBottomY() const { return CPlotArea_getBottomY(ptr); }
|
};
|
|
|
class XYChart : public BaseChart
|
{
|
private :
|
//disable copying
|
XYChart(const XYChart &rhs);
|
XYChart &operator=(const XYChart &rhs);
|
|
XYChartInternal *ptr;
|
|
Layer **layerCache;
|
int layerCacheCount;
|
int maxLayerCacheCount;
|
|
Layer *regLayer(LayerInternal *ptr) {
|
if (!ptr) return 0;
|
for (int i = 0; i < layerCacheCount; ++i)
|
if (layerCache[i]->getInternalPtr() == ptr) return layerCache[i];
|
Layer *ret = new Layer(ptr); reg(ret);
|
if (layerCacheCount >= maxLayerCacheCount) {
|
maxLayerCacheCount = (maxLayerCacheCount < 10) ? 10 : maxLayerCacheCount * 2;
|
Layer **temp = new Layer*[maxLayerCacheCount];
|
for (int i = 0; i < layerCacheCount; ++i) temp[i] = layerCache[i];
|
delete[] layerCache; layerCache = temp;
|
}
|
return layerCache[layerCacheCount++] = ret;
|
}
|
|
public :
|
XYChart(int width, int height, int bgColor = Chart::BackgroundColor,
|
int edgeColor = Chart::Transparent, int raisedEffect = 0) :
|
layerCache(0), layerCacheCount(0), maxLayerCacheCount(0)
|
{ ptr = CXYChart_create(width, height, bgColor, edgeColor, raisedEffect);
|
init(XYChart2BaseChart(ptr)); }
|
static XYChart *create(int width, int height, int bgColor = Chart::BackgroundColor,
|
int edgeColor = Chart::Transparent, int raisedEffect = 0)
|
{ return new XYChart(width, height, bgColor, edgeColor, raisedEffect); }
|
~XYChart() { delete[] layerCache; }
|
|
Axis *addAxis(int align, int offset) { Axis *ret = new Axis(CXYChart_addAxis(ptr, align, offset)); reg(ret); return ret; }
|
Axis *yAxis() { Axis *ret = new Axis(CXYChart_yAxis(ptr)); reg(ret); return ret; }
|
Axis *yAxis2() { Axis *ret = new Axis(CXYChart_yAxis2(ptr)); reg(ret); return ret; }
|
void syncYAxis(double slope = 1, double intercept = 0)
|
{ CXYChart_syncYAxis(ptr, slope, intercept); }
|
void setYAxisOnRight(bool b = true) { CXYChart_setYAxisOnRight(ptr, b); }
|
Axis *xAxis() { Axis *ret = new Axis(CXYChart_xAxis(ptr)); reg(ret); return ret; }
|
Axis *xAxis2() { Axis *ret = new Axis(CXYChart_xAxis2(ptr)); reg(ret); return ret; }
|
void setXAxisOnTop(bool b = true) { CXYChart_setXAxisOnTop(ptr, b); }
|
void swapXY(bool b = true) { CXYChart_swapXY(ptr, b); }
|
void setAxisAtOrigin(int originMode = Chart::XYAxisAtOrigin, int symmetryMode = 0)
|
{ CXYChart_setAxisAtOrigin(ptr, originMode, symmetryMode); }
|
|
int getXCoor(double v) const { return CXYChart_getXCoor(ptr, v); }
|
int getYCoor(double v, const Axis *yAxis = 0)
|
{ return CXYChart_getYCoor(ptr, v, (0 == yAxis) ? 0 : yAxis->getInternalPtr()); }
|
double getXValue(int xCoor)
|
{ return CXYChart_getXValue(ptr, xCoor); }
|
double getNearestXValue(double xCoor)
|
{ return CXYChart_getNearestXValue(ptr, xCoor); }
|
double getYValue(int yCoor, const Axis *yAxis = 0)
|
{ return CXYChart_getYValue(ptr, yCoor, (0 == yAxis) ? 0 : yAxis->getInternalPtr()); }
|
|
int xZoneColor(double threshold, int belowColor, int aboveColor)
|
{ return CXYChart_xZoneColor(ptr, threshold, belowColor, aboveColor); }
|
int yZoneColor(double threshold, int belowColor, int aboveColor, const Axis *yAxis = 0)
|
{ return CXYChart_yZoneColor(ptr, threshold, belowColor, aboveColor, (0 == yAxis) ? 0 : yAxis->getInternalPtr()); }
|
|
PlotArea *setPlotArea(int x, int y, int width, int height,
|
int bgColor = Chart::Transparent, int altBgColor = -1, int edgeColor = -1,
|
int hGridColor = 0xc0c0c0, int vGridColor = Chart::Transparent)
|
{ PlotArea *ret = new PlotArea(CXYChart_setPlotArea(ptr, x, y, width, height, bgColor,
|
altBgColor, edgeColor, hGridColor, vGridColor)); reg(ret); return ret; }
|
PlotArea *getPlotArea() { PlotArea *ret = new PlotArea(CXYChart_getPlotArea(ptr)); reg(ret); return ret; }
|
void setClipping(int margin = 0) { CXYChart_setClipping(ptr, margin); }
|
void setTrimData(int startPos, int len = 0x7fffffff) { CXYChart_setTrimData(ptr, startPos, len); }
|
|
BarLayer *addBarLayer(int noOfPoints, const double *data, int color = -1, const char *name = 0, int depth = 0)
|
{ return addBarLayer(DoubleArray(data, noOfPoints), color, name, depth); }
|
BarLayer *addBarLayer(DoubleArray data, int color = -1, const char *name = 0, int depth = 0)
|
{ BarLayer *ret = new BarLayer(CXYChart_addBarLayer(ptr, data.data, data.len, color, name, depth)); reg(ret); return ret; }
|
BarLayer *addBarLayer(int noOfPoints, const double *data, const int *colors, const char* const* names = 0, int depth = 0)
|
{ return addBarLayer(DoubleArray(data, noOfPoints), IntArray(colors, colors ? noOfPoints : 0), StringArray(names, names ? noOfPoints : 0), depth); }
|
BarLayer *addBarLayer(DoubleArray data, IntArray colors, StringArray names = StringArray(), int depth = 0)
|
{ BarLayer *ret = new BarLayer(CXYChart_addBarLayer3(ptr, data.data, data.len, colors.data, colors.len, names.data, names.len, depth)); reg(ret); return ret; }
|
BarLayer *addBarLayer(int dataCombineMethod = Chart::Side, int depth = 0)
|
{ BarLayer *ret = new BarLayer(CXYChart_addBarLayer2(ptr, dataCombineMethod, depth)); reg(ret); return ret; }
|
|
LineLayer *addLineLayer(int noOfPoints, const double *data, int color = -1, const char *name = 0, int depth = 0)
|
{ return addLineLayer(DoubleArray(data, noOfPoints), color, name, depth); }
|
LineLayer *addLineLayer(DoubleArray data, int color = -1, const char *name = 0, int depth = 0)
|
{ LineLayer *ret = new LineLayer(CXYChart_addLineLayer(ptr, data.data, data.len, color, name, depth)); reg(ret); return ret; }
|
LineLayer *addLineLayer(int dataCombineMethod = Chart::Overlay, int depth = 0)
|
{ LineLayer *ret = new LineLayer(CXYChart_addLineLayer2(ptr, dataCombineMethod, depth)); reg(ret); return ret; }
|
|
AreaLayer *addAreaLayer(int noOfPoints, const double *data, int color = -1, const char *name = 0, int depth = 0)
|
{ return addAreaLayer(DoubleArray(data, noOfPoints), color, name, depth); }
|
AreaLayer *addAreaLayer(DoubleArray data, int color = -1, const char *name = 0, int depth = 0)
|
{ AreaLayer *ret = new AreaLayer(CXYChart_addAreaLayer(ptr, data.data, data.len, color, name, depth)); reg(ret); return ret; }
|
AreaLayer *addAreaLayer(int dataCombineMethod = Chart::Stack, int depth = 0)
|
{ AreaLayer *ret = new AreaLayer(CXYChart_addAreaLayer2(ptr, dataCombineMethod, depth)); reg(ret); return ret; }
|
|
HLOCLayer *addHLOCLayer()
|
{ HLOCLayer *ret = new HLOCLayer(CXYChart_addHLOCLayer2(ptr)); reg(ret); return ret; }
|
HLOCLayer *addHLOCLayer(int noOfPoints, const double *highData, const double *lowData, const double *openData = 0,
|
const double *closeData = 0, int color = -1)
|
{ return addHLOCLayer(DoubleArray(highData, highData ? noOfPoints : 0), DoubleArray(lowData, lowData ? noOfPoints : 0),
|
DoubleArray(openData, openData ? noOfPoints : 0), DoubleArray(closeData, closeData ? noOfPoints : 0), color); }
|
HLOCLayer *addHLOCLayer(DoubleArray highData, DoubleArray lowData, DoubleArray openData = DoubleArray(),
|
DoubleArray closeData = DoubleArray(), int color = -1)
|
{ HLOCLayer *ret = new HLOCLayer(CXYChart_addHLOCLayer(ptr, highData.data, highData.len,
|
lowData.data, lowData.len, openData.data, openData.len, closeData.data, closeData.len, color)); reg(ret); return ret; }
|
HLOCLayer *addHLOCLayer(DoubleArray highData, DoubleArray lowData, DoubleArray openData,
|
DoubleArray closeData, int upColor, int downColor, int colorMode = -1, double leadValue = -1.7E308)
|
{ HLOCLayer *ret = new HLOCLayer(CXYChart_addHLOCLayer3(ptr, highData.data, highData.len,
|
lowData.data, lowData.len, openData.data, openData.len, closeData.data, closeData.len,
|
upColor, downColor, colorMode, leadValue)); reg(ret); return ret; }
|
|
CandleStickLayer *addCandleStickLayer(
|
DoubleArray highData, DoubleArray lowData, DoubleArray openData, DoubleArray closeData,
|
int riseColor = 0xffffff, int fallColor = 0x0, int edgeColor = Chart::LineColor)
|
{ CandleStickLayer *ret = new CandleStickLayer(CXYChart_addCandleStickLayer(ptr, highData.data, highData.len,
|
lowData.data, lowData.len, openData.data, openData.len, closeData.data, closeData.len,
|
riseColor, fallColor, edgeColor)); reg(ret); return ret; }
|
|
BoxWhiskerLayer *addBoxWhiskerLayer(
|
DoubleArray boxTop, DoubleArray boxBottom, DoubleArray maxData = DoubleArray(), DoubleArray minData = DoubleArray(),
|
DoubleArray midData = DoubleArray(), int fillColor = -1, int whiskerColor = Chart::LineColor, int edgeColor = -1)
|
{ BoxWhiskerLayer *ret = new BoxWhiskerLayer(CXYChart_addBoxWhiskerLayer(ptr, boxTop.data, boxTop.len,
|
boxBottom.data, boxBottom.len, maxData.data, maxData.len, minData.data, minData.len, midData.data, midData.len,
|
fillColor, whiskerColor, edgeColor)); reg(ret); return ret; }
|
BoxWhiskerLayer *addBoxWhiskerLayer2(DoubleArray boxTop, DoubleArray boxBottom, DoubleArray maxData = DoubleArray(),
|
DoubleArray minData = DoubleArray(), DoubleArray midData = DoubleArray(), IntArray fillColors = IntArray(),
|
double whiskerBrightness = 0.5, StringArray names = StringArray())
|
{ BoxWhiskerLayer *ret = new BoxWhiskerLayer(CXYChart_addBoxWhiskerLayer2(ptr, boxTop.data, boxTop.len,
|
boxBottom.data, boxBottom.len, maxData.data, maxData.len, minData.data, minData.len, midData.data, midData.len,
|
fillColors.data, fillColors.len, whiskerBrightness, names.data, names.len)); reg(ret); return ret; }
|
BoxWhiskerLayer *addBoxLayer(DoubleArray boxTop, DoubleArray boxBottom, int color = -1, const char *name = 0)
|
{ BoxWhiskerLayer *ret = new BoxWhiskerLayer(CXYChart_addBoxLayer(ptr, boxTop.data, boxTop.len,
|
boxBottom.data, boxBottom.len, color, name)); reg(ret); return ret; }
|
|
ScatterLayer *addScatterLayer(DoubleArray xData, DoubleArray yData, const char *name = 0,
|
int symbol = Chart::SquareSymbol, int symbolSize = 5, int fillColor = -1, int edgeColor = -1)
|
{ ScatterLayer *ret = new ScatterLayer(CXYChart_addScatterLayer(ptr, xData.data, xData.len,
|
yData.data, yData.len, name, symbol, symbolSize, fillColor, edgeColor)); reg(ret); return ret; }
|
|
TrendLayer *addTrendLayer(DoubleArray data, int color = -1, const char *name = 0, int depth = 0)
|
{ TrendLayer *ret = new TrendLayer(CXYChart_addTrendLayer(ptr, data.data, data.len, color, name, depth)); reg(ret); return ret; }
|
TrendLayer *addTrendLayer(DoubleArray xData, DoubleArray yData, int color = -1, const char *name = 0, int depth = 0)
|
{ TrendLayer *ret = new TrendLayer(CXYChart_addTrendLayer2(ptr, xData.data, xData.len,
|
yData.data, yData.len, color, name, depth)); reg(ret); return ret; }
|
|
SplineLayer *addSplineLayer(DoubleArray data = DoubleArray(), int color = -1, const char *name = 0)
|
{ SplineLayer *ret = new SplineLayer(CXYChart_addSplineLayer(ptr, data.data, data.len, color, name)); reg(ret); return ret; }
|
StepLineLayer *addStepLineLayer(DoubleArray data = DoubleArray(), int color = -1, const char *name = 0)
|
{ StepLineLayer *ret = new StepLineLayer(CXYChart_addStepLineLayer(ptr, data.data, data.len, color, name)); reg(ret); return ret; }
|
|
InterLineLayer *addInterLineLayer(LineObj *line1, LineObj *line2, int color12, int color21 = -1)
|
{ InterLineLayer *ret = new InterLineLayer(CXYChart_addInterLineLayer(ptr, (LineObjInternal *)line1, (LineObjInternal *)line2, color12, color21));
|
reg(ret); return ret; }
|
|
VectorLayer *addVectorLayer(DoubleArray xData, DoubleArray yData, DoubleArray lengths, DoubleArray directions,
|
int lengthScale = Chart::PixelScale, int color = -1, const char *name = 0)
|
{ VectorLayer *ret = new VectorLayer(CXYChart_addVectorLayer(ptr, xData.data, xData.len,
|
yData.data, yData.len, lengths.data, lengths.len, directions.data, directions.len, lengthScale, color, name));
|
reg(ret); return ret; }
|
|
ContourLayer *addContourLayer(DoubleArray xData, DoubleArray yData, DoubleArray zData)
|
{ ContourLayer *ret = new ContourLayer(CXYChart_addContourLayer(ptr, xData.data, xData.len, yData.data, yData.len, zData.data, zData.len));
|
reg(ret); return ret; }
|
|
Layer *getLayer(int i)
|
{ return regLayer(CXYChart_getLayer(ptr, i)); }
|
Layer *getLayerByZ(int i)
|
{ return regLayer(CXYChart_getLayerByZ(ptr, i)); }
|
int getLayerCount()
|
{ return CXYChart_getLayerCount(ptr); }
|
|
void layoutAxes() { CXYChart_layoutAxes(ptr); }
|
void packPlotArea(int leftX, int topY, int rightX, int bottomY, int minWidth = 0, int minHeight = 0)
|
{ CXYChart_packPlotArea(ptr, leftX, topY, rightX, bottomY, minWidth, minHeight); }
|
};
|
|
|
//
|
// Ver 5.1
|
//
|
class ThreeDChart : public BaseChart
|
{
|
private :
|
//disable copying
|
ThreeDChart(const ThreeDChart &rhs);
|
ThreeDChart &operator=(const ThreeDChart &rhs);
|
|
ThreeDChartInternal *ptr;
|
|
public :
|
ThreeDChart() : ptr(0) {}
|
void init(ThreeDChartInternal *ptr) { this->ptr = ptr; BaseChart::init(ThreeDChart2BaseChart(ptr)); }
|
|
void setPlotRegion(int cx, int cy, int xWidth, int yDepth, int zHeight)
|
{ CThreeDChart_setPlotRegion(ptr, cx, cy, xWidth, yDepth, zHeight); }
|
void setViewAngle(double elevation, double rotation = 0, double twist = 0)
|
{ CThreeDChart_setViewAngle(ptr, elevation, rotation, twist); }
|
void setPerspective(double perspective)
|
{ CThreeDChart_setPerspective(ptr, perspective); }
|
|
Axis *xAxis() { Axis *ret = new Axis(CThreeDChart_xAxis(ptr)); reg(ret); return ret; }
|
Axis *yAxis() { Axis *ret = new Axis(CThreeDChart_yAxis(ptr)); reg(ret); return ret; }
|
Axis *zAxis() { Axis *ret = new Axis(CThreeDChart_zAxis(ptr)); reg(ret); return ret; }
|
void setZAxisPos(int pos) { CThreeDChart_setZAxisPos(ptr, pos); }
|
|
ColorAxis *setColorAxis(int x, int y, int alignment, int length, int orientation)
|
{ ColorAxis *ret = new ColorAxis(CThreeDChart_setColorAxis(ptr, x, y, alignment, length, orientation)); reg(ret); return ret; }
|
ColorAxis *colorAxis()
|
{ ColorAxis *ret = new ColorAxis(CThreeDChart_colorAxis(ptr)); reg(ret); return ret; }
|
|
void setWallVisibility(bool xyVisible, bool yzVisible, bool zxVisible)
|
{ CThreeDChart_setWallVisibility(ptr, xyVisible, yzVisible, zxVisible); }
|
void setWallColor(int xyColor, int yzColor = -1, int zxColor = -1, int borderColor = -1)
|
{ CThreeDChart_setWallColor(ptr, xyColor, yzColor, zxColor, borderColor); }
|
void setWallThickness(int xyThickness, int yzThickness = -1, int zxThickness = -1)
|
{ CThreeDChart_setWallThickness(ptr, xyThickness, yzThickness, zxThickness); }
|
void setWallGrid(int majorXGridColor, int majorYGridColor = -1, int majorZGridColor = -1,
|
int minorXGridColor = -1, int minorYGridColor = -1, int minorZGridColor = -1)
|
{ CThreeDChart_setWallGrid(ptr, majorXGridColor, majorYGridColor, majorZGridColor, minorXGridColor, minorYGridColor, minorZGridColor); }
|
};
|
|
|
class SurfaceChart : public ThreeDChart
|
{
|
private :
|
//disable copying
|
SurfaceChart(const SurfaceChart &rhs);
|
SurfaceChart &operator=(const SurfaceChart &rhs);
|
|
SurfaceChartInternal *ptr;
|
|
public :
|
SurfaceChart(int width, int height, int bgColor = Chart::BackgroundColor,
|
int edgeColor = Chart::Transparent, int raisedEffect = 0)
|
{ ptr = CSurfaceChart_create(width, height, bgColor, edgeColor, raisedEffect);
|
init(SurfaceChart2ThreeDChart(ptr)); }
|
|
void setData(DoubleArray xData, DoubleArray yData, DoubleArray zData)
|
{ CSurfaceChart_setData(ptr, xData.data, xData.len, yData.data, yData.len, zData.data, zData.len); }
|
void setInterpolation(int xSamples, int ySamples = -1, bool isSmooth = true)
|
{ CSurfaceChart_setInterpolation(ptr, xSamples, ySamples, isSmooth); }
|
|
void setLighting(double ambientIntensity, double diffuseIntensity, double specularIntensity, double shininess)
|
{ CSurfaceChart_setLighting(ptr, ambientIntensity, diffuseIntensity, specularIntensity, shininess); }
|
void setShadingMode(int shadingMode, int wireWidth = 1)
|
{ CSurfaceChart_setShadingMode(ptr, shadingMode, wireWidth); }
|
|
void setSurfaceAxisGrid(int majorXGridColor, int majorYGridColor = -1, int minorXGridColor = -1, int minorYGridColor = -1)
|
{ CSurfaceChart_setSurfaceAxisGrid(ptr, majorXGridColor, majorYGridColor, minorXGridColor, minorYGridColor); }
|
void setSurfaceDataGrid(int xGridColor, int yGridColor = -1)
|
{ CSurfaceChart_setSurfaceDataGrid(ptr, xGridColor, yGridColor); }
|
void setContourColor(int contourColor, int minorContourColor = -1)
|
{ CSurfaceChart_setContourColor(ptr, contourColor, minorContourColor); }
|
|
void setBackSideBrightness(double brightness) { CSurfaceChart_setBackSideBrightness(ptr, brightness); }
|
void setBackSideColor(int color) { CSurfaceChart_setBackSideColor(ptr, color); }
|
void setBackSideLighting(double ambientLight, double diffuseLight, double specularLight, double shininess)
|
{ CSurfaceChart_setBackSideLighting(ptr, ambientLight, diffuseLight, specularLight, shininess); }
|
};
|
|
class ThreeDScatterGroup : public AutoDestroy
|
{
|
private :
|
//disable copying
|
ThreeDScatterGroup(const ThreeDScatterGroup &rhs);
|
ThreeDScatterGroup &operator=(const ThreeDScatterGroup &rhs);
|
|
ThreeDScatterGroupInternal *ptr;
|
|
public :
|
ThreeDScatterGroup(ThreeDScatterGroupInternal *ptr) : ptr(ptr) {}
|
~ThreeDScatterGroup() {}
|
|
void setDataSymbol(int symbol, int size = 5, int fillColor = -1, int edgeColor = -1, int lineWidth = 1)
|
{ CThreeDScatterGroup_setDataSymbol(ptr, symbol, size, fillColor, edgeColor, lineWidth); }
|
void setDataSymbol(const char *image)
|
{ CThreeDScatterGroup_setDataSymbol2(ptr, image); }
|
void setDataSymbol(const DrawArea *obj)
|
{ CThreeDScatterGroup_setDataSymbol3(ptr, obj->getInternalPtr()); }
|
void setDataSymbol(IntArray polygon, int size = 11, int fillColor = -1, int edgeColor = -1)
|
{ CThreeDScatterGroup_setDataSymbol4(ptr, polygon.data, polygon.len, size, fillColor, edgeColor); }
|
|
void setDropLine(int dropLineColor = Chart::LineColor, int dropLineWidth = 1)
|
{ CThreeDScatterGroup_setDropLine(ptr, dropLineColor, dropLineWidth); }
|
void setLegendIcon(int width, int height = -1, int color = -1)
|
{ CThreeDScatterGroup_setLegendIcon(ptr, width, height, color); }
|
};
|
|
class ThreeDScatterChart : public ThreeDChart
|
{
|
private :
|
//disable copying
|
ThreeDScatterChart(const ThreeDScatterChart &rhs);
|
ThreeDScatterChart &operator=(const ThreeDScatterChart &rhs);
|
|
ThreeDScatterChartInternal *ptr;
|
|
public :
|
ThreeDScatterChart(int width, int height, int bgColor = Chart::BackgroundColor,
|
int edgeColor = Chart::Transparent, int raisedEffect = 0)
|
{ ptr = CThreeDScatterChart_create(width, height, bgColor, edgeColor, raisedEffect);
|
init(ThreeDScatterChart2ThreeDChart(ptr)); }
|
|
ThreeDScatterGroup *addScatterGroup(DoubleArray xData, DoubleArray yData, DoubleArray zData, const char *name = 0,
|
int symbol = Chart::CircleSymbol, int symbolSize = 5, int fillColor = -1, int edgeColor = -1) {
|
ThreeDScatterGroup *ret = new ThreeDScatterGroup(CThreeDScatterChart_addScatterGroup(ptr, xData.data, xData.len,
|
yData.data, yData.len, zData.data, zData.len, name, symbol, symbolSize, fillColor, edgeColor));
|
reg(ret); return ret;
|
}
|
};
|
|
class PolarLayer : public AutoDestroy, protected GarbageContainer
|
{
|
private :
|
//disable copying
|
PolarLayer(const PolarLayer &rhs);
|
PolarLayer &operator=(const PolarLayer &rhs);
|
|
PolarLayerInternal *ptr;
|
|
public :
|
PolarLayer(PolarLayerInternal *ptr) : ptr(ptr) {}
|
~PolarLayer() {}
|
|
void setData(DoubleArray data, int color = -1, const char *name = 0)
|
{ CPolarLayer_setData(ptr, data.data, data.len, color, name); }
|
void setAngles(DoubleArray angles)
|
{ CPolarLayer_setAngles(ptr, angles.data, angles.len); }
|
|
void setBorderColor(int edgeColor) { CPolarLayer_setBorderColor(ptr, edgeColor); }
|
void setLineWidth(int w) { CPolarLayer_setLineWidth(ptr, w); }
|
|
void setDataSymbol(const char *image) { CPolarLayer_setDataSymbol2(ptr, image); };
|
void setDataSymbol(const DrawArea *obj) { CPolarLayer_setDataSymbol3(ptr, obj->getInternalPtr()); };
|
void setDataSymbol(int symbol, int size = 7,
|
int fillColor = -1, int edgeColor = -1, int lineWidth = 1)
|
{ CPolarLayer_setDataSymbol(ptr, symbol, size, fillColor, edgeColor, lineWidth); }
|
void setDataSymbol(IntArray polygon, int size = 11, int fillColor = -1,
|
int edgeColor = -1)
|
{ CPolarLayer_setDataSymbol4(ptr, polygon.data, polygon.len, size, fillColor, edgeColor); }
|
void setSymbolScale(DoubleArray zData, int scaleType = Chart::PixelScale)
|
{ CPolarLayer_setSymbolScale(ptr, zData.data, zData.len, scaleType); }
|
|
void setImageMapWidth(int width) { CPolarLayer_setImageMapWidth(ptr, width); }
|
const char *getImageCoor(int dataItem, int offsetX = 0, int offsetY = 0)
|
{ return CPolarLayer_getImageCoor(ptr, dataItem, offsetX, offsetY); }
|
const char *getHTMLImageMap(const char *url, const char *queryFormat = 0, const char *extraAttr = 0,
|
int offsetX = 0, int offsetY = 0)
|
{ return CPolarLayer_getHTMLImageMap(ptr, url, queryFormat, extraAttr, offsetX, offsetY); }
|
void setHTMLImageMap(const char *url, const char *queryFormat = 0, const char *extraAttr = 0)
|
{ CPolarLayer_setHTMLImageMap(ptr, url, queryFormat, extraAttr); }
|
|
void setDataLabelFormat(const char *formatString)
|
{ CPolarLayer_setDataLabelFormat(ptr, formatString); }
|
TextBox *setDataLabelStyle(const char *font = 0, double fontSize = 8,
|
int fontColor = Chart::TextColor, double fontAngle = 0)
|
{ TextBox *ret = new TextBox(CPolarLayer_setDataLabelStyle(ptr, font, fontSize, fontColor, fontAngle)); reg(ret); return ret;}
|
TextBox *addCustomDataLabel(int i, const char *label, const char *font = 0,
|
double fontSize = 8, int fontColor = Chart::TextColor, double fontAngle = 0)
|
{ TextBox *ret = new TextBox(CPolarLayer_addCustomDataLabel(ptr, i, label, font, fontSize, fontColor, fontAngle)); reg(ret); return ret;}
|
};
|
|
|
class PolarAreaLayer : public PolarLayer
|
{
|
private :
|
//disable copying
|
PolarAreaLayer(const PolarAreaLayer &rhs);
|
PolarAreaLayer &operator=(const PolarAreaLayer &rhs);
|
|
public :
|
PolarAreaLayer(PolarAreaLayerInternal *ptr) : PolarLayer(PolarAreaLayer2PolarLayer(ptr)) {}
|
~PolarAreaLayer() {}
|
};
|
|
|
class PolarLineLayer : public PolarLayer
|
{
|
private :
|
//disable copying
|
PolarLineLayer(const PolarLineLayer &rhs);
|
PolarLineLayer &operator=(const PolarLineLayer &rhs);
|
|
PolarLineLayerInternal *ptr;
|
|
public :
|
PolarLineLayer(PolarLineLayerInternal *ptr) : PolarLayer(PolarLineLayer2PolarLayer(ptr)), ptr(ptr) {}
|
~PolarLineLayer() {}
|
|
void setCloseLoop(bool b)
|
{ CPolarLineLayer_setCloseLoop(ptr, b); }
|
void setGapColor(int lineColor, int lineWidth = -1)
|
{ CPolarLineLayer_setGapColor(ptr, lineColor, lineWidth); }
|
};
|
|
|
class PolarSplineLineLayer : public PolarLineLayer
|
{
|
private :
|
//disable copying
|
PolarSplineLineLayer(const PolarSplineLineLayer &rhs);
|
PolarSplineLineLayer &operator=(const PolarSplineLineLayer &rhs);
|
|
PolarSplineLineLayerInternal *ptr;
|
|
public :
|
PolarSplineLineLayer(PolarSplineLineLayerInternal *ptr) : PolarLineLayer(PolarSplineLineLayer2PolarLineLayer(ptr)), ptr(ptr) {}
|
~PolarSplineLineLayer() {}
|
|
void setTension(double tension) { CPolarSplineLineLayer_setTension(ptr, tension); }
|
};
|
|
|
class PolarSplineAreaLayer : public PolarAreaLayer
|
{
|
private :
|
//disable copying
|
PolarSplineAreaLayer(const PolarSplineAreaLayer &rhs);
|
PolarSplineAreaLayer &operator=(const PolarSplineAreaLayer &rhs);
|
|
PolarSplineAreaLayerInternal *ptr;
|
|
public :
|
PolarSplineAreaLayer(PolarSplineAreaLayerInternal *ptr) : PolarAreaLayer(PolarSplineAreaLayer2PolarAreaLayer(ptr)), ptr(ptr) {}
|
~PolarSplineAreaLayer() {}
|
|
void setTension(double tension) { CPolarSplineAreaLayer_setTension(ptr, tension); }
|
};
|
|
|
class PolarVectorLayer : public PolarLayer
|
{
|
private :
|
//disable copying
|
PolarVectorLayer(const PolarVectorLayer &rhs);
|
PolarVectorLayer &operator=(const PolarVectorLayer &rhs);
|
|
PolarVectorLayerInternal *ptr;
|
|
public :
|
PolarVectorLayer(PolarVectorLayerInternal *ptr) : PolarLayer(PolarVectorLayer2PolarLayer(ptr)), ptr(ptr) {}
|
~PolarVectorLayer() {}
|
|
void setVector(DoubleArray lengths, DoubleArray directions, int lengthScale = Chart::PixelScale)
|
{ CPolarVectorLayer_setVector(ptr, lengths.data, lengths.len, directions.data, directions.len, lengthScale); }
|
void setArrowHead(int width, int height = 0) { CPolarVectorLayer_setArrowHead(ptr, width, height); }
|
void setArrowHead(IntArray polygon) { CPolarVectorLayer_setArrowHead2(ptr, polygon.data, polygon.len); }
|
void setArrowStem(IntArray polygon) { CPolarVectorLayer_setArrowStem(ptr, polygon.data, polygon.len); }
|
void setArrowAlignment(int alignment) { CPolarVectorLayer_setArrowAlignment(ptr, alignment); }
|
void setIconSize(int height, int width = 0) { CPolarVectorLayer_setIconSize(ptr, height, width); }
|
void setVectorMargin(double startMargin, double endMargin = Chart::NoValue)
|
{ CPolarVectorLayer_setVectorMargin(ptr, startMargin, endMargin); }
|
};
|
|
|
class PolarChart : public BaseChart
|
{
|
private :
|
//disable copying
|
PolarChart(const PolarChart &rhs);
|
PolarChart &operator=(const PolarChart &rhs);
|
|
PolarChartInternal *ptr;
|
|
public :
|
PolarChart(int width, int height, int bgColor = Chart::BackgroundColor,
|
int edgeColor = Chart::Transparent, int raisedEffect = 0)
|
{ ptr = CPolarChart_create(width, height, bgColor, edgeColor, raisedEffect);
|
init(PolarChart2BaseChart(ptr)); }
|
static PolarChart *create(int width, int height, int bgColor = Chart::BackgroundColor,
|
int edgeColor = Chart::Transparent, int raisedEffect = 0)
|
{ return new PolarChart(width, height, bgColor, edgeColor, raisedEffect); }
|
|
void setPlotArea(int x, int y, int r, int bgColor = Chart::Transparent,
|
int edgeColor = Chart::Transparent, int edgeWidth = 1)
|
{ CPolarChart_setPlotArea(ptr, x, y, r, bgColor, edgeColor, edgeWidth); }
|
void setPlotAreaBg(int bgColor1, int bgColor2 = -1, bool altRings = true)
|
{ CPolarChart_setPlotAreaBg(ptr, bgColor1, bgColor2, altRings); }
|
void setGridColor(int rGridColor = 0x80000000, int rGridWidth = 1, int aGridColor = 0x80000000,
|
int aGridWidth = 1)
|
{ CPolarChart_setGridColor(ptr, rGridColor, rGridWidth, aGridColor, aGridWidth); }
|
void setGridStyle(bool polygonGrid, bool gridOnTop = true)
|
{ CPolarChart_setGridStyle(ptr, polygonGrid, gridOnTop); }
|
void setStartAngle(double startAngle, bool clockwise = true)
|
{ CPolarChart_setStartAngle(ptr, startAngle, clockwise); }
|
|
AngularAxis *angularAxis() { AngularAxis *ret = new AngularAxis(CPolarChart_angularAxis(ptr)); reg(ret); return ret; }
|
RadialAxis *radialAxis() { RadialAxis *ret = new RadialAxis(CPolarChart_radialAxis(ptr)); reg(ret); return ret; }
|
|
int getXCoor(double r, double a) const { return CPolarChart_getXCoor(ptr, r, a); }
|
int getYCoor(double r, double a) const { return CPolarChart_getYCoor(ptr, r, a); }
|
|
PolarAreaLayer *addAreaLayer(DoubleArray data, int color = -1, const char *name = 0)
|
{ PolarAreaLayer *ret = new PolarAreaLayer(CPolarChart_addAreaLayer(ptr, data.data, data.len, color, name)); reg(ret); return ret; }
|
PolarLineLayer *addLineLayer(DoubleArray data, int color = -1, const char *name = 0)
|
{ PolarLineLayer *ret = new PolarLineLayer(CPolarChart_addLineLayer(ptr, data.data, data.len, color, name)); reg(ret); return ret; }
|
PolarSplineLineLayer *addSplineLineLayer(DoubleArray data, int color = -1, const char *name = 0)
|
{ PolarSplineLineLayer *ret = new PolarSplineLineLayer(CPolarChart_addSplineLineLayer(ptr, data.data, data.len, color, name)); reg(ret); return ret; }
|
PolarSplineAreaLayer *addSplineAreaLayer(DoubleArray data, int color = -1, const char *name = 0)
|
{ PolarSplineAreaLayer *ret = new PolarSplineAreaLayer(CPolarChart_addSplineAreaLayer(ptr, data.data, data.len, color, name)); reg(ret); return ret; }
|
PolarVectorLayer *addVectorLayer(DoubleArray rData, DoubleArray aData, DoubleArray lengths,
|
DoubleArray directions, int lengthScale = Chart::PixelScale, int color = -1, const char *name = 0)
|
{ PolarVectorLayer *ret = new PolarVectorLayer(CPolarChart_addVectorLayer(ptr, rData.data, rData.len,
|
aData.data, aData.len, lengths.data, lengths.len, directions.data, directions.len, lengthScale, color, name));
|
reg(ret); return ret; }
|
};
|
|
|
class PyramidLayer : public AutoDestroy, protected GarbageContainer
|
{
|
private :
|
//disable copying
|
PyramidLayer(const PyramidLayer &rhs);
|
PyramidLayer &operator=(const PyramidLayer &rhs);
|
|
PyramidLayerInternal *ptr;
|
|
public :
|
PyramidLayer(PyramidLayerInternal *ptr) : ptr(ptr) {}
|
~PyramidLayer() {}
|
|
TextBox *setCenterLabel(const char *labelTemplate = "{skip}", const char *font = "{skip}", double fontSize = -1, int fontColor = -1)
|
{ TextBox *ret = new TextBox(CPyramidLayer_setCenterLabel(ptr, labelTemplate, font, fontSize, fontColor)); reg(ret); return ret; }
|
TextBox *setRightLabel(const char *labelTemplate = "{skip}", const char *font = "{skip}", double fontSize = -1, int fontColor = -1)
|
{ TextBox *ret = new TextBox(CPyramidLayer_setRightLabel(ptr, labelTemplate, font, fontSize, fontColor)); reg(ret); return ret; }
|
TextBox *setLeftLabel(const char *labelTemplate = "{skip}", const char *font = "{skip}", double fontSize = -1, int fontColor = -1)
|
{ TextBox *ret = new TextBox(CPyramidLayer_setLeftLabel(ptr, labelTemplate, font, fontSize, fontColor)); reg(ret); return ret; }
|
|
void setColor(int color)
|
{ CPyramidLayer_setColor(ptr, color); }
|
void setJoinLine(int color , int width = -1)
|
{ CPyramidLayer_setJoinLine(ptr, color, width); }
|
void setJoinLineGap(int pyramidGap, int pyramidMargin = -0x7fffffff, int textGap = -0x7fffffff)
|
{ CPyramidLayer_setJoinLineGap(ptr, pyramidGap, pyramidMargin, textGap); }
|
void setLayerBorder(int color, int width = -1)
|
{ CPyramidLayer_setLayerBorder(ptr, color, width); }
|
void setLayerGap(double layerGap)
|
{ CPyramidLayer_setLayerGap(ptr, layerGap); }
|
};
|
|
|
class PyramidChart : public BaseChart
|
{
|
private :
|
//disable copying
|
PyramidChart(const PyramidChart &rhs);
|
PyramidChart &operator=(const PyramidChart &rhs);
|
|
PyramidChartInternal *ptr;
|
|
public :
|
PyramidChart(int width, int height, int bgColor = Chart::BackgroundColor,
|
int edgeColor = Chart::Transparent, int raisedEffect = 0)
|
{ ptr = CPyramidChart_create(width, height, bgColor, edgeColor, raisedEffect);
|
init(PyramidChart2BaseChart(ptr)); }
|
|
void setPyramidSize(int cx, int cy, int radius, int height)
|
{ CPyramidChart_setPyramidSize(ptr, cx, cy, radius, height); }
|
void setConeSize(int cx, int cy, int radius, int height)
|
{ CPyramidChart_setConeSize(ptr, cx, cy, radius, height); }
|
void setFunnelSize(int cx, int cy, int radius, int height, double tubeRadius = 0.2, double tubeHeight = 0.3)
|
{ CPyramidChart_setFunnelSize(ptr, cx, cy, radius, height, tubeRadius, tubeHeight); }
|
void setData(DoubleArray data, StringArray labels = StringArray())
|
{ CPyramidChart_setData(ptr, data.data, data.len, labels.data, labels.len); }
|
TextBox *setCenterLabel(const char *labelTemplate = "{skip}", const char *font = "{skip}", double fontSize = -1, int fontColor = -1)
|
{ TextBox *ret = new TextBox(CPyramidChart_setCenterLabel(ptr, labelTemplate, font, fontSize, fontColor)); reg(ret); return ret; }
|
TextBox *setRightLabel(const char *labelTemplate = "{skip}", const char *font = "{skip}", double fontSize = -1, int fontColor = -1)
|
{ TextBox *ret = new TextBox(CPyramidChart_setRightLabel(ptr, labelTemplate, font, fontSize, fontColor)); reg(ret); return ret; }
|
TextBox *setLeftLabel(const char *labelTemplate = "{skip}", const char *font = "{skip}", double fontSize = -1, int fontColor = -1)
|
{ TextBox *ret = new TextBox(CPyramidChart_setLeftLabel(ptr, labelTemplate, font, fontSize, fontColor)); reg(ret); return ret; }
|
|
void setPyramidSides(int noOfSides)
|
{ CPyramidChart_setPyramidSides(ptr, noOfSides); }
|
void setViewAngle(double elevation, double rotation = 0, double twist = 0)
|
{ CPyramidChart_setViewAngle(ptr, elevation, rotation, twist); }
|
|
void setGradientShading(double startBrightness, double endBrightness)
|
{ CPyramidChart_setGradientShading(ptr, startBrightness, endBrightness); }
|
void setLighting(double ambientIntensity = 0.5, double diffuseIntensity = 0.5, double specularIntensity = 1, double shininess = 8)
|
{ CPyramidChart_setLighting(ptr, ambientIntensity, diffuseIntensity, specularIntensity, shininess); }
|
|
void setJoinLine(int color, int width = -1)
|
{ CPyramidChart_setJoinLine(ptr, color, width); }
|
void setJoinLineGap(int pyramidGap, int pyramidMargin = -0x7fffffff, int textGap = -0x7fffffff)
|
{ CPyramidChart_setJoinLineGap(ptr, pyramidGap, pyramidMargin, textGap); }
|
void setLayerBorder(int color, int width = -1)
|
{ CPyramidChart_setLayerBorder(ptr, color, width); }
|
void setLayerGap(double layerGap)
|
{ CPyramidChart_setLayerGap(ptr, layerGap); }
|
|
PyramidLayer *getLayer(int layerNo)
|
{ PyramidLayerInternal *p = CPyramidChart_getLayer(ptr, layerNo); if (!p) return 0;
|
PyramidLayer *ret = new PyramidLayer(p); reg(ret); return ret; }
|
};
|
|
|
class MeterPointer : public DrawObj
|
{
|
//disable copying
|
MeterPointer(const MeterPointer &rhs);
|
MeterPointer &operator=(const MeterPointer &rhs);
|
|
MeterPointerInternal *ptr;
|
|
public :
|
MeterPointer(MeterPointerInternal *ptr) : DrawObj(MeterPointer2DrawObj(ptr)), ptr(ptr) {}
|
void setColor(int fillColor, int edgeColor = -1)
|
{ CMeterPointer_setColor(ptr, fillColor, edgeColor); }
|
void setPos(double value) { CMeterPointer_setPos(ptr, value); }
|
void setShape(int pointerType, double lengthRatio = Chart::NoValue, double widthRatio = Chart::NoValue)
|
{ CMeterPointer_setShape(ptr, pointerType, lengthRatio, widthRatio); }
|
void setShape(IntArray pointerCoor, double lengthRatio = Chart::NoValue, double widthRatio = Chart::NoValue)
|
{ CMeterPointer_setShape2(ptr, pointerCoor.data, pointerCoor.len, lengthRatio, widthRatio); }
|
};
|
|
|
class BaseMeter : public BaseChart
|
{
|
private :
|
//disable copying
|
BaseMeter(const BaseMeter &rhs);
|
BaseMeter &operator=(const BaseMeter &rhs);
|
|
BaseMeterInternal *ptr;
|
|
public :
|
BaseMeter() : ptr(0) {}
|
void init(BaseMeterInternal *ptr) { this->ptr = ptr; BaseChart::init(BaseMeter2BaseChart(ptr)); }
|
|
MeterPointer *addPointer(double value, int fillColor = Chart::LineColor, int edgeColor = -1)
|
{ MeterPointer *ret = new MeterPointer(CBaseMeter_addPointer(ptr, value, fillColor, edgeColor)); reg(ret); return ret; }
|
|
void setScale(double lowerLimit, double upperLimit, double majorTickInc = 0, double minorTickInc = 0, double microTickInc = 0)
|
{ CBaseMeter_setScale(ptr, lowerLimit, upperLimit, majorTickInc, minorTickInc, microTickInc); }
|
void setScale(double lowerLimit, double upperLimit, StringArray labels)
|
{ CBaseMeter_setScale2(ptr, lowerLimit, upperLimit, labels.data, labels.len); }
|
void setScale(double lowerLimit, double upperLimit, DoubleArray labels, const char *formatString = 0)
|
{ CBaseMeter_setScale3(ptr, lowerLimit, upperLimit, labels.data, labels.len, formatString); }
|
|
void addLabel(double pos, const char *label) { CBaseMeter_addLabel(ptr, pos, label); }
|
const char *getLabel(double i) const { return CBaseMeter_getLabel(ptr, i); }
|
DoubleArray getTicks() const
|
{ const double *d; int len; CBaseMeter_getTicks(ptr, &d, &len); return DoubleArray(d, len); }
|
|
TextBox *setLabelStyle(const char *font = "bold", double fontSize = -1, int fontColor = Chart::TextColor, double fontAngle = 0)
|
{ TextBox *ret = new TextBox(CBaseMeter_setLabelStyle(ptr, font, fontSize, fontColor, fontAngle)); reg(ret); return ret; }
|
void setLabelPos(bool labelInside, int labelOffset = 0) { CBaseMeter_setLabelPos(ptr, labelInside, labelOffset); }
|
void setLabelFormat(const char *mainLabelFormat) { CBaseMeter_setLabelFormat(ptr, mainLabelFormat); }
|
void setTickLength(int majorLen, int minorLen = -0x7fffffff, int microLen = -0x7fffffff)
|
{ CBaseMeter_setTickLength(ptr, majorLen, minorLen, microLen); }
|
void setLineWidth(int axisWidth, int majorTickWidth = 1, int minorTickWidth = 1, int microTickWidth = 1)
|
{ CBaseMeter_setLineWidth(ptr, axisWidth, majorTickWidth, minorTickWidth, microTickWidth); }
|
void setMeterColors(int axisColor, int labelColor = -1, int tickColor = -1)
|
{ CBaseMeter_setMeterColors(ptr, axisColor, labelColor, tickColor); }
|
|
int getCoor(double v) const { return CBaseMeter_getCoor(ptr, v); }
|
};
|
|
|
class AngularMeter : public BaseMeter
|
{
|
private :
|
//disable copying
|
AngularMeter(const AngularMeter &rhs);
|
AngularMeter &operator=(const AngularMeter &rhs);
|
|
AngularMeterInternal *ptr;
|
|
public :
|
AngularMeter(int width, int height, int bgColor = Chart::BackgroundColor,
|
int edgeColor = Chart::Transparent, int raisedEffect = 0)
|
{ ptr = CAngularMeter_create(width, height, bgColor, edgeColor, raisedEffect);
|
init(AngularMeter2BaseMeter(ptr)); }
|
|
void addRing(int startRadius, int endRadius, int fillColor, int edgeColor = -1)
|
{ CAngularMeter_addRing(ptr, startRadius, endRadius, fillColor, edgeColor); }
|
void addRingSector(int startRadius, int endRadius, double a1, double a2, int fillColor, int edgeColor = -1)
|
{ CAngularMeter_addRingSector(ptr, startRadius, endRadius, a1, a2, fillColor, edgeColor); }
|
void setCap(int radius, int fillColor, int edgeColor = Chart::LineColor)
|
{ CAngularMeter_setCap(ptr, radius, fillColor, edgeColor); }
|
|
void setMeter(int cx, int cy, int radius, double startAngle, double endAngle)
|
{ CAngularMeter_setMeter(ptr, cx, cy, radius, startAngle, endAngle); }
|
|
void addZone(double startValue, double endValue, int startRadius, int endRadius, int fillColor, int edgeColor = -1)
|
{ CAngularMeter_addZone(ptr, startValue, endValue, startRadius, endRadius, fillColor, edgeColor); }
|
void addZone(double startValue, double endValue, int fillColor, int edgeColor = -1)
|
{ CAngularMeter_addZone2(ptr, startValue, endValue, fillColor, edgeColor); }
|
};
|
|
|
class LinearMeter : public BaseMeter
|
{
|
private :
|
//disable copying
|
LinearMeter(const LinearMeter &rhs);
|
LinearMeter &operator=(const LinearMeter &rhs);
|
|
LinearMeterInternal *ptr;
|
|
public :
|
LinearMeter(int width, int height, int bgColor = Chart::BackgroundColor,
|
int edgeColor = Chart::Transparent, int raisedEffect = 0)
|
{ ptr = CLinearMeter_create(width, height, bgColor, edgeColor, raisedEffect);
|
init(LinearMeter2BaseMeter(ptr)); }
|
|
void setMeter(int leftX, int topY, int width, int height, int axisPos = Chart::Left, bool isReversed = false)
|
{ CLinearMeter_setMeter(ptr, leftX, topY, width, height, axisPos, isReversed); }
|
void setRail(int railColor, int railWidth = 2, int railOffset = 6)
|
{ CLinearMeter_setRail(ptr, railColor, railWidth, railOffset); }
|
|
TextBox *addZone(double startValue, double endValue, int color, const char *label = 0)
|
{ TextBox *ret = new TextBox(CLinearMeter_addZone(ptr, startValue, endValue, color, label)); reg(ret); return ret; }
|
};
|
|
|
class ArrayMath
|
{
|
private :
|
ArrayMathInternal *ptr;
|
|
public :
|
ArrayMath(DoubleArray a) : ptr(CArrayMath_create(a.data, a.len)) {}
|
~ArrayMath() { CArrayMath_destroy(ptr); }
|
static ArrayMath *create(DoubleArray a) { return new ArrayMath(a); }
|
void destroy() { delete this; }
|
|
ArrayMath(const ArrayMath &rhs) { DoubleArray r = rhs; ptr = CArrayMath_create(r.data, r.len); }
|
ArrayMath &operator=(const ArrayMath &rhs) { CArrayMath_destroy(ptr); DoubleArray r = rhs; ptr = CArrayMath_create(r.data, r.len); return *this;}
|
operator DoubleArray() const { return result(); }
|
|
ArrayMath& add(DoubleArray b) { CArrayMath_add(ptr, b.data, b.len); return *this; }
|
ArrayMath& add(double b) { CArrayMath_add2(ptr, b); return *this; }
|
ArrayMath& sub(DoubleArray b) { CArrayMath_sub(ptr, b.data, b.len); return *this; }
|
ArrayMath& sub(double b) { CArrayMath_sub2(ptr, b); return *this; }
|
ArrayMath& mul(DoubleArray b) { CArrayMath_mul(ptr, b.data, b.len); return *this; }
|
ArrayMath& mul(double b) { CArrayMath_mul2(ptr, b); return *this; }
|
ArrayMath& div(DoubleArray b) { CArrayMath_div(ptr, b.data, b.len); return *this; }
|
ArrayMath& div(double b) { CArrayMath_div2(ptr, b); return *this; }
|
ArrayMath& financeDiv(DoubleArray b, double zeroByZeroValue) { CArrayMath_financeDiv(ptr, b.data, b.len, zeroByZeroValue); return *this; }
|
ArrayMath& shift(int offset = 1, double fillValue = Chart::NoValue) { CArrayMath_shift(ptr, offset, fillValue); return *this; }
|
ArrayMath& delta(int offset = 1) { CArrayMath_delta(ptr, offset); return *this; }
|
ArrayMath& rate(int offset = 1) { CArrayMath_rate(ptr, offset); return *this; }
|
ArrayMath& abs() { CArrayMath_abs(ptr); return *this; }
|
ArrayMath& acc() { CArrayMath_acc(ptr); return *this; }
|
|
ArrayMath& selectGTZ(DoubleArray decisionArray = DoubleArray(), double fillValue = 0)
|
{ CArrayMath_selectGTZ(ptr, decisionArray.data, decisionArray.len, fillValue); return *this; }
|
ArrayMath& selectGEZ(DoubleArray decisionArray = DoubleArray(), double fillValue = 0)
|
{ CArrayMath_selectGEZ(ptr, decisionArray.data, decisionArray.len, fillValue); return *this; }
|
ArrayMath& selectLTZ(DoubleArray decisionArray = DoubleArray(), double fillValue = 0)
|
{ CArrayMath_selectLTZ(ptr, decisionArray.data, decisionArray.len, fillValue); return *this; }
|
ArrayMath& selectLEZ(DoubleArray decisionArray = DoubleArray(), double fillValue = 0)
|
{ CArrayMath_selectLEZ(ptr, decisionArray.data, decisionArray.len, fillValue); return *this; }
|
ArrayMath& selectEQZ(DoubleArray decisionArray = DoubleArray(), double fillValue = 0)
|
{ CArrayMath_selectEQZ(ptr, decisionArray.data, decisionArray.len, fillValue); return *this; }
|
ArrayMath& selectNEZ(DoubleArray decisionArray = DoubleArray(), double fillValue = 0)
|
{ CArrayMath_selectNEZ(ptr, decisionArray.data, decisionArray.len, fillValue); return *this; }
|
|
ArrayMath& selectStartOfHour(int majorTickStep = 1, double initialMargin = 300)
|
{ CArrayMath_selectStartOfHour(ptr, majorTickStep, initialMargin); return *this; }
|
ArrayMath& selectStartOfDay(int majorTickStep = 1, double initialMargin = 3 * 3600)
|
{ CArrayMath_selectStartOfDay(ptr, majorTickStep, initialMargin); return *this; }
|
ArrayMath& selectStartOfWeek(int majorTickStep = 1, double initialMargin = 2 * 86400)
|
{ CArrayMath_selectStartOfWeek(ptr, majorTickStep, initialMargin); return *this; }
|
ArrayMath& selectStartOfMonth(int majorTickStep = 1, double initialMargin = 5 * 86400)
|
{ CArrayMath_selectStartOfMonth(ptr, majorTickStep, initialMargin); return *this; }
|
ArrayMath& selectStartOfYear(int majorTickStep = 1, double initialMargin = 60 * 86400)
|
{ CArrayMath_selectStartOfYear(ptr, majorTickStep, initialMargin); return *this; }
|
ArrayMath& selectRegularSpacing(int majorTickStep, int minorTickStep = 0, int initialMargin = 0)
|
{ CArrayMath_selectRegularSpacing(ptr, majorTickStep, minorTickStep, initialMargin); return *this; }
|
|
ArrayMath& trim(int startIndex = 0, int len = -1)
|
{ CArrayMath_trim(ptr, startIndex, len); return *this; }
|
ArrayMath& insert(DoubleArray a, int insertPoint = -1)
|
{ CArrayMath_insert(ptr, a.data, a.len, insertPoint); return *this; }
|
ArrayMath& insert(double c, int len, int insertPoint = -1)
|
{ CArrayMath_insert2(ptr, c, len, insertPoint); return *this; }
|
ArrayMath& replace(double a, double b)
|
{ CArrayMath_replace(ptr, a, b); return *this; }
|
|
ArrayMath& movAvg(int interval)
|
{ CArrayMath_movAvg(ptr, interval); return *this; }
|
ArrayMath& expAvg(double smoothingFactor)
|
{ CArrayMath_expAvg(ptr, smoothingFactor); return *this; }
|
ArrayMath& movMed(int interval)
|
{ CArrayMath_movMed(ptr, interval); return *this; }
|
ArrayMath& movPercentile(int interval, double percentile)
|
{ CArrayMath_movPercentile(ptr, interval, percentile); return *this; }
|
ArrayMath& movMax(int interval)
|
{ CArrayMath_movMax(ptr, interval); return *this; }
|
ArrayMath& movMin(int interval)
|
{ CArrayMath_movMin(ptr, interval); return *this; }
|
ArrayMath& movStdDev(int interval)
|
{ CArrayMath_movStdDev(ptr, interval); return *this; }
|
ArrayMath& movCorr(int interval, DoubleArray b = DoubleArray())
|
{ CArrayMath_movCorr(ptr, interval, b.data, b.len); return *this; }
|
ArrayMath& lowess(double smoothness = 0.25, int iteration = 0)
|
{ CArrayMath_lowess(ptr, smoothness, iteration); return *this; }
|
ArrayMath& lowess(DoubleArray b, double smoothness = 0.25, int iteration = 0)
|
{ CArrayMath_lowess2(ptr, b.data, b.len, smoothness, iteration); return *this; }
|
|
DoubleArray result() const { const double *d; int len; CArrayMath_result(ptr, &d, &len); return DoubleArray(d, len); }
|
#ifndef max
|
double max() const { return CArrayMath_max(ptr); }
|
#endif
|
double maxValue() const { return CArrayMath_max(ptr); }
|
#ifndef min
|
double min() const { return CArrayMath_min(ptr); }
|
#endif
|
double minValue() const { return CArrayMath_min(ptr); }
|
double avg() const { return CArrayMath_avg(ptr); }
|
double sum() const { return CArrayMath_sum(ptr); }
|
double stdDev() const { return CArrayMath_stdDev(ptr); }
|
double med() const { return CArrayMath_med(ptr); }
|
double percentile(double p) const { return CArrayMath_percentile(ptr, p); }
|
int maxIndex() const { return CArrayMath_maxIndex(ptr); }
|
int minIndex() const { return CArrayMath_minIndex(ptr); }
|
|
DoubleArray aggregate(DoubleArray srcArray, int aggregateMethod, double param = 50) const
|
{ const double *d; int len; CArrayMath_aggregate(ptr, srcArray.data, srcArray.len, aggregateMethod, param,
|
&d, &len); return DoubleArray(d, len); }
|
};
|
|
|
class RanTable
|
{
|
private :
|
//disable copying
|
RanTable(const RanTable &rhs);
|
RanTable &operator=(const RanTable &rhs);
|
|
RanTableInternal *ptr;
|
|
public :
|
RanTable(int seed, int noOfCols, int noOfRows) : ptr(CRanTable_create(seed, noOfCols, noOfRows)) {}
|
~RanTable() { CRanTable_destroy(ptr); }
|
static RanTable *create(int seed, int noOfCols, int noOfRows) { return new RanTable(seed, noOfCols, noOfRows); }
|
void destroy() { delete this; }
|
|
void setCol(int colNo, double minValue, double maxValue)
|
{ CRanTable_setCol(ptr, colNo, minValue, maxValue); }
|
void setCol(int colNo, double startValue, double minDelta, double maxDelta,
|
double lowerLimit = -1E+308, double upperLimit = 1E+308)
|
{ CRanTable_setCol2(ptr, colNo, startValue, minDelta, maxDelta, lowerLimit, upperLimit); }
|
void setDateCol(int i, double startTime, double tickInc, bool weekDayOnly = false)
|
{ CRanTable_setDateCol(ptr, i, startTime, tickInc, weekDayOnly); }
|
void setHLOCCols(int i, double startValue, double minDelta, double maxDelta,
|
double lowerLimit = 0, double upperLimit = 1E+308)
|
{ CRanTable_setHLOCCols(ptr, i, startValue, minDelta, maxDelta, lowerLimit, upperLimit); }
|
int selectDate(int colNo, double minDate, double maxDate)
|
{ return CRanTable_selectDate(ptr, colNo, minDate, maxDate); }
|
DoubleArray getCol(int i)
|
{ const double *d; int len; CRanTable_getCol(ptr, i, &d, &len); return DoubleArray(d, len); }
|
};
|
|
class RanSeries
|
{
|
private :
|
//disable copying
|
RanSeries(const RanSeries &rhs);
|
RanSeries &operator=(const RanSeries &rhs);
|
|
RanSeriesInternal *ptr;
|
|
public :
|
RanSeries(int seed) : ptr(CRanSeries_create(seed)) {}
|
~RanSeries() { CRanSeries_destroy(ptr); }
|
static RanSeries *create(int seed) { return new RanSeries(seed); }
|
void destroy() { delete this; }
|
|
DoubleArray getSeries(int len, double minValue, double maxValue)
|
{ const double *ret; int retLen; CRanSeries_getSeries(ptr, len, minValue, maxValue, &ret, &retLen);
|
return DoubleArray(ret, retLen); }
|
DoubleArray getSeries(int len, double minValue, double maxValue, double maxDelta,
|
double lowerLimit = -1E+308, double upperLimit = 1E+308)
|
{ const double *ret; int retLen; CRanSeries_getSeries2(ptr, len, minValue, maxValue, maxDelta,
|
lowerLimit, upperLimit, &ret, &retLen); return DoubleArray(ret, retLen); }
|
DoubleArray getDateSeries(int len, double startTime, double tickInc, bool weekDayOnly = false)
|
{ const double *ret; int retLen; CRanSeries_getDateSeries(ptr, len, startTime, tickInc, weekDayOnly,
|
&ret, &retLen); return DoubleArray(ret, retLen); }
|
};
|
|
class FinanceSimulator
|
{
|
private :
|
//disable copying
|
FinanceSimulator(const FinanceSimulator &rhs);
|
FinanceSimulator &operator=(const FinanceSimulator &rhs);
|
|
FinanceSimulatorInternal *ptr;
|
|
public :
|
FinanceSimulator(int seed, double startTime, double endTime, int resolution) :
|
ptr(CFinanceSimulator_create(seed, startTime, endTime, resolution))
|
{}
|
FinanceSimulator(const char *seed, double startTime, double endTime, int resolution) :
|
ptr(CFinanceSimulator_create2(seed, startTime, endTime, resolution))
|
{}
|
~FinanceSimulator() { CFinanceSimulator_destroy(ptr); }
|
|
DoubleArray getTimeStamps()
|
{ const double *d; int len; CFinanceSimulator_getTimeStamps(ptr, &d, &len); return DoubleArray(d, len); }
|
DoubleArray getHighData()
|
{ const double *d; int len; CFinanceSimulator_getHighData(ptr, &d, &len); return DoubleArray(d, len); }
|
DoubleArray getLowData()
|
{ const double *d; int len; CFinanceSimulator_getLowData(ptr, &d, &len); return DoubleArray(d, len); }
|
DoubleArray getOpenData()
|
{ const double *d; int len; CFinanceSimulator_getOpenData(ptr, &d, &len); return DoubleArray(d, len); }
|
DoubleArray getCloseData()
|
{ const double *d; int len; CFinanceSimulator_getCloseData(ptr, &d, &len); return DoubleArray(d, len); }
|
DoubleArray getVolData()
|
{ const double *d; int len; CFinanceSimulator_getVolData(ptr, &d, &len); return DoubleArray(d, len); }
|
};
|
|
class ImageMapHandler
|
{
|
private :
|
//disable copying
|
ImageMapHandler(const ImageMapHandler &rhs);
|
ImageMapHandler &operator=(const ImageMapHandler &rhs);
|
|
ImageMapHandlerInternal *ptr;
|
|
public :
|
ImageMapHandler(const char *imageMap) : ptr(CImageMapHandler_create(imageMap)) {}
|
~ImageMapHandler() { CImageMapHandler_destroy(ptr); }
|
|
int getHotSpot(int x, int y)
|
{ return CImageMapHandler_getHotSpot(ptr, x, y); }
|
const char *getValue(const char *key)
|
{ return CImageMapHandler_getValue(ptr, key); }
|
const char *getKey(int i)
|
{ return CImageMapHandler_getKey(ptr, i); }
|
const char *getValue(int i)
|
{ return CImageMapHandler_getValue2(ptr, i); }
|
};
|
|
class ViewPortManager
|
{
|
private :
|
//disable copying
|
ViewPortManager(const ViewPortManager &rhs);
|
ViewPortManager &operator=(const ViewPortManager &rhs);
|
|
ViewPortManagerInternal *ptr;
|
|
public :
|
|
ViewPortManager() : ptr(CViewPortManager_create()) {}
|
~ViewPortManager() { CViewPortManager_destroy(ptr); }
|
|
void setChartMetrics(const char *metrics) { CViewPortManager_setChartMetrics(ptr, metrics); }
|
int getPlotAreaLeft() { return CViewPortManager_getPlotAreaLeft(ptr); }
|
int getPlotAreaTop() { return CViewPortManager_getPlotAreaTop(ptr); }
|
int getPlotAreaWidth() { return CViewPortManager_getPlotAreaWidth(ptr); }
|
int getPlotAreaHeight() { return CViewPortManager_getPlotAreaHeight(ptr); }
|
bool inPlotArea(int x, int y) { return CViewPortManager_inPlotArea(ptr, x, y); }
|
|
double getViewPortLeft() { return CViewPortManager_getViewPortLeft(ptr); }
|
void setViewPortLeft(double left) { CViewPortManager_setViewPortLeft(ptr, left); }
|
double getViewPortTop() { return CViewPortManager_getViewPortTop(ptr); }
|
void setViewPortTop(double top) { CViewPortManager_setViewPortTop(ptr, top); }
|
double getViewPortWidth() { return CViewPortManager_getViewPortWidth(ptr); }
|
void setViewPortWidth(double width) { CViewPortManager_setViewPortWidth(ptr, width); }
|
double getViewPortHeight() { return CViewPortManager_getViewPortHeight(ptr); }
|
void setViewPortHeight(double height) { CViewPortManager_setViewPortHeight(ptr, height); }
|
void validateViewPort() { CViewPortManager_validateViewPort(ptr); }
|
|
double getZoomInWidthLimit() { return CViewPortManager_getZoomInWidthLimit(ptr); }
|
void setZoomInWidthLimit(double viewPortWidth) { CViewPortManager_setZoomInWidthLimit(ptr, viewPortWidth); }
|
double getZoomOutWidthLimit() { return CViewPortManager_getZoomOutWidthLimit(ptr); }
|
void setZoomOutWidthLimit(double viewPortWidth){ CViewPortManager_setZoomOutWidthLimit(ptr, viewPortWidth); }
|
double getZoomInHeightLimit() { return CViewPortManager_getZoomInHeightLimit(ptr); }
|
void setZoomInHeightLimit(double viewPortHeight) { CViewPortManager_setZoomInHeightLimit(ptr, viewPortHeight); }
|
double getZoomOutHeightLimit() { return CViewPortManager_getZoomOutHeightLimit(ptr); }
|
void setZoomOutHeightLimit(double viewPortHeight){ CViewPortManager_setZoomOutHeightLimit(ptr, viewPortHeight); }
|
bool canZoomIn(int zoomDirection) { return CViewPortManager_canZoomIn(ptr, zoomDirection); }
|
bool canZoomOut(int zoomDirection) { return CViewPortManager_canZoomOut(ptr, zoomDirection); }
|
bool zoomAt(int zoomDirection, int x, int y, double zoomRatio)
|
{ return CViewPortManager_zoomAt(ptr, zoomDirection, x, y, zoomRatio); }
|
bool zoomTo(int zoomDirection, int x1, int y1, int x2, int y2)
|
{ return CViewPortManager_zoomTo(ptr, zoomDirection, x1, y1, x2, y2); }
|
|
void startDrag() { CViewPortManager_startDrag(ptr); }
|
bool dragTo(int scrollDirection, int deltaX, int deltaY)
|
{ return CViewPortManager_dragTo(ptr, scrollDirection, deltaX, deltaY); }
|
|
void setFullRange(const char *id, double minValue, double maxValue)
|
{ CViewPortManager_setFullRange(ptr, id, minValue, maxValue); }
|
void clearAllRanges()
|
{ CViewPortManager_clearAllRanges(ptr); }
|
double getValueAtViewPort(const char *id, double ratio, bool isLogScale = false)
|
{ return CViewPortManager_getValueAtViewPort(ptr, id, ratio, isLogScale); }
|
double getViewPortAtValue(const char *id, double ratio, bool isLogScale = false)
|
{ return CViewPortManager_getViewPortAtValue(ptr, id, ratio, isLogScale); }
|
void syncLinearAxisWithViewPort(const char *id, Axis *axis)
|
{ CViewPortManager_syncLinearAxisWithViewPort(ptr, id, axis->getInternalPtr()); }
|
void syncLogAxisWithViewPort(const char *id, Axis *axis)
|
{ CViewPortManager_syncLogAxisWithViewPort(ptr, id, axis->getInternalPtr()); }
|
void syncDateAxisWithViewPort(const char *id, Axis *axis)
|
{ CViewPortManager_syncDateAxisWithViewPort(ptr, id, axis->getInternalPtr()); }
|
void commitPendingSyncAxis(BaseChart *c)
|
{ CViewPortManager_commitPendingSyncAxis(ptr, c->getInternalPtr()); }
|
|
void setPlotAreaMouseMargin(int leftMargin, int rightMargin, int topMargin, int bottomMargin)
|
{ CViewPortManager_setPlotAreaMouseMargin(ptr, leftMargin, rightMargin, topMargin, bottomMargin); }
|
bool inExtendedPlotArea(int x, int y)
|
{ return CViewPortManager_inExtendedPlotArea(ptr, x, y); }
|
};
|
|
|
#ifndef CHARTDIR_HIDE_OBSOLETE
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
// This section is obsoleted - retained for compatibility only.
|
// Global identifiers are now moved into the Chart namespace
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
static const double LogTick = +1.6e308;
|
static const double NoValue = +1.7e308;
|
static const double TouchBar = -1.7E-100;
|
|
enum Alignment
|
{
|
TopLeft = 7, TopCenter = 8, TopRight = 9,
|
Left = 4, Center = 5, Right = 6,
|
BottomLeft = 1, BottomCenter = 2, BottomRight = 3,
|
Top = TopCenter,
|
Bottom = BottomCenter
|
};
|
|
enum
|
{
|
DashLine = 0x0505,
|
DotLine = 0x0202,
|
DotDashLine = 0x05050205,
|
AltDashLine = 0x0A050505
|
};
|
|
static const int * const goldGradient = Chart::goldGradient;
|
static const int * const silverGradient = Chart::silverGradient;
|
static const int * const redMetalGradient = Chart::redMetalGradient;
|
static const int * const blueMetalGradient = Chart::blueMetalGradient;
|
static const int * const greenMetalGradient = Chart::greenMetalGradient;
|
|
enum AntiAliasMode { NoAntiAlias, AntiAlias, AutoAntiAlias };
|
enum PaletteMode { TryPalette, ForcePalette, NoPalette };
|
enum DitherMethod { Quantize, OrderedDither, ErrorDiffusion };
|
|
enum CDFilterType { BoxFilter, LinearFilter, QuadraticFilter, BSplineFilter, HermiteFilter,
|
CatromFilter, MitchellFilter, SincFilter, LanczosFilter, GaussianFilter, HanningFilter,
|
HammingFilter, BlackmanFilter, BesselFilter };
|
|
enum
|
{
|
Transparent = 0xff000000,
|
Palette = 0xffff0000,
|
BackgroundColor = 0xffff0000,
|
LineColor = 0xffff0001,
|
TextColor = 0xffff0002,
|
DataColor = 0xffff0008,
|
SameAsMainColor = 0xffff0007
|
};
|
|
enum ImgFormat {PNG, GIF, JPG, WMP, BMP};
|
|
static const int * const oldDefaultPalette = Chart::oldDefaultPalette;
|
static const int * const defaultPalette = Chart::defaultPalette;
|
static const int * const whiteOnBlackPalette = Chart::whiteOnBlackPalette;
|
static const int * const transparentPalette = Chart::transparentPalette;
|
|
enum {SideLayout, CircleLayout};
|
|
enum SymbolType
|
{
|
NoSymbol = 0,
|
SquareSymbol = 1,
|
DiamondSymbol = 2,
|
TriangleSymbol = 3,
|
RightTriangleSymbol = 4,
|
LeftTriangleSymbol = 5,
|
InvertedTriangleSymbol = 6,
|
CircleSymbol = 7,
|
CrossSymbol = 8,
|
Cross2Symbol = 9
|
};
|
|
enum DataCombineMethod { Overlay, Stack, Depth, Side, Percentage };
|
|
enum LegendMode { NormalLegend, ReverseLegend, NoLegend };
|
|
enum ScaleType { PixelScale, XAxisScale, YAxisScale,
|
AngularAxisScale = XAxisScale, RadialAxisScale = YAxisScale };
|
|
static inline int getVersion() { return Chart::getVersion(); }
|
static inline const char * getDescription() { return Chart::getDescription(); }
|
static inline const char * getCopyright() { return Chart::getCopyright(); }
|
|
static inline bool testFont(const char *font, int fontIndex, double fontHeight,
|
double fontWidth, double angle, char *buffer)
|
{ return Chart::testFont(font, fontIndex, fontHeight, fontWidth, angle, buffer); }
|
|
static inline bool isLicensed() { return Chart::isLicensed(); }
|
static inline bool getLicenseAttr(const char *key, char *buffer)
|
{ return Chart::getLicenseAttr(key, buffer); }
|
static inline bool setLicenseFile(const char *filename = 0, char *buffer = 0)
|
{ return Chart::setLicenseFile(filename, buffer); }
|
static inline bool setLicenseCode(const char *licCode, char *buffer = 0)
|
{ return Chart::setLicenseCode(licCode, buffer); }
|
|
static inline double chartTime(int y, int m, int d, int h = 0, int n = 0, int s = 0)
|
{ return Chart::chartTime(y, m, d, h, n, s); }
|
static inline double chartTime2(int t)
|
{ return Chart::chartTime2(t); }
|
|
//#ifndef CHARTDIR_HIDE_OBSOLETE
|
#endif
|
|
//#ifndef CCHARTDIR_HDR
|
#endif
|
