#if !defined(OCH2DOWL_H)
#define OCH2DOWL_H

 /******************************************************************************
 *
 * Copyright (c) 1999, KL GROUP INC.  All Rights Reserved.
 * http://www.klgroup.com
 *
 * This file is provided for demonstration and educational uses only.
 * Permission to use, copy, modify and distribute this file for
 * any purpose and without fee is hereby granted, provided that the
 * above copyright notice and this permission notice appear in all
 * copies, and that the name of KL Group not be used in advertising
 * or publicity pertaining to this material without the specific,
 * prior written permission of an authorized representative of
 * KL Group.
 *
 * KL GROUP MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY
 * OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
 * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, OR NON-INFRINGEMENT. KL GROUP SHALL NOT BE LIABLE FOR ANY
 * DAMAGES SUFFERED BY USERS AS A RESULT OF USING, MODIFYING OR
 * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
 *
 ******************************************************************************/

/* ========================================================================
 *                 How to use the OWL wrapper classes:
 * ========================================================================
 * The OWL wrapper classes below provide a fairly flat wrapper around
 * the native Olectra Chart DLL function calls.
 *
 * If you wish to develop using the OCX, please *DO NOT* use these header
 * files. They are for use in C++ based, straight DLL programming only.
 *
 * To find more information about the "get" and "set" methods given below,
 * look up the associated property in the DLL manual. Properties are always
 * the second parameter in methods that wrap "GetValues" or "SetValues" DLL
 * calls. For example, to find out about GetFooterWidth(), look up the
 * XRT_FOOTER_WIDTH property.
 *
 * To find more information about the "operations" methods given below,
 * look up the wrapped DLL call directly. For example, to find out about
 * Pick(), look up the "XrtPick" function in the DLL manual.
 *
 * ------------------------------------
 * The main class, TChart2D, derives from TControl. The majority of native
 * Olectra Chart DLL calls require a handle to the chart (usually shown in
 * the DLL manual as HXRT2D hChart) as the first parameter. TChart2D wraps
 * these calls and provides straightforward names for the access functions.
 *
 * As with a TControl, you construct a TChart2D object in two steps. First,
 * call the constructor, which in turn constructs the associated TControl
 * object.  Then call the Create method, which creates and sets up the
 * TControl, then creates the Chart and attaches the Windows child window
 * to it.
 *
 * ------------------------------------
 * The TChart2DText class is normally created via a call to "new". Always
 * remember to free these objects via "delete" at the end of execution!
 *
 * TChart2DText wraps Olectra Chart DLL calls that require a data handle
 * (usually shown in the DLL manual as XrtTextHandle text) as the first
 * parameter. TChart2DText wraps these calls and provides more
 * straightforward names for the access functions.
 *
 * ------------------------------------
 * The TChart2DPointStyle class is normally created via a call to "new".
 * Always remember to free these objects via "delete" at the end of
 * execution!
 *
 * TChart2DPointStyle wraps Olectra Chart DLL calls that require a point
 * style handle (usually shown in the DLL manual as XrtPointStyleHandle)
 * as the first parameter. TChart2DPointStyle wraps these calls and
 * provides more straightforward names for the access functions.
 *
 * ------------------------------------
 * The TChart2DData class is normally created via a call to "new". Always
 * remember to free these objects via "delete" at the end of execution!
 *
 * TChart2DData objects can be constructed in one of four ways:
 *   (i)  You can allocate an empty data object of either Array or General
 *        data. In addition to the type, you must specify the number of
 *        sets (called Series by the OCX) and the number of points in each
 *        set. This constructor calls the DLL's XrtDataCreate() function.
 *  (ii)  You can allocate a data object and load it with data
 *        specified in a text file. This constructor calls the DLL's
 *        XrtDataCreateFromFile() function.
 *  (iii) You can allocate a data object and copy the data from another
 *        provided data object. This constructor calls the DLL's
 *        XrtDataCopy() function.
 *  (iv)  You can directly assign a data handle acquired from another
 *        source. This would allow multiple charts to share a common
 *        data object.
 *
 * TChart2DData wraps Olectra Chart DLL calls that require a data handle
 * (usually shown in the DLL manual as XrtDataHandle hData) as the first
 * parameter. TChart2DData wraps these calls and provides more
 * straightforward names for the access functions.
 *
 * ==========================================================================
 */

#if !defined(OWL_CONTROL_H)
# include <owl/control.h>
#endif
#if !defined(CLASSLIB_ARRAYS_H)
# include <classlib/arrays.h>
#endif

#include <olch2d.h>

/*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 *
 *  Class TChart2D
 *
 *-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
*/

class _OWLCLASS TChart2D : public TControl {
  public:
    TChart2D(TWindow* parent, int id, int x, int y, int w, int h, TModule* module = 0);
    TChart2D(TWindow* parent, int resourceId, TModule* module = 0);
    virtual ~TChart2D() { if (HChart) { XrtDestroy(HChart); } }

    // Get methods
    XrtAngleUnit GetAngleUnit() { XrtAngleUnit val; XrtGetValues(HChart, XRT_ANGLE_UNIT, &val, NULL); return(val); }
    BOOL GetAxisBoundingBox() { BOOL val; XrtGetValues(HChart, XRT_AXIS_BOUNDING_BOX, &val, NULL); return(val); }
    HFONT GetAxisFont() { HFONT val; XrtGetValues(HChart, XRT_AXIS_FONT, &val, NULL); return(val); }
    COLORREF GetBackgroundColor() { COLORREF val; XrtGetValues(HChart, XRT_BACKGROUND_COLOR, &val, NULL); return(val); }
    int GetBarClusterOverlap() { int val; XrtGetValues(HChart, XRT_BAR_CLUSTER_OVERLAP, &val, NULL); return(val); }
    int GetBarClusterWidth() { int val; XrtGetValues(HChart, XRT_BAR_CLUSTER_WIDTH, &val, NULL); return(val); }
    XrtBorder GetBorder() { XrtBorder val; XrtGetValues(HChart, XRT_BORDER, &val, NULL); return(val); }
    int GetBorderWidth() { int val; XrtGetValues(HChart, XRT_BORDER_WIDTH, &val, NULL); return(val); }
    double GetBubbleMax() { double val; XrtGetValues(HChart, XRT_BUBBLE_MAX, &val, NULL); return(val); }
    XrtBubbleMethod GetBubbleMethod() { XrtBubbleMethod val; XrtGetValues(HChart, XRT_BUBBLE_METHOD, &val, NULL); return(val); }
    double GetBubbleMin() { double val; XrtGetValues(HChart, XRT_BUBBLE_MIN, &val, NULL); return(val); }
    BOOL GetCandleComplex() { BOOL val; XrtGetValues(HChart, XRT_CANDLE_COMPLEX, &val, NULL); return(val); }
    XrtDataHandle GetData() { XrtDataHandle val; XrtGetValues(HChart, XRT_DATA, &val, NULL); return(val); }
    XrtDataHandle GetData2() { XrtDataHandle val; XrtGetValues(HChart, XRT_DATA2, &val, NULL); return(val); }
    COLORREF GetDataAreaBackgroundColor() { COLORREF val; XrtGetValues(HChart, XRT_DATA_AREA_BACKGROUND_COLOR, &val, NULL); return(val); }
    COLORREF GetDataAreaForegroundColor() { COLORREF val; XrtGetValues(HChart, XRT_DATA_AREA_FOREGROUND_COLOR, &val, NULL); return(val); }
    XrtImage GetDataAreaImage() { XrtImage val; XrtGetValues(HChart, XRT_DATA_AREA_IMAGE, &val, NULL); return(val); }
    XrtImageLayout GetDataAreaImageLayout() { XrtImageLayout val; XrtGetValues(HChart, XRT_DATA_AREA_IMAGE_LAYOUT, &val, NULL); return(val); }
    char * GetDataAreaImageObsolete() { char * val; XrtGetValues(HChart, XRT_DATA_AREA_IMAGE_OBSOLETE, &val, NULL); return(val); }
    XrtDataStyle ** GetDataStyles() { XrtDataStyle ** val; XrtGetValues(HChart, XRT_DATA_STYLES, &val, NULL); return(val); }
    XrtDataStyle ** GetDataStyles2() { XrtDataStyle ** val; XrtGetValues(HChart, XRT_DATA_STYLES2, &val, NULL); return(val); }
    BOOL GetDataStyles2UseDefault() { BOOL val; XrtGetValues(HChart, XRT_DATA_STYLES2_USE_DEFAULT, &val, NULL); return(val); }
    BOOL GetDataStylesUseDefault() { BOOL val; XrtGetValues(HChart, XRT_DATA_STYLES_USE_DEFAULT, &val, NULL); return(val); }
    BOOL GetDebug() { BOOL val; XrtGetValues(HChart, XRT_DEBUG, &val, NULL); return(val); }
    BOOL GetDoubleBuffer() { BOOL val; XrtGetValues(HChart, XRT_DOUBLE_BUFFER, &val, NULL); return(val); }
    BOOL GetExtraDefaultDataStyles() { BOOL val; XrtGetValues(HChart, XRT_EXTRA_DEFAULT_DATA_STYLES, &val, NULL); return(val); }
    XrtAdjust GetFooterAdjust() { XrtAdjust val; XrtGetValues(HChart, XRT_FOOTER_ADJUST, &val, NULL); return(val); }
    COLORREF GetFooterBackgroundColor() { COLORREF val; XrtGetValues(HChart, XRT_FOOTER_BACKGROUND_COLOR, &val, NULL); return(val); }
    XrtBorder GetFooterBorder() { XrtBorder val; XrtGetValues(HChart, XRT_FOOTER_BORDER, &val, NULL); return(val); }
    int GetFooterBorderWidth() { int val; XrtGetValues(HChart, XRT_FOOTER_BORDER_WIDTH, &val, NULL); return(val); }
    HFONT GetFooterFont() { HFONT val; XrtGetValues(HChart, XRT_FOOTER_FONT, &val, NULL); return(val); }
    COLORREF GetFooterForegroundColor() { COLORREF val; XrtGetValues(HChart, XRT_FOOTER_FOREGROUND_COLOR, &val, NULL); return(val); }
    int GetFooterHeight() { int val; XrtGetValues(HChart, XRT_FOOTER_HEIGHT, &val, NULL); return(val); }
    XrtImage GetFooterImage() { XrtImage val; XrtGetValues(HChart, XRT_FOOTER_IMAGE, &val, NULL); return(val); }
    XrtImageLayout GetFooterImageLayout() { XrtImageLayout val; XrtGetValues(HChart, XRT_FOOTER_IMAGE_LAYOUT, &val, NULL); return(val); }
    BOOL GetFooterImageMinimumSize() { BOOL val; XrtGetValues(HChart, XRT_FOOTER_IMAGE_MINIMUM_SIZE, &val, NULL); return(val); }
    char * GetFooterImageObsolete() { char * val; XrtGetValues(HChart, XRT_FOOTER_IMAGE_OBSOLETE, &val, NULL); return(val); }
    char ** GetFooterStrings() { char ** val; XrtGetValues(HChart, XRT_FOOTER_STRINGS, &val, NULL); return(val); }
    int GetFooterWidth() { int val; XrtGetValues(HChart, XRT_FOOTER_WIDTH, &val, NULL); return(val); }
    int GetFooterX() { int val; XrtGetValues(HChart, XRT_FOOTER_X, &val, NULL); return(val); }
    BOOL GetFooterXUseDefault() { BOOL val; XrtGetValues(HChart, XRT_FOOTER_X_USE_DEFAULT, &val, NULL); return(val); }
    int GetFooterY() { int val; XrtGetValues(HChart, XRT_FOOTER_Y, &val, NULL); return(val); }
    BOOL GetFooterYUseDefault() { BOOL val; XrtGetValues(HChart, XRT_FOOTER_Y_USE_DEFAULT, &val, NULL); return(val); }
    COLORREF GetForegroundColor() { COLORREF val; XrtGetValues(HChart, XRT_FOREGROUND_COLOR, &val, NULL); return(val); }
    int GetFrontDataset() { int val; XrtGetValues(HChart, XRT_FRONT_DATASET, &val, NULL); return(val); }
    XrtShading GetGraph3dShading() { XrtShading val; XrtGetValues(HChart, XRT_GRAPH_3D_SHADING, &val, NULL); return(val); }
    COLORREF GetGraphBackgroundColor() { COLORREF val; XrtGetValues(HChart, XRT_GRAPH_BACKGROUND_COLOR, &val, NULL); return(val); }
    XrtBorder GetGraphBorder() { XrtBorder val; XrtGetValues(HChart, XRT_GRAPH_BORDER, &val, NULL); return(val); }
    int GetGraphBorderWidth() { int val; XrtGetValues(HChart, XRT_GRAPH_BORDER_WIDTH, &val, NULL); return(val); }
    int GetGraphDepth() { int val; XrtGetValues(HChart, XRT_GRAPH_DEPTH, &val, NULL); return(val); }
    COLORREF GetGraphForegroundColor() { COLORREF val; XrtGetValues(HChart, XRT_GRAPH_FOREGROUND_COLOR, &val, NULL); return(val); }
    int GetGraphHeight() { int val; XrtGetValues(HChart, XRT_GRAPH_HEIGHT, &val, NULL); return(val); }
    BOOL GetGraphHeightUseDefault() { BOOL val; XrtGetValues(HChart, XRT_GRAPH_HEIGHT_USE_DEFAULT, &val, NULL); return(val); }
    XrtImage GetGraphImage() { XrtImage val; XrtGetValues(HChart, XRT_GRAPH_IMAGE, &val, NULL); return(val); }
    XrtImageLayout GetGraphImageLayout() { XrtImageLayout val; XrtGetValues(HChart, XRT_GRAPH_IMAGE_LAYOUT, &val, NULL); return(val); }
    char * GetGraphImageObsolete() { char * val; XrtGetValues(HChart, XRT_GRAPH_IMAGE_OBSOLETE, &val, NULL); return(val); }
    int GetGraphInclination() { int val; XrtGetValues(HChart, XRT_GRAPH_INCLINATION, &val, NULL); return(val); }
    int GetGraphMarginBottom() { int val; XrtGetValues(HChart, XRT_GRAPH_MARGIN_BOTTOM, &val, NULL); return(val); }
    BOOL GetGraphMarginBottomUseDefault() { BOOL val; XrtGetValues(HChart, XRT_GRAPH_MARGIN_BOTTOM_USE_DEFAULT, &val, NULL); return(val); }
    int GetGraphMarginLeft() { int val; XrtGetValues(HChart, XRT_GRAPH_MARGIN_LEFT, &val, NULL); return(val); }
    BOOL GetGraphMarginLeftUseDefault() { BOOL val; XrtGetValues(HChart, XRT_GRAPH_MARGIN_LEFT_USE_DEFAULT, &val, NULL); return(val); }
    int GetGraphMarginRight() { int val; XrtGetValues(HChart, XRT_GRAPH_MARGIN_RIGHT, &val, NULL); return(val); }
    BOOL GetGraphMarginRightUseDefault() { BOOL val; XrtGetValues(HChart, XRT_GRAPH_MARGIN_RIGHT_USE_DEFAULT, &val, NULL); return(val); }
    int GetGraphMarginTop() { int val; XrtGetValues(HChart, XRT_GRAPH_MARGIN_TOP, &val, NULL); return(val); }
    BOOL GetGraphMarginTopUseDefault() { BOOL val; XrtGetValues(HChart, XRT_GRAPH_MARGIN_TOP_USE_DEFAULT, &val, NULL); return(val); }
    int GetGraphRotation() { int val; XrtGetValues(HChart, XRT_GRAPH_ROTATION, &val, NULL); return(val); }
    BOOL GetGraphShowOutlines() { BOOL val; XrtGetValues(HChart, XRT_GRAPH_SHOW_OUTLINES, &val, NULL); return(val); }
    int GetGraphWidth() { int val; XrtGetValues(HChart, XRT_GRAPH_WIDTH, &val, NULL); return(val); }
    BOOL GetGraphWidthUseDefault() { BOOL val; XrtGetValues(HChart, XRT_GRAPH_WIDTH_USE_DEFAULT, &val, NULL); return(val); }
    int GetGraphX() { int val; XrtGetValues(HChart, XRT_GRAPH_X, &val, NULL); return(val); }
    BOOL GetGraphXUseDefault() { BOOL val; XrtGetValues(HChart, XRT_GRAPH_X_USE_DEFAULT, &val, NULL); return(val); }
    int GetGraphY() { int val; XrtGetValues(HChart, XRT_GRAPH_Y, &val, NULL); return(val); }
    BOOL GetGraphYUseDefault() { BOOL val; XrtGetValues(HChart, XRT_GRAPH_Y_USE_DEFAULT, &val, NULL); return(val); }
    XrtAdjust GetHeaderAdjust() { XrtAdjust val; XrtGetValues(HChart, XRT_HEADER_ADJUST, &val, NULL); return(val); }
    COLORREF GetHeaderBackgroundColor() { COLORREF val; XrtGetValues(HChart, XRT_HEADER_BACKGROUND_COLOR, &val, NULL); return(val); }
    XrtBorder GetHeaderBorder() { XrtBorder val; XrtGetValues(HChart, XRT_HEADER_BORDER, &val, NULL); return(val); }
    int GetHeaderBorderWidth() { int val; XrtGetValues(HChart, XRT_HEADER_BORDER_WIDTH, &val, NULL); return(val); }
    HFONT GetHeaderFont() { HFONT val; XrtGetValues(HChart, XRT_HEADER_FONT, &val, NULL); return(val); }
    COLORREF GetHeaderForegroundColor() { COLORREF val; XrtGetValues(HChart, XRT_HEADER_FOREGROUND_COLOR, &val, NULL); return(val); }
    int GetHeaderHeight() { int val; XrtGetValues(HChart, XRT_HEADER_HEIGHT, &val, NULL); return(val); }
    XrtImage GetHeaderImage() { XrtImage val; XrtGetValues(HChart, XRT_HEADER_IMAGE, &val, NULL); return(val); }
    XrtImageLayout GetHeaderImageLayout() { XrtImageLayout val; XrtGetValues(HChart, XRT_HEADER_IMAGE_LAYOUT, &val, NULL); return(val); }
    BOOL GetHeaderImageMinimumSize() { BOOL val; XrtGetValues(HChart, XRT_HEADER_IMAGE_MINIMUM_SIZE, &val, NULL); return(val); }
    char * GetHeaderImageObsolete() { char * val; XrtGetValues(HChart, XRT_HEADER_IMAGE_OBSOLETE, &val, NULL); return(val); }
    char ** GetHeaderStrings() { char ** val; XrtGetValues(HChart, XRT_HEADER_STRINGS, &val, NULL); return(val); }
    int GetHeaderWidth() { int val; XrtGetValues(HChart, XRT_HEADER_WIDTH, &val, NULL); return(val); }
    int GetHeaderX() { int val; XrtGetValues(HChart, XRT_HEADER_X, &val, NULL); return(val); }
    BOOL GetHeaderXUseDefault() { BOOL val; XrtGetValues(HChart, XRT_HEADER_X_USE_DEFAULT, &val, NULL); return(val); }
    int GetHeaderY() { int val; XrtGetValues(HChart, XRT_HEADER_Y, &val, NULL); return(val); }
    BOOL GetHeaderYUseDefault() { BOOL val; XrtGetValues(HChart, XRT_HEADER_Y_USE_DEFAULT, &val, NULL); return(val); }
    int GetHeight() { int val; XrtGetValues(HChart, XRT_HEIGHT, &val, NULL); return(val); }
    BOOL GetHiloCloseShow() { BOOL val; XrtGetValues(HChart, XRT_HILO_CLOSE_SHOW, &val, NULL); return(val); }
    BOOL GetHiloOpenCloseFullWidth() { BOOL val; XrtGetValues(HChart, XRT_HILO_OPEN_CLOSE_FULL_WIDTH, &val, NULL); return(val); }
    BOOL GetHiloOpenShow() { BOOL val; XrtGetValues(HChart, XRT_HILO_OPEN_SHOW, &val, NULL); return(val); }
    XrtImage GetImage() { XrtImage val; XrtGetValues(HChart, XRT_IMAGE, &val, NULL); return(val); }
    XrtImageLayout GetImageLayout() { XrtImageLayout val; XrtGetValues(HChart, XRT_IMAGE_LAYOUT, &val, NULL); return(val); }
    char * GetImageObsolete() { char * val; XrtGetValues(HChart, XRT_IMAGE_OBSOLETE, &val, NULL); return(val); }
    BOOL GetInvertOrientation() { BOOL val; XrtGetValues(HChart, XRT_INVERT_ORIENTATION, &val, NULL); return(val); }
    BOOL GetIsStacked() { BOOL val; XrtGetValues(HChart, XRT_IS_STACKED, &val, NULL); return(val); }
    BOOL GetIsStacked2() { BOOL val; XrtGetValues(HChart, XRT_IS_STACKED2, &val, NULL); return(val); }
    XrtAnchor GetLegendAnchor() { XrtAnchor val; XrtGetValues(HChart, XRT_LEGEND_ANCHOR, &val, NULL); return(val); }
    COLORREF GetLegendBackgroundColor() { COLORREF val; XrtGetValues(HChart, XRT_LEGEND_BACKGROUND_COLOR, &val, NULL); return(val); }
    XrtBorder GetLegendBorder() { XrtBorder val; XrtGetValues(HChart, XRT_LEGEND_BORDER, &val, NULL); return(val); }
    int GetLegendBorderWidth() { int val; XrtGetValues(HChart, XRT_LEGEND_BORDER_WIDTH, &val, NULL); return(val); }
    HFONT GetLegendFont() { HFONT val; XrtGetValues(HChart, XRT_LEGEND_FONT, &val, NULL); return(val); }
    COLORREF GetLegendForegroundColor() { COLORREF val; XrtGetValues(HChart, XRT_LEGEND_FOREGROUND_COLOR, &val, NULL); return(val); }
    int GetLegendHeight() { int val; XrtGetValues(HChart, XRT_LEGEND_HEIGHT, &val, NULL); return(val); }
    XrtImage GetLegendImage() { XrtImage val; XrtGetValues(HChart, XRT_LEGEND_IMAGE, &val, NULL); return(val); }
    XrtImageLayout GetLegendImageLayout() { XrtImageLayout val; XrtGetValues(HChart, XRT_LEGEND_IMAGE_LAYOUT, &val, NULL); return(val); }
    char * GetLegendImageObsolete() { char * val; XrtGetValues(HChart, XRT_LEGEND_IMAGE_OBSOLETE, &val, NULL); return(val); }
    XrtAlign GetLegendOrientation() { XrtAlign val; XrtGetValues(HChart, XRT_LEGEND_ORIENTATION, &val, NULL); return(val); }
    BOOL GetLegendReversed() { BOOL val; XrtGetValues(HChart, XRT_LEGEND_REVERSED, &val, NULL); return(val); }
    BOOL GetLegendShow() { BOOL val; XrtGetValues(HChart, XRT_LEGEND_SHOW, &val, NULL); return(val); }
    char * GetLegendTitle() { char * val; XrtGetValues(HChart, XRT_LEGEND_TITLE, &val, NULL); return(val); }
    int GetLegendWidth() { int val; XrtGetValues(HChart, XRT_LEGEND_WIDTH, &val, NULL); return(val); }
    int GetLegendX() { int val; XrtGetValues(HChart, XRT_LEGEND_X, &val, NULL); return(val); }
    BOOL GetLegendXUseDefault() { BOOL val; XrtGetValues(HChart, XRT_LEGEND_X_USE_DEFAULT, &val, NULL); return(val); }
    int GetLegendY() { int val; XrtGetValues(HChart, XRT_LEGEND_Y, &val, NULL); return(val); }
    BOOL GetLegendYUseDefault() { BOOL val; XrtGetValues(HChart, XRT_LEGEND_Y_USE_DEFAULT, &val, NULL); return(val); }
    XrtDataStyle * GetMarkerDataStyle() { XrtDataStyle * val; XrtGetValues(HChart, XRT_MARKER_DATA_STYLE, &val, NULL); return(val); }
    BOOL GetMarkerDataStyleUseDefault() { BOOL val; XrtGetValues(HChart, XRT_MARKER_DATA_STYLE_USE_DEFAULT, &val, NULL); return(val); }
    int GetMarkerDataset() { int val; XrtGetValues(HChart, XRT_MARKER_DATASET, &val, NULL); return(val); }
    char * GetName() { char * val; XrtGetValues(HChart, XRT_NAME, &val, NULL); return(val); }
    XrtDataStyle * GetOtherDataStyle() { XrtDataStyle * val; XrtGetValues(HChart, XRT_OTHER_DATA_STYLE, &val, NULL); return(val); }
    BOOL GetOtherDataStyleUseDefault() { BOOL val; XrtGetValues(HChart, XRT_OTHER_DATA_STYLE_USE_DEFAULT, &val, NULL); return(val); }
    char * GetOtherLabel() { char * val; XrtGetValues(HChart, XRT_OTHER_LABEL, &val, NULL); return(val); }
    BOOL GetPieMergeMissingSlices() { BOOL val; XrtGetValues(HChart, XRT_PIE_MERGE_MISSING_SLICES, &val, NULL); return(val); }
    int GetPieMinSlices() { int val; XrtGetValues(HChart, XRT_PIE_MIN_SLICES, &val, NULL); return(val); }
    XrtPieOrder GetPieOrder() { XrtPieOrder val; XrtGetValues(HChart, XRT_PIE_ORDER, &val, NULL); return(val); }
    double GetPieStartAngle() { double val; XrtGetValues(HChart, XRT_PIE_START_ANGLE, &val, NULL); return(val); }
    XrtPieThresholdMethod GetPieThresholdMethod() { XrtPieThresholdMethod val; XrtGetValues(HChart, XRT_PIE_THRESHOLD_METHOD, &val, NULL); return(val); }
    double GetPieThresholdValue() { double val; XrtGetValues(HChart, XRT_PIE_THRESHOLD_VALUE, &val, NULL); return(val); }
    char ** GetPointLabels() { char ** val; XrtGetValues(HChart, XRT_POINT_LABELS, &val, NULL); return(val); }
    char ** GetPointLabels2() { char ** val; XrtGetValues(HChart, XRT_POINT_LABELS2, &val, NULL); return(val); }
    BOOL GetPolarAxisAllowNegatives() { BOOL val; XrtGetValues(HChart, XRT_POLAR_AXIS_ALLOW_NEGATIVES, &val, NULL); return(val); }
    BOOL GetPolarHalfRange() { BOOL val; XrtGetValues(HChart, XRT_POLAR_HALF_RANGE, &val, NULL); return(val); }
    BOOL GetRepaint() { BOOL val; XrtGetValues(HChart, XRT_REPAINT, &val, NULL); return(val); }
    char ** GetSetLabels() { char ** val; XrtGetValues(HChart, XRT_SET_LABELS, &val, NULL); return(val); }
    char ** GetSetLabels2() { char ** val; XrtGetValues(HChart, XRT_SET_LABELS2, &val, NULL); return(val); }
    long GetTimeBase() { long val; XrtGetValues(HChart, XRT_TIME_BASE, &val, NULL); return(val); }
    char * GetTimeFormat() { char * val; XrtGetValues(HChart, XRT_TIME_FORMAT, &val, NULL); return(val); }
    BOOL GetTimeFormatUseDefault() { BOOL val; XrtGetValues(HChart, XRT_TIME_FORMAT_USE_DEFAULT, &val, NULL); return(val); }
    XrtTimeUnit GetTimeUnit() { XrtTimeUnit val; XrtGetValues(HChart, XRT_TIME_UNIT, &val, NULL); return(val); }
    BOOL GetTransposeData() { BOOL val; XrtGetValues(HChart, XRT_TRANSPOSE_DATA, &val, NULL); return(val); }
    XrtType GetType() { XrtType val; XrtGetValues(HChart, XRT_TYPE, &val, NULL); return(val); }
    XrtType GetType2() { XrtType val; XrtGetValues(HChart, XRT_TYPE2, &val, NULL); return(val); }
    int GetWidth() { int val; XrtGetValues(HChart, XRT_WIDTH, &val, NULL); return(val); }
    XrtAnnoPlacement GetXAnnoPlacement() { XrtAnnoPlacement val; XrtGetValues(HChart, XRT_XANNO_PLACEMENT, &val, NULL); return(val); }
    XrtAnnoMethod GetXAnnotationMethod() { XrtAnnoMethod val; XrtGetValues(HChart, XRT_XANNOTATION_METHOD, &val, NULL); return(val); }
    XrtRotate GetXAnnotationRotation() { XrtRotate val; XrtGetValues(HChart, XRT_XANNOTATION_ROTATION, &val, NULL); return(val); }
    double GetXAnnotationRotationAngle() { double val; XrtGetValues(HChart, XRT_XANNOTATION_ROTATION_ANGLE, &val, NULL); return(val); }
    XrtDataStyle * GetXAxisDataStyle() { XrtDataStyle * val; XrtGetValues(HChart, XRT_XAXIS_DATA_STYLE, &val, NULL); return(val); }
    BOOL GetXAxisDataStyleUseDefault() { BOOL val; XrtGetValues(HChart, XRT_XAXIS_DATA_STYLE_USE_DEFAULT, &val, NULL); return(val); }
    char * GetXAxisLabelFormat() { char * val; XrtGetValues(HChart, XRT_XAXIS_LABEL_FORMAT, &val, NULL); return(val); }
    BOOL GetXAxisLogarithmic() { BOOL val; XrtGetValues(HChart, XRT_XAXIS_LOGARITHMIC, &val, NULL); return(val); }
    double GetXAxisMax() { double val; XrtGetValues(HChart, XRT_XAXIS_MAX, &val, NULL); return(val); }
    BOOL GetXAxisMaxUseDefault() { BOOL val; XrtGetValues(HChart, XRT_XAXIS_MAX_USE_DEFAULT, &val, NULL); return(val); }
    double GetXAxisMin() { double val; XrtGetValues(HChart, XRT_XAXIS_MIN, &val, NULL); return(val); }
    BOOL GetXAxisMinUseDefault() { BOOL val; XrtGetValues(HChart, XRT_XAXIS_MIN_USE_DEFAULT, &val, NULL); return(val); }
    BOOL GetXAxisReversed() { BOOL val; XrtGetValues(HChart, XRT_XAXIS_REVERSED, &val, NULL); return(val); }
    BOOL GetXAxisShow() { BOOL val; XrtGetValues(HChart, XRT_XAXIS_SHOW, &val, NULL); return(val); }
    double GetXGrid() { double val; XrtGetValues(HChart, XRT_XGRID, &val, NULL); return(val); }
    XrtDataStyle * GetXGridDataStyle() { XrtDataStyle * val; XrtGetValues(HChart, XRT_XGRID_DATA_STYLE, &val, NULL); return(val); }
    BOOL GetXGridDataStyleUseDefault() { BOOL val; XrtGetValues(HChart, XRT_XGRID_DATA_STYLE_USE_DEFAULT, &val, NULL); return(val); }
    BOOL GetXGridUseDefault() { BOOL val; XrtGetValues(HChart, XRT_XGRID_USE_DEFAULT, &val, NULL); return(val); }
    char ** GetXLabels() { char ** val; XrtGetValues(HChart, XRT_XLABELS, &val, NULL); return(val); }
    double GetXMarker() { double val; XrtGetValues(HChart, XRT_XMARKER, &val, NULL); return(val); }
    XrtDataStyle * GetXMarkerDataStyle() { XrtDataStyle * val; XrtGetValues(HChart, XRT_XMARKER_DATA_STYLE, &val, NULL); return(val); }
    BOOL GetXMarkerDataStyleUseDefault() { BOOL val; XrtGetValues(HChart, XRT_XMARKER_DATA_STYLE_USE_DEFAULT, &val, NULL); return(val); }
    XrtMarkerMethod GetXMarkerMethod() { XrtMarkerMethod val; XrtGetValues(HChart, XRT_XMARKER_METHOD, &val, NULL); return(val); }
    int GetXMarkerPoint() { int val; XrtGetValues(HChart, XRT_XMARKER_POINT, &val, NULL); return(val); }
    int GetXMarkerSet() { int val; XrtGetValues(HChart, XRT_XMARKER_SET, &val, NULL); return(val); }
    BOOL GetXMarkerShow() { BOOL val; XrtGetValues(HChart, XRT_XMARKER_SHOW, &val, NULL); return(val); }
    double GetXMax() { double val; XrtGetValues(HChart, XRT_XMAX, &val, NULL); return(val); }
    BOOL GetXMaxUseDefault() { BOOL val; XrtGetValues(HChart, XRT_XMAX_USE_DEFAULT, &val, NULL); return(val); }
    double GetXMin() { double val; XrtGetValues(HChart, XRT_XMIN, &val, NULL); return(val); }
    BOOL GetXMinUseDefault() { BOOL val; XrtGetValues(HChart, XRT_XMIN_USE_DEFAULT, &val, NULL); return(val); }
    double GetXNum() { double val; XrtGetValues(HChart, XRT_XNUM, &val, NULL); return(val); }
    XrtNumMethod GetXNumMethod() { XrtNumMethod val; XrtGetValues(HChart, XRT_XNUM_METHOD, &val, NULL); return(val); }
    BOOL GetXNumUseDefault() { BOOL val; XrtGetValues(HChart, XRT_XNUM_USE_DEFAULT, &val, NULL); return(val); }
    double GetXOrigin() { double val; XrtGetValues(HChart, XRT_XORIGIN, &val, NULL); return(val); }
    double GetXOriginBase() { double val; XrtGetValues(HChart, XRT_XORIGIN_BASE, &val, NULL); return(val); }
    XrtOriginPlacement GetXOriginPlacement() { XrtOriginPlacement val; XrtGetValues(HChart, XRT_XORIGIN_PLACEMENT, &val, NULL); return(val); }
    BOOL GetXOriginUseDefault() { BOOL val; XrtGetValues(HChart, XRT_XORIGIN_USE_DEFAULT, &val, NULL); return(val); }
    int GetXPrecision() { int val; XrtGetValues(HChart, XRT_XPRECISION, &val, NULL); return(val); }
    BOOL GetXPrecisionUseDefault() { BOOL val; XrtGetValues(HChart, XRT_XPRECISION_USE_DEFAULT, &val, NULL); return(val); }
    double GetXTick() { double val; XrtGetValues(HChart, XRT_XTICK, &val, NULL); return(val); }
    BOOL GetXTickUseDefault() { BOOL val; XrtGetValues(HChart, XRT_XTICK_USE_DEFAULT, &val, NULL); return(val); }
    char * GetXTitle() { char * val; XrtGetValues(HChart, XRT_XTITLE, &val, NULL); return(val); }
    XrtRotate GetXTitleRotation() { XrtRotate val; XrtGetValues(HChart, XRT_XTITLE_ROTATION, &val, NULL); return(val); }
    XrtAnnoPlacement GetY2AnnoPlacement() { XrtAnnoPlacement val; XrtGetValues(HChart, XRT_Y2ANNO_PLACEMENT, &val, NULL); return(val); }
    double GetY2AnnotationAngle() { double val; XrtGetValues(HChart, XRT_Y2ANNOTATION_ANGLE, &val, NULL); return(val); }
    BOOL GetY2AnnotationAngleUseDefault() { BOOL val; XrtGetValues(HChart, XRT_Y2ANNOTATION_ANGLE_USE_DEFAULT, &val, NULL); return(val); }
    XrtAnnoMethod GetY2AnnotationMethod() { XrtAnnoMethod val; XrtGetValues(HChart, XRT_Y2ANNOTATION_METHOD, &val, NULL); return(val); }
    XrtRotate GetY2AnnotationRotation() { XrtRotate val; XrtGetValues(HChart, XRT_Y2ANNOTATION_ROTATION, &val, NULL); return(val); }
    double GetY2AnnotationRotationAngle() { double val; XrtGetValues(HChart, XRT_Y2ANNOTATION_ROTATION_ANGLE, &val, NULL); return(val); }
    BOOL GetY2Axis100Percent() { BOOL val; XrtGetValues(HChart, XRT_Y2AXIS_100_PERCENT, &val, NULL); return(val); }
    XrtDataStyle * GetY2AxisDataStyle() { XrtDataStyle * val; XrtGetValues(HChart, XRT_Y2AXIS_DATA_STYLE, &val, NULL); return(val); }
    BOOL GetY2AxisDataStyleUseDefault() { BOOL val; XrtGetValues(HChart, XRT_Y2AXIS_DATA_STYLE_USE_DEFAULT, &val, NULL); return(val); }
    char * GetY2AxisLabelFormat() { char * val; XrtGetValues(HChart, XRT_Y2AXIS_LABEL_FORMAT, &val, NULL); return(val); }
    BOOL GetY2AxisLogarithmic() { BOOL val; XrtGetValues(HChart, XRT_Y2AXIS_LOGARITHMIC, &val, NULL); return(val); }
    double GetY2AxisMax() { double val; XrtGetValues(HChart, XRT_Y2AXIS_MAX, &val, NULL); return(val); }
    BOOL GetY2AxisMaxUseDefault() { BOOL val; XrtGetValues(HChart, XRT_Y2AXIS_MAX_USE_DEFAULT, &val, NULL); return(val); }
    double GetY2AxisMin() { double val; XrtGetValues(HChart, XRT_Y2AXIS_MIN, &val, NULL); return(val); }
    BOOL GetY2AxisMinUseDefault() { BOOL val; XrtGetValues(HChart, XRT_Y2AXIS_MIN_USE_DEFAULT, &val, NULL); return(val); }
    BOOL GetY2AxisReversed() { BOOL val; XrtGetValues(HChart, XRT_Y2AXIS_REVERSED, &val, NULL); return(val); }
    BOOL GetY2AxisShow() { BOOL val; XrtGetValues(HChart, XRT_Y2AXIS_SHOW, &val, NULL); return(val); }
    double GetY2Grid() { double val; XrtGetValues(HChart, XRT_Y2GRID, &val, NULL); return(val); }
    XrtDataStyle * GetY2GridDataStyle() { XrtDataStyle * val; XrtGetValues(HChart, XRT_Y2GRID_DATA_STYLE, &val, NULL); return(val); }
    BOOL GetY2GridDataStyleUseDefault() { BOOL val; XrtGetValues(HChart, XRT_Y2GRID_DATA_STYLE_USE_DEFAULT, &val, NULL); return(val); }
    BOOL GetY2GridUseDefault() { BOOL val; XrtGetValues(HChart, XRT_Y2GRID_USE_DEFAULT, &val, NULL); return(val); }
    char ** GetY2Labels() { char ** val; XrtGetValues(HChart, XRT_Y2LABELS, &val, NULL); return(val); }
    double GetY2Max() { double val; XrtGetValues(HChart, XRT_Y2MAX, &val, NULL); return(val); }
    BOOL GetY2MaxUseDefault() { BOOL val; XrtGetValues(HChart, XRT_Y2MAX_USE_DEFAULT, &val, NULL); return(val); }
    double GetY2Min() { double val; XrtGetValues(HChart, XRT_Y2MIN, &val, NULL); return(val); }
    BOOL GetY2MinUseDefault() { BOOL val; XrtGetValues(HChart, XRT_Y2MIN_USE_DEFAULT, &val, NULL); return(val); }
    double GetY2Num() { double val; XrtGetValues(HChart, XRT_Y2NUM, &val, NULL); return(val); }
    XrtNumMethod GetY2NumMethod() { XrtNumMethod val; XrtGetValues(HChart, XRT_Y2NUM_METHOD, &val, NULL); return(val); }
    BOOL GetY2NumUseDefault() { BOOL val; XrtGetValues(HChart, XRT_Y2NUM_USE_DEFAULT, &val, NULL); return(val); }
    double GetY2Origin() { double val; XrtGetValues(HChart, XRT_Y2ORIGIN, &val, NULL); return(val); }
    XrtOriginPlacement GetY2OriginPlacement() { XrtOriginPlacement val; XrtGetValues(HChart, XRT_Y2ORIGIN_PLACEMENT, &val, NULL); return(val); }
    BOOL GetY2OriginUseDefault() { BOOL val; XrtGetValues(HChart, XRT_Y2ORIGIN_USE_DEFAULT, &val, NULL); return(val); }
    int GetY2Precision() { int val; XrtGetValues(HChart, XRT_Y2PRECISION, &val, NULL); return(val); }
    BOOL GetY2PrecisionUseDefault() { BOOL val; XrtGetValues(HChart, XRT_Y2PRECISION_USE_DEFAULT, &val, NULL); return(val); }
    double GetY2Tick() { double val; XrtGetValues(HChart, XRT_Y2TICK, &val, NULL); return(val); }
    BOOL GetY2TickUseDefault() { BOOL val; XrtGetValues(HChart, XRT_Y2TICK_USE_DEFAULT, &val, NULL); return(val); }
    char * GetY2Title() { char * val; XrtGetValues(HChart, XRT_Y2TITLE, &val, NULL); return(val); }
    XrtRotate GetY2TitleRotation() { XrtRotate val; XrtGetValues(HChart, XRT_Y2TITLE_ROTATION, &val, NULL); return(val); }
    XrtAnnoPlacement GetYAnnoPlacement() { XrtAnnoPlacement val; XrtGetValues(HChart, XRT_YANNO_PLACEMENT, &val, NULL); return(val); }
    double GetYAnnotationAngle() { double val; XrtGetValues(HChart, XRT_YANNOTATION_ANGLE, &val, NULL); return(val); }
    BOOL GetYAnnotationAngleUseDefault() { BOOL val; XrtGetValues(HChart, XRT_YANNOTATION_ANGLE_USE_DEFAULT, &val, NULL); return(val); }
    XrtAnnoMethod GetYAnnotationMethod() { XrtAnnoMethod val; XrtGetValues(HChart, XRT_YANNOTATION_METHOD, &val, NULL); return(val); }
    XrtRotate GetYAnnotationRotation() { XrtRotate val; XrtGetValues(HChart, XRT_YANNOTATION_ROTATION, &val, NULL); return(val); }
    double GetYAnnotationRotationAngle() { double val; XrtGetValues(HChart, XRT_YANNOTATION_ROTATION_ANGLE, &val, NULL); return(val); }
    BOOL GetYAxis100Percent() { BOOL val; XrtGetValues(HChart, XRT_YAXIS_100_PERCENT, &val, NULL); return(val); }
    double GetYAxisConst() { double val; XrtGetValues(HChart, XRT_YAXIS_CONST, &val, NULL); return(val); }
    XrtDataStyle * GetYAxisDataStyle() { XrtDataStyle * val; XrtGetValues(HChart, XRT_YAXIS_DATA_STYLE, &val, NULL); return(val); }
    BOOL GetYAxisDataStyleUseDefault() { BOOL val; XrtGetValues(HChart, XRT_YAXIS_DATA_STYLE_USE_DEFAULT, &val, NULL); return(val); }
    char * GetYAxisLabelFormat() { char * val; XrtGetValues(HChart, XRT_YAXIS_LABEL_FORMAT, &val, NULL); return(val); }
    BOOL GetYAxisLogarithmic() { BOOL val; XrtGetValues(HChart, XRT_YAXIS_LOGARITHMIC, &val, NULL); return(val); }
    double GetYAxisMax() { double val; XrtGetValues(HChart, XRT_YAXIS_MAX, &val, NULL); return(val); }
    BOOL GetYAxisMaxUseDefault() { BOOL val; XrtGetValues(HChart, XRT_YAXIS_MAX_USE_DEFAULT, &val, NULL); return(val); }
    double GetYAxisMin() { double val; XrtGetValues(HChart, XRT_YAXIS_MIN, &val, NULL); return(val); }
    BOOL GetYAxisMinUseDefault() { BOOL val; XrtGetValues(HChart, XRT_YAXIS_MIN_USE_DEFAULT, &val, NULL); return(val); }
    double GetYAxisMult() { double val; XrtGetValues(HChart, XRT_YAXIS_MULT, &val, NULL); return(val); }
    BOOL GetYAxisReversed() { BOOL val; XrtGetValues(HChart, XRT_YAXIS_REVERSED, &val, NULL); return(val); }
    BOOL GetYAxisShow() { BOOL val; XrtGetValues(HChart, XRT_YAXIS_SHOW, &val, NULL); return(val); }
    double GetYGrid() { double val; XrtGetValues(HChart, XRT_YGRID, &val, NULL); return(val); }
    XrtDataStyle * GetYGridDataStyle() { XrtDataStyle * val; XrtGetValues(HChart, XRT_YGRID_DATA_STYLE, &val, NULL); return(val); }
    BOOL GetYGridDataStyleUseDefault() { BOOL val; XrtGetValues(HChart, XRT_YGRID_DATA_STYLE_USE_DEFAULT, &val, NULL); return(val); }
    BOOL GetYGridUseDefault() { BOOL val; XrtGetValues(HChart, XRT_YGRID_USE_DEFAULT, &val, NULL); return(val); }
    char ** GetYLabels() { char ** val; XrtGetValues(HChart, XRT_YLABELS, &val, NULL); return(val); }
    double GetYMarker() { double val; XrtGetValues(HChart, XRT_YMARKER, &val, NULL); return(val); }
    XrtDataStyle * GetYMarkerDataStyle() { XrtDataStyle * val; XrtGetValues(HChart, XRT_YMARKER_DATA_STYLE, &val, NULL); return(val); }
    BOOL GetYMarkerDataStyleUseDefault() { BOOL val; XrtGetValues(HChart, XRT_YMARKER_DATA_STYLE_USE_DEFAULT, &val, NULL); return(val); }
    BOOL GetYMarkerShow() { BOOL val; XrtGetValues(HChart, XRT_YMARKER_SHOW, &val, NULL); return(val); }
    double GetYMax() { double val; XrtGetValues(HChart, XRT_YMAX, &val, NULL); return(val); }
    BOOL GetYMaxUseDefault() { BOOL val; XrtGetValues(HChart, XRT_YMAX_USE_DEFAULT, &val, NULL); return(val); }
    double GetYMin() { double val; XrtGetValues(HChart, XRT_YMIN, &val, NULL); return(val); }
    BOOL GetYMinUseDefault() { BOOL val; XrtGetValues(HChart, XRT_YMIN_USE_DEFAULT, &val, NULL); return(val); }
    double GetYNum() { double val; XrtGetValues(HChart, XRT_YNUM, &val, NULL); return(val); }
    XrtNumMethod GetYNumMethod() { XrtNumMethod val; XrtGetValues(HChart, XRT_YNUM_METHOD, &val, NULL); return(val); }
    BOOL GetYNumUseDefault() { BOOL val; XrtGetValues(HChart, XRT_YNUM_USE_DEFAULT, &val, NULL); return(val); }
    double GetYOrigin() { double val; XrtGetValues(HChart, XRT_YORIGIN, &val, NULL); return(val); }
    XrtOriginPlacement GetYOriginPlacement() { XrtOriginPlacement val; XrtGetValues(HChart, XRT_YORIGIN_PLACEMENT, &val, NULL); return(val); }
    BOOL GetYOriginUseDefault() { BOOL val; XrtGetValues(HChart, XRT_YORIGIN_USE_DEFAULT, &val, NULL); return(val); }
    int GetYPrecision() { int val; XrtGetValues(HChart, XRT_YPRECISION, &val, NULL); return(val); }
    BOOL GetYPrecisionUseDefault() { BOOL val; XrtGetValues(HChart, XRT_YPRECISION_USE_DEFAULT, &val, NULL); return(val); }
    double GetYTick() { double val; XrtGetValues(HChart, XRT_YTICK, &val, NULL); return(val); }
    BOOL GetYTickUseDefault() { BOOL val; XrtGetValues(HChart, XRT_YTICK_USE_DEFAULT, &val, NULL); return(val); }
    char * GetYTitle() { char * val; XrtGetValues(HChart, XRT_YTITLE, &val, NULL); return(val); }
    XrtRotate GetYTitleRotation() { XrtRotate val; XrtGetValues(HChart, XRT_YTITLE_ROTATION, &val, NULL); return(val); }

    // Set methods
    void SetAngleUnit(XrtAngleUnit val) { XrtSetValues(HChart, XRT_ANGLE_UNIT, val, NULL); }
    void SetAxisBoundingBox(BOOL val) { XrtSetValues(HChart, XRT_AXIS_BOUNDING_BOX, val, NULL); }
    void SetAxisFont(HFONT val) { XrtSetValues(HChart, XRT_AXIS_FONT, (int)val, NULL); }
    void SetBackgroundColor(COLORREF val) { XrtSetValues(HChart, XRT_BACKGROUND_COLOR, val, NULL); }
    void SetBarClusterOverlap(int val) { XrtSetValues(HChart, XRT_BAR_CLUSTER_OVERLAP, val, NULL); }
    void SetBarClusterWidth(int val) { XrtSetValues(HChart, XRT_BAR_CLUSTER_WIDTH, val, NULL); }
    void SetBorder(XrtBorder val) { XrtSetValues(HChart, XRT_BORDER, val, NULL); }
    void SetBorderWidth(int val) { XrtSetValues(HChart, XRT_BORDER_WIDTH, val, NULL); }
    void SetBubbleMax(double val) { XrtSetValues(HChart, XRT_BUBBLE_MAX, val, NULL); }
    void SetBubbleMethod(XrtBubbleMethod val) { XrtSetValues(HChart, XRT_BUBBLE_METHOD, val, NULL); }
    void SetBubbleMin(double val) { XrtSetValues(HChart, XRT_BUBBLE_MIN, val, NULL); }
    void SetCandleComplex(BOOL val) { XrtSetValues(HChart, XRT_CANDLE_COMPLEX, val, NULL); }
    void SetData(XrtDataHandle val) { XrtSetValues(HChart, XRT_DATA, val, NULL); }
    void SetData2(XrtDataHandle val) { XrtSetValues(HChart, XRT_DATA2, val, NULL); }
    void SetDataAreaBackgroundColor(COLORREF val) { XrtSetValues(HChart, XRT_DATA_AREA_BACKGROUND_COLOR, val, NULL); }
    void SetDataAreaForegroundColor(COLORREF val) { XrtSetValues(HChart, XRT_DATA_AREA_FOREGROUND_COLOR, val, NULL); }
    void SetDataAreaImage(XrtImage val) { XrtSetValues(HChart, XRT_DATA_AREA_IMAGE, val, NULL); }
    void SetDataAreaImageLayout(XrtImageLayout val) { XrtSetValues(HChart, XRT_DATA_AREA_IMAGE_LAYOUT, val, NULL); }
    void SetDataAreaImageObsolete(char * val) { XrtSetValues(HChart, XRT_DATA_AREA_IMAGE_OBSOLETE, val, NULL); }
    void SetDataStyles(XrtDataStyle ** val) { XrtSetValues(HChart, XRT_DATA_STYLES, val, NULL); }
    void SetDataStyles2(XrtDataStyle ** val) { XrtSetValues(HChart, XRT_DATA_STYLES2, val, NULL); }
    void SetDataStyles2UseDefault(BOOL val) { XrtSetValues(HChart, XRT_DATA_STYLES2_USE_DEFAULT, val, NULL); }
    void SetDataStylesUseDefault(BOOL val) { XrtSetValues(HChart, XRT_DATA_STYLES_USE_DEFAULT, val, NULL); }
    void SetDebug(BOOL val) { XrtSetValues(HChart, XRT_DEBUG, val, NULL); }
    void SetDoubleBuffer(BOOL val) { XrtSetValues(HChart, XRT_DOUBLE_BUFFER, val, NULL); }
    void SetExtraDefaultDataStyles(BOOL val) { XrtSetValues(HChart, XRT_EXTRA_DEFAULT_DATA_STYLES, val, NULL); }
    void SetFooterAdjust(XrtAdjust val) { XrtSetValues(HChart, XRT_FOOTER_ADJUST, val, NULL); }
    void SetFooterBackgroundColor(COLORREF val) { XrtSetValues(HChart, XRT_FOOTER_BACKGROUND_COLOR, val, NULL); }
    void SetFooterBorder(XrtBorder val) { XrtSetValues(HChart, XRT_FOOTER_BORDER, val, NULL); }
    void SetFooterBorderWidth(int val) { XrtSetValues(HChart, XRT_FOOTER_BORDER_WIDTH, val, NULL); }
    void SetFooterFont(HFONT val) { XrtSetValues(HChart, XRT_FOOTER_FONT, (int)val, NULL); }
    void SetFooterForegroundColor(COLORREF val) { XrtSetValues(HChart, XRT_FOOTER_FOREGROUND_COLOR, val, NULL); }
    void SetFooterHeight(int val) { XrtSetValues(HChart, XRT_FOOTER_HEIGHT, val, NULL); }
    void SetFooterImage(XrtImage val) { XrtSetValues(HChart, XRT_FOOTER_IMAGE, val, NULL); }
    void SetFooterImageLayout(XrtImageLayout val) { XrtSetValues(HChart, XRT_FOOTER_IMAGE_LAYOUT, val, NULL); }
    void SetFooterImageMinimumSize(BOOL val) { XrtSetValues(HChart, XRT_FOOTER_IMAGE_MINIMUM_SIZE, val, NULL); }
    void SetFooterImageObsolete(char * val) { XrtSetValues(HChart, XRT_FOOTER_IMAGE_OBSOLETE, val, NULL); }
    void SetFooterStrings(char ** val) { XrtSetValues(HChart, XRT_FOOTER_STRINGS, val, NULL); }
    void SetFooterWidth(int val) { XrtSetValues(HChart, XRT_FOOTER_WIDTH, val, NULL); }
    void SetFooterX(int val) { XrtSetValues(HChart, XRT_FOOTER_X, val, NULL); }
    void SetFooterXUseDefault(BOOL val) { XrtSetValues(HChart, XRT_FOOTER_X_USE_DEFAULT, val, NULL); }
    void SetFooterY(int val) { XrtSetValues(HChart, XRT_FOOTER_Y, val, NULL); }
    void SetFooterYUseDefault(BOOL val) { XrtSetValues(HChart, XRT_FOOTER_Y_USE_DEFAULT, val, NULL); }
    void SetForegroundColor(COLORREF val) { XrtSetValues(HChart, XRT_FOREGROUND_COLOR, val, NULL); }
    void SetFrontDataset(int val) { XrtSetValues(HChart, XRT_FRONT_DATASET, val, NULL); }
    void SetGraph3dShading(XrtShading val) { XrtSetValues(HChart, XRT_GRAPH_3D_SHADING, val, NULL); }
    void SetGraphBackgroundColor(COLORREF val) { XrtSetValues(HChart, XRT_GRAPH_BACKGROUND_COLOR, val, NULL); }
    void SetGraphBorder(XrtBorder val) { XrtSetValues(HChart, XRT_GRAPH_BORDER, val, NULL); }
    void SetGraphBorderWidth(int val) { XrtSetValues(HChart, XRT_GRAPH_BORDER_WIDTH, val, NULL); }
    void SetGraphDepth(int val) { XrtSetValues(HChart, XRT_GRAPH_DEPTH, val, NULL); }
    void SetGraphForegroundColor(COLORREF val) { XrtSetValues(HChart, XRT_GRAPH_FOREGROUND_COLOR, val, NULL); }
    void SetGraphHeight(int val) { XrtSetValues(HChart, XRT_GRAPH_HEIGHT, val, NULL); }
    void SetGraphHeightUseDefault(BOOL val) { XrtSetValues(HChart, XRT_GRAPH_HEIGHT_USE_DEFAULT, val, NULL); }
    void SetGraphImage(XrtImage val) { XrtSetValues(HChart, XRT_GRAPH_IMAGE, val, NULL); }
    void SetGraphImageLayout(XrtImageLayout val) { XrtSetValues(HChart, XRT_GRAPH_IMAGE_LAYOUT, val, NULL); }
    void SetGraphImageObsolete(char * val) { XrtSetValues(HChart, XRT_GRAPH_IMAGE_OBSOLETE, val, NULL); }
    void SetGraphInclination(int val) { XrtSetValues(HChart, XRT_GRAPH_INCLINATION, val, NULL); }
    void SetGraphMarginBottom(int val) { XrtSetValues(HChart, XRT_GRAPH_MARGIN_BOTTOM, val, NULL); }
    void SetGraphMarginBottomUseDefault(BOOL val) { XrtSetValues(HChart, XRT_GRAPH_MARGIN_BOTTOM_USE_DEFAULT, val, NULL); }
    void SetGraphMarginLeft(int val) { XrtSetValues(HChart, XRT_GRAPH_MARGIN_LEFT, val, NULL); }
    void SetGraphMarginLeftUseDefault(BOOL val) { XrtSetValues(HChart, XRT_GRAPH_MARGIN_LEFT_USE_DEFAULT, val, NULL); }
    void SetGraphMarginRight(int val) { XrtSetValues(HChart, XRT_GRAPH_MARGIN_RIGHT, val, NULL); }
    void SetGraphMarginRightUseDefault(BOOL val) { XrtSetValues(HChart, XRT_GRAPH_MARGIN_RIGHT_USE_DEFAULT, val, NULL); }
    void SetGraphMarginTop(int val) { XrtSetValues(HChart, XRT_GRAPH_MARGIN_TOP, val, NULL); }
    void SetGraphMarginTopUseDefault(BOOL val) { XrtSetValues(HChart, XRT_GRAPH_MARGIN_TOP_USE_DEFAULT, val, NULL); }
    void SetGraphRotation(int val) { XrtSetValues(HChart, XRT_GRAPH_ROTATION, val, NULL); }
    void SetGraphShowOutlines(BOOL val) { XrtSetValues(HChart, XRT_GRAPH_SHOW_OUTLINES, val, NULL); }
    void SetGraphWidth(int val) { XrtSetValues(HChart, XRT_GRAPH_WIDTH, val, NULL); }
    void SetGraphWidthUseDefault(BOOL val) { XrtSetValues(HChart, XRT_GRAPH_WIDTH_USE_DEFAULT, val, NULL); }
    void SetGraphX(int val) { XrtSetValues(HChart, XRT_GRAPH_X, val, NULL); }
    void SetGraphXUseDefault(BOOL val) { XrtSetValues(HChart, XRT_GRAPH_X_USE_DEFAULT, val, NULL); }
    void SetGraphY(int val) { XrtSetValues(HChart, XRT_GRAPH_Y, val, NULL); }
    void SetGraphYUseDefault(BOOL val) { XrtSetValues(HChart, XRT_GRAPH_Y_USE_DEFAULT, val, NULL); }
    void SetHeaderAdjust(XrtAdjust val) { XrtSetValues(HChart, XRT_HEADER_ADJUST, val, NULL); }
    void SetHeaderBackgroundColor(COLORREF val) { XrtSetValues(HChart, XRT_HEADER_BACKGROUND_COLOR, val, NULL); }
    void SetHeaderBorder(XrtBorder val) { XrtSetValues(HChart, XRT_HEADER_BORDER, val, NULL); }
    void SetHeaderBorderWidth(int val) { XrtSetValues(HChart, XRT_HEADER_BORDER_WIDTH, val, NULL); }
    void SetHeaderFont(HFONT val) { XrtSetValues(HChart, XRT_HEADER_FONT, (int)val, NULL); }
    void SetHeaderForegroundColor(COLORREF val) { XrtSetValues(HChart, XRT_HEADER_FOREGROUND_COLOR, val, NULL); }
    void SetHeaderHeight(int val) { XrtSetValues(HChart, XRT_HEADER_HEIGHT, val, NULL); }
    void SetHeaderImage(XrtImage val) { XrtSetValues(HChart, XRT_HEADER_IMAGE, val, NULL); }
    void SetHeaderImageLayout(XrtImageLayout val) { XrtSetValues(HChart, XRT_HEADER_IMAGE_LAYOUT, val, NULL); }
    void SetHeaderImageMinimumSize(BOOL val) { XrtSetValues(HChart, XRT_HEADER_IMAGE_MINIMUM_SIZE, val, NULL); }
    void SetHeaderImageObsolete(char * val) { XrtSetValues(HChart, XRT_HEADER_IMAGE_OBSOLETE, val, NULL); }
    void SetHeaderStrings(char ** val) { XrtSetValues(HChart, XRT_HEADER_STRINGS, val, NULL); }
    void SetHeaderWidth(int val) { XrtSetValues(HChart, XRT_HEADER_WIDTH, val, NULL); }
    void SetHeaderX(int val) { XrtSetValues(HChart, XRT_HEADER_X, val, NULL); }
    void SetHeaderXUseDefault(BOOL val) { XrtSetValues(HChart, XRT_HEADER_X_USE_DEFAULT, val, NULL); }
    void SetHeaderY(int val) { XrtSetValues(HChart, XRT_HEADER_Y, val, NULL); }
    void SetHeaderYUseDefault(BOOL val) { XrtSetValues(HChart, XRT_HEADER_Y_USE_DEFAULT, val, NULL); }
    void SetHeight(int val) { XrtSetValues(HChart, XRT_HEIGHT, val, NULL); }
    void SetHiloCloseShow(BOOL val) { XrtSetValues(HChart, XRT_HILO_CLOSE_SHOW, val, NULL); }
    void SetHiloOpenCloseFullWidth(BOOL val) { XrtSetValues(HChart, XRT_HILO_OPEN_CLOSE_FULL_WIDTH, val, NULL); }
    void SetHiloOpenShow(BOOL val) { XrtSetValues(HChart, XRT_HILO_OPEN_SHOW, val, NULL); }
    void SetImage(XrtImage val) { XrtSetValues(HChart, XRT_IMAGE, val, NULL); }
    void SetImageLayout(XrtImageLayout val) { XrtSetValues(HChart, XRT_IMAGE_LAYOUT, val, NULL); }
    void SetImageObsolete(char * val) { XrtSetValues(HChart, XRT_IMAGE_OBSOLETE, val, NULL); }
    void SetInvertOrientation(BOOL val) { XrtSetValues(HChart, XRT_INVERT_ORIENTATION, val, NULL); }
    void SetIsStacked(BOOL val) { XrtSetValues(HChart, XRT_IS_STACKED, val, NULL); }
    void SetIsStacked2(BOOL val) { XrtSetValues(HChart, XRT_IS_STACKED2, val, NULL); }
    void SetLegendAnchor(XrtAnchor val) { XrtSetValues(HChart, XRT_LEGEND_ANCHOR, val, NULL); }
    void SetLegendBackgroundColor(COLORREF val) { XrtSetValues(HChart, XRT_LEGEND_BACKGROUND_COLOR, val, NULL); }
    void SetLegendBorder(XrtBorder val) { XrtSetValues(HChart, XRT_LEGEND_BORDER, val, NULL); }
    void SetLegendBorderWidth(int val) { XrtSetValues(HChart, XRT_LEGEND_BORDER_WIDTH, val, NULL); }
    void SetLegendFont(HFONT val) { XrtSetValues(HChart, XRT_LEGEND_FONT, (int)val, NULL); }
    void SetLegendForegroundColor(COLORREF val) { XrtSetValues(HChart, XRT_LEGEND_FOREGROUND_COLOR, val, NULL); }
    void SetLegendHeight(int val) { XrtSetValues(HChart, XRT_LEGEND_HEIGHT, val, NULL); }
    void SetLegendImage(XrtImage val) { XrtSetValues(HChart, XRT_LEGEND_IMAGE, val, NULL); }
    void SetLegendImageLayout(XrtImageLayout val) { XrtSetValues(HChart, XRT_LEGEND_IMAGE_LAYOUT, val, NULL); }
    void SetLegendImageObsolete(char * val) { XrtSetValues(HChart, XRT_LEGEND_IMAGE_OBSOLETE, val, NULL); }
    void SetLegendOrientation(XrtAlign val) { XrtSetValues(HChart, XRT_LEGEND_ORIENTATION, val, NULL); }
    void SetLegendReversed(BOOL val) { XrtSetValues(HChart, XRT_LEGEND_REVERSED, val, NULL); }
    void SetLegendShow(BOOL val) { XrtSetValues(HChart, XRT_LEGEND_SHOW, val, NULL); }
    void SetLegendTitle(char * val) { XrtSetValues(HChart, XRT_LEGEND_TITLE, val, NULL); }
    void SetLegendWidth(int val) { XrtSetValues(HChart, XRT_LEGEND_WIDTH, val, NULL); }
    void SetLegendX(int val) { XrtSetValues(HChart, XRT_LEGEND_X, val, NULL); }
    void SetLegendXUseDefault(BOOL val) { XrtSetValues(HChart, XRT_LEGEND_X_USE_DEFAULT, val, NULL); }
    void SetLegendY(int val) { XrtSetValues(HChart, XRT_LEGEND_Y, val, NULL); }
    void SetLegendYUseDefault(BOOL val) { XrtSetValues(HChart, XRT_LEGEND_Y_USE_DEFAULT, val, NULL); }
    void SetMarkerDataStyle(XrtDataStyle * val) { XrtSetValues(HChart, XRT_MARKER_DATA_STYLE, val, NULL); }
    void SetMarkerDataStyleUseDefault(BOOL val) { XrtSetValues(HChart, XRT_MARKER_DATA_STYLE_USE_DEFAULT, val, NULL); }
    void SetMarkerDataset(int val) { XrtSetValues(HChart, XRT_MARKER_DATASET, val, NULL); }
    void SetName(char * val) { XrtSetValues(HChart, XRT_NAME, val, NULL); }
    void SetOtherDataStyle(XrtDataStyle * val) { XrtSetValues(HChart, XRT_OTHER_DATA_STYLE, val, NULL); }
    void SetOtherDataStyleUseDefault(BOOL val) { XrtSetValues(HChart, XRT_OTHER_DATA_STYLE_USE_DEFAULT, val, NULL); }
    void SetOtherLabel(char * val) { XrtSetValues(HChart, XRT_OTHER_LABEL, val, NULL); }
    void SetPieMergeMissingSlices(BOOL val) { XrtSetValues(HChart, XRT_PIE_MERGE_MISSING_SLICES, val, NULL); }
    void SetPieMinSlices(int val) { XrtSetValues(HChart, XRT_PIE_MIN_SLICES, val, NULL); }
    void SetPieOrder(XrtPieOrder val) { XrtSetValues(HChart, XRT_PIE_ORDER, val, NULL); }
    void SetPieStartAngle(double val) { XrtSetValues(HChart, XRT_PIE_START_ANGLE, val, NULL); }
    void SetPieThresholdMethod(XrtPieThresholdMethod val) { XrtSetValues(HChart, XRT_PIE_THRESHOLD_METHOD, val, NULL); }
    void SetPieThresholdValue(double val) { XrtSetValues(HChart, XRT_PIE_THRESHOLD_VALUE, val, NULL); }
    void SetPointLabels(char ** val) { XrtSetValues(HChart, XRT_POINT_LABELS, val, NULL); }
    void SetPointLabels2(char ** val) { XrtSetValues(HChart, XRT_POINT_LABELS2, val, NULL); }
    void SetPolarAxisAllowNegatives(BOOL val) { XrtSetValues(HChart, XRT_POLAR_AXIS_ALLOW_NEGATIVES, val, NULL); }
    void SetPolarHalfRange(BOOL val) { XrtSetValues(HChart, XRT_POLAR_HALF_RANGE, val, NULL); }
    void SetRepaint(BOOL val) { XrtSetValues(HChart, XRT_REPAINT, val, NULL); }
    void SetSetLabels(char ** val) { XrtSetValues(HChart, XRT_SET_LABELS, val, NULL); }
    void SetSetLabels2(char ** val) { XrtSetValues(HChart, XRT_SET_LABELS2, val, NULL); }
    void SetTimeBase(long val) { XrtSetValues(HChart, XRT_TIME_BASE, val, NULL); }
    void SetTimeFormat(char * val) { XrtSetValues(HChart, XRT_TIME_FORMAT, val, NULL); }
    void SetTimeFormatUseDefault(BOOL val) { XrtSetValues(HChart, XRT_TIME_FORMAT_USE_DEFAULT, val, NULL); }
    void SetTimeUnit(XrtTimeUnit val) { XrtSetValues(HChart, XRT_TIME_UNIT, val, NULL); }
    void SetTransposeData(BOOL val) { XrtSetValues(HChart, XRT_TRANSPOSE_DATA, val, NULL); }
    void SetType(XrtType val) { XrtSetValues(HChart, XRT_TYPE, val, NULL); }
    void SetType2(XrtType val) { XrtSetValues(HChart, XRT_TYPE2, val, NULL); }
    void SetWidth(int val) { XrtSetValues(HChart, XRT_WIDTH, val, NULL); }
    void SetXAnnoPlacement(XrtAnnoPlacement val) { XrtSetValues(HChart, XRT_XANNO_PLACEMENT, val, NULL); }
    void SetXAnnotationMethod(XrtAnnoMethod val) { XrtSetValues(HChart, XRT_XANNOTATION_METHOD, val, NULL); }
    void SetXAnnotationRotation(XrtRotate val) { XrtSetValues(HChart, XRT_XANNOTATION_ROTATION, val, NULL); }
    void SetXAnnotationRotationAngle(double val) { XrtSetValues(HChart, XRT_XANNOTATION_ROTATION_ANGLE, val, NULL); }
    void SetXAxisDataStyle(XrtDataStyle * val) { XrtSetValues(HChart, XRT_XAXIS_DATA_STYLE, val, NULL); }
    void SetXAxisDataStyleUseDefault(BOOL val) { XrtSetValues(HChart, XRT_XAXIS_DATA_STYLE_USE_DEFAULT, val, NULL); }
    void SetXAxisLabelFormat(char * val) { XrtSetValues(HChart, XRT_XAXIS_LABEL_FORMAT, val, NULL); }
    void SetXAxisLogarithmic(BOOL val) { XrtSetValues(HChart, XRT_XAXIS_LOGARITHMIC, val, NULL); }
    void SetXAxisMax(double val) { XrtSetValues(HChart, XRT_XAXIS_MAX, val, NULL); }
    void SetXAxisMaxUseDefault(BOOL val) { XrtSetValues(HChart, XRT_XAXIS_MAX_USE_DEFAULT, val, NULL); }
    void SetXAxisMin(double val) { XrtSetValues(HChart, XRT_XAXIS_MIN, val, NULL); }
    void SetXAxisMinUseDefault(BOOL val) { XrtSetValues(HChart, XRT_XAXIS_MIN_USE_DEFAULT, val, NULL); }
    void SetXAxisReversed(BOOL val) { XrtSetValues(HChart, XRT_XAXIS_REVERSED, val, NULL); }
    void SetXAxisShow(BOOL val) { XrtSetValues(HChart, XRT_XAXIS_SHOW, val, NULL); }
    void SetXGrid(double val) { XrtSetValues(HChart, XRT_XGRID, val, NULL); }
    void SetXGridDataStyle(XrtDataStyle * val) { XrtSetValues(HChart, XRT_XGRID_DATA_STYLE, val, NULL); }
    void SetXGridDataStyleUseDefault(BOOL val) { XrtSetValues(HChart, XRT_XGRID_DATA_STYLE_USE_DEFAULT, val, NULL); }
    void SetXGridUseDefault(BOOL val) { XrtSetValues(HChart, XRT_XGRID_USE_DEFAULT, val, NULL); }
    void SetXLabels(char ** val) { XrtSetValues(HChart, XRT_XLABELS, val, NULL); }
    void SetXMarker(double val) { XrtSetValues(HChart, XRT_XMARKER, val, NULL); }
    void SetXMarkerDataStyle(XrtDataStyle * val) { XrtSetValues(HChart, XRT_XMARKER_DATA_STYLE, val, NULL); }
    void SetXMarkerDataStyleUseDefault(BOOL val) { XrtSetValues(HChart, XRT_XMARKER_DATA_STYLE_USE_DEFAULT, val, NULL); }
    void SetXMarkerMethod(XrtMarkerMethod val) { XrtSetValues(HChart, XRT_XMARKER_METHOD, val, NULL); }
    void SetXMarkerPoint(int val) { XrtSetValues(HChart, XRT_XMARKER_POINT, val, NULL); }
    void SetXMarkerSet(int val) { XrtSetValues(HChart, XRT_XMARKER_SET, val, NULL); }
    void SetXMarkerShow(BOOL val) { XrtSetValues(HChart, XRT_XMARKER_SHOW, val, NULL); }
    void SetXMax(double val) { XrtSetValues(HChart, XRT_XMAX, val, NULL); }
    void SetXMaxUseDefault(BOOL val) { XrtSetValues(HChart, XRT_XMAX_USE_DEFAULT, val, NULL); }
    void SetXMin(double val) { XrtSetValues(HChart, XRT_XMIN, val, NULL); }
    void SetXMinUseDefault(BOOL val) { XrtSetValues(HChart, XRT_XMIN_USE_DEFAULT, val, NULL); }
    void SetXNum(double val) { XrtSetValues(HChart, XRT_XNUM, val, NULL); }
    void SetXNumMethod(XrtNumMethod val) { XrtSetValues(HChart, XRT_XNUM_METHOD, val, NULL); }
    void SetXNumUseDefault(BOOL val) { XrtSetValues(HChart, XRT_XNUM_USE_DEFAULT, val, NULL); }
    void SetXOrigin(double val) { XrtSetValues(HChart, XRT_XORIGIN, val, NULL); }
    void SetXOriginBase(double val) { XrtSetValues(HChart, XRT_XORIGIN_BASE, val, NULL); }
    void SetXOriginPlacement(XrtOriginPlacement val) { XrtSetValues(HChart, XRT_XORIGIN_PLACEMENT, val, NULL); }
    void SetXOriginUseDefault(BOOL val) { XrtSetValues(HChart, XRT_XORIGIN_USE_DEFAULT, val, NULL); }
    void SetXPrecision(int val) { XrtSetValues(HChart, XRT_XPRECISION, val, NULL); }
    void SetXPrecisionUseDefault(BOOL val) { XrtSetValues(HChart, XRT_XPRECISION_USE_DEFAULT, val, NULL); }
    void SetXTick(double val) { XrtSetValues(HChart, XRT_XTICK, val, NULL); }
    void SetXTickUseDefault(BOOL val) { XrtSetValues(HChart, XRT_XTICK_USE_DEFAULT, val, NULL); }
    void SetXTitle(char * val) { XrtSetValues(HChart, XRT_XTITLE, val, NULL); }
    void SetXTitleRotation(XrtRotate val) { XrtSetValues(HChart, XRT_XTITLE_ROTATION, val, NULL); }
    void SetY2AnnoPlacement(XrtAnnoPlacement val) { XrtSetValues(HChart, XRT_Y2ANNO_PLACEMENT, val, NULL); }
    void SetY2AnnotationAngle(double val) { XrtSetValues(HChart, XRT_Y2ANNOTATION_ANGLE, val, NULL); }
    void SetY2AnnotationAngleUseDefault(BOOL val) { XrtSetValues(HChart, XRT_Y2ANNOTATION_ANGLE_USE_DEFAULT, val, NULL); }
    void SetY2AnnotationMethod(XrtAnnoMethod val) { XrtSetValues(HChart, XRT_Y2ANNOTATION_METHOD, val, NULL); }
    void SetY2AnnotationRotation(XrtRotate val) { XrtSetValues(HChart, XRT_Y2ANNOTATION_ROTATION, val, NULL); }
    void SetY2AnnotationRotationAngle(double val) { XrtSetValues(HChart, XRT_Y2ANNOTATION_ROTATION_ANGLE, val, NULL); }
    void SetY2Axis100Percent(BOOL val) { XrtSetValues(HChart, XRT_Y2AXIS_100_PERCENT, val, NULL); }
    void SetY2AxisDataStyle(XrtDataStyle * val) { XrtSetValues(HChart, XRT_Y2AXIS_DATA_STYLE, val, NULL); }
    void SetY2AxisDataStyleUseDefault(BOOL val) { XrtSetValues(HChart, XRT_Y2AXIS_DATA_STYLE_USE_DEFAULT, val, NULL); }
    void SetY2AxisLabelFormat(char * val) { XrtSetValues(HChart, XRT_Y2AXIS_LABEL_FORMAT, val, NULL); }
    void SetY2AxisLogarithmic(BOOL val) { XrtSetValues(HChart, XRT_Y2AXIS_LOGARITHMIC, val, NULL); }
    void SetY2AxisMax(double val) { XrtSetValues(HChart, XRT_Y2AXIS_MAX, val, NULL); }
    void SetY2AxisMaxUseDefault(BOOL val) { XrtSetValues(HChart, XRT_Y2AXIS_MAX_USE_DEFAULT, val, NULL); }
    void SetY2AxisMin(double val) { XrtSetValues(HChart, XRT_Y2AXIS_MIN, val, NULL); }
    void SetY2AxisMinUseDefault(BOOL val) { XrtSetValues(HChart, XRT_Y2AXIS_MIN_USE_DEFAULT, val, NULL); }
    void SetY2AxisReversed(BOOL val) { XrtSetValues(HChart, XRT_Y2AXIS_REVERSED, val, NULL); }
    void SetY2AxisShow(BOOL val) { XrtSetValues(HChart, XRT_Y2AXIS_SHOW, val, NULL); }
    void SetY2Grid(double val) { XrtSetValues(HChart, XRT_Y2GRID, val, NULL); }
    void SetY2GridDataStyle(XrtDataStyle * val) { XrtSetValues(HChart, XRT_Y2GRID_DATA_STYLE, val, NULL); }
    void SetY2GridDataStyleUseDefault(BOOL val) { XrtSetValues(HChart, XRT_Y2GRID_DATA_STYLE_USE_DEFAULT, val, NULL); }
    void SetY2GridUseDefault(BOOL val) { XrtSetValues(HChart, XRT_Y2GRID_USE_DEFAULT, val, NULL); }
    void SetY2Labels(char ** val) { XrtSetValues(HChart, XRT_Y2LABELS, val, NULL); }
    void SetY2Max(double val) { XrtSetValues(HChart, XRT_Y2MAX, val, NULL); }
    void SetY2MaxUseDefault(BOOL val) { XrtSetValues(HChart, XRT_Y2MAX_USE_DEFAULT, val, NULL); }
    void SetY2Min(double val) { XrtSetValues(HChart, XRT_Y2MIN, val, NULL); }
    void SetY2MinUseDefault(BOOL val) { XrtSetValues(HChart, XRT_Y2MIN_USE_DEFAULT, val, NULL); }
    void SetY2Num(double val) { XrtSetValues(HChart, XRT_Y2NUM, val, NULL); }
    void SetY2NumMethod(XrtNumMethod val) { XrtSetValues(HChart, XRT_Y2NUM_METHOD, val, NULL); }
    void SetY2NumUseDefault(BOOL val) { XrtSetValues(HChart, XRT_Y2NUM_USE_DEFAULT, val, NULL); }
    void SetY2Origin(double val) { XrtSetValues(HChart, XRT_Y2ORIGIN, val, NULL); }
    void SetY2OriginPlacement(XrtOriginPlacement val) { XrtSetValues(HChart, XRT_Y2ORIGIN_PLACEMENT, val, NULL); }
    void SetY2OriginUseDefault(BOOL val) { XrtSetValues(HChart, XRT_Y2ORIGIN_USE_DEFAULT, val, NULL); }
    void SetY2Precision(int val) { XrtSetValues(HChart, XRT_Y2PRECISION, val, NULL); }
    void SetY2PrecisionUseDefault(BOOL val) { XrtSetValues(HChart, XRT_Y2PRECISION_USE_DEFAULT, val, NULL); }
    void SetY2Tick(double val) { XrtSetValues(HChart, XRT_Y2TICK, val, NULL); }
    void SetY2TickUseDefault(BOOL val) { XrtSetValues(HChart, XRT_Y2TICK_USE_DEFAULT, val, NULL); }
    void SetY2Title(char * val) { XrtSetValues(HChart, XRT_Y2TITLE, val, NULL); }
    void SetY2TitleRotation(XrtRotate val) { XrtSetValues(HChart, XRT_Y2TITLE_ROTATION, val, NULL); }
    void SetYAnnoPlacement(XrtAnnoPlacement val) { XrtSetValues(HChart, XRT_YANNO_PLACEMENT, val, NULL); }
    void SetYAnnotationAngle(double val) { XrtSetValues(HChart, XRT_YANNOTATION_ANGLE, val, NULL); }
    void SetYAnnotationAngleUseDefault(BOOL val) { XrtSetValues(HChart, XRT_YANNOTATION_ANGLE_USE_DEFAULT, val, NULL); }
    void SetYAnnotationMethod(XrtAnnoMethod val) { XrtSetValues(HChart, XRT_YANNOTATION_METHOD, val, NULL); }
    void SetYAnnotationRotation(XrtRotate val) { XrtSetValues(HChart, XRT_YANNOTATION_ROTATION, val, NULL); }
    void SetYAnnotationRotationAngle(double val) { XrtSetValues(HChart, XRT_YANNOTATION_ROTATION_ANGLE, val, NULL); }
    void SetYAxis100Percent(BOOL val) { XrtSetValues(HChart, XRT_YAXIS_100_PERCENT, val, NULL); }
    void SetYAxisConst(double val) { XrtSetValues(HChart, XRT_YAXIS_CONST, val, NULL); }
    void SetYAxisDataStyle(XrtDataStyle * val) { XrtSetValues(HChart, XRT_YAXIS_DATA_STYLE, val, NULL); }
    void SetYAxisDataStyleUseDefault(BOOL val) { XrtSetValues(HChart, XRT_YAXIS_DATA_STYLE_USE_DEFAULT, val, NULL); }
    void SetYAxisLabelFormat(char * val) { XrtSetValues(HChart, XRT_YAXIS_LABEL_FORMAT, val, NULL); }
    void SetYAxisLogarithmic(BOOL val) { XrtSetValues(HChart, XRT_YAXIS_LOGARITHMIC, val, NULL); }
    void SetYAxisMax(double val) { XrtSetValues(HChart, XRT_YAXIS_MAX, val, NULL); }
    void SetYAxisMaxUseDefault(BOOL val) { XrtSetValues(HChart, XRT_YAXIS_MAX_USE_DEFAULT, val, NULL); }
    void SetYAxisMin(double val) { XrtSetValues(HChart, XRT_YAXIS_MIN, val, NULL); }
    void SetYAxisMinUseDefault(BOOL val) { XrtSetValues(HChart, XRT_YAXIS_MIN_USE_DEFAULT, val, NULL); }
    void SetYAxisMult(double val) { XrtSetValues(HChart, XRT_YAXIS_MULT, val, NULL); }
    void SetYAxisReversed(BOOL val) { XrtSetValues(HChart, XRT_YAXIS_REVERSED, val, NULL); }
    void SetYAxisShow(BOOL val) { XrtSetValues(HChart, XRT_YAXIS_SHOW, val, NULL); }
    void SetYGrid(double val) { XrtSetValues(HChart, XRT_YGRID, val, NULL); }
    void SetYGridDataStyle(XrtDataStyle * val) { XrtSetValues(HChart, XRT_YGRID_DATA_STYLE, val, NULL); }
    void SetYGridDataStyleUseDefault(BOOL val) { XrtSetValues(HChart, XRT_YGRID_DATA_STYLE_USE_DEFAULT, val, NULL); }
    void SetYGridUseDefault(BOOL val) { XrtSetValues(HChart, XRT_YGRID_USE_DEFAULT, val, NULL); }
    void SetYLabels(char ** val) { XrtSetValues(HChart, XRT_YLABELS, val, NULL); }
    void SetYMarker(double val) { XrtSetValues(HChart, XRT_YMARKER, val, NULL); }
    void SetYMarkerDataStyle(XrtDataStyle * val) { XrtSetValues(HChart, XRT_YMARKER_DATA_STYLE, val, NULL); }
    void SetYMarkerDataStyleUseDefault(BOOL val) { XrtSetValues(HChart, XRT_YMARKER_DATA_STYLE_USE_DEFAULT, val, NULL); }
    void SetYMarkerShow(BOOL val) { XrtSetValues(HChart, XRT_YMARKER_SHOW, val, NULL); }
    void SetYMax(double val) { XrtSetValues(HChart, XRT_YMAX, val, NULL); }
    void SetYMaxUseDefault(BOOL val) { XrtSetValues(HChart, XRT_YMAX_USE_DEFAULT, val, NULL); }
    void SetYMin(double val) { XrtSetValues(HChart, XRT_YMIN, val, NULL); }
    void SetYMinUseDefault(BOOL val) { XrtSetValues(HChart, XRT_YMIN_USE_DEFAULT, val, NULL); }
    void SetYNum(double val) { XrtSetValues(HChart, XRT_YNUM, val, NULL); }
    void SetYNumMethod(XrtNumMethod val) { XrtSetValues(HChart, XRT_YNUM_METHOD, val, NULL); }
    void SetYNumUseDefault(BOOL val) { XrtSetValues(HChart, XRT_YNUM_USE_DEFAULT, val, NULL); }
    void SetYOrigin(double val) { XrtSetValues(HChart, XRT_YORIGIN, val, NULL); }
    void SetYOriginPlacement(XrtOriginPlacement val) { XrtSetValues(HChart, XRT_YORIGIN_PLACEMENT, val, NULL); }
    void SetYOriginUseDefault(BOOL val) { XrtSetValues(HChart, XRT_YORIGIN_USE_DEFAULT, val, NULL); }
    void SetYPrecision(int val) { XrtSetValues(HChart, XRT_YPRECISION, val, NULL); }
    void SetYPrecisionUseDefault(BOOL val) { XrtSetValues(HChart, XRT_YPRECISION_USE_DEFAULT, val, NULL); }
    void SetYTick(double val) { XrtSetValues(HChart, XRT_YTICK, val, NULL); }
    void SetYTickUseDefault(BOOL val) { XrtSetValues(HChart, XRT_YTICK_USE_DEFAULT, val, NULL); }
    void SetYTitle(char * val) { XrtSetValues(HChart, XRT_YTITLE, val, NULL); }
    void SetYTitleRotation(XrtRotate val) { XrtSetValues(HChart, XRT_YTITLE_ROTATION, val, NULL); }

    // Operations
    int ArrCheckAxisBounds(int dset, int npoints) { return XrtArrCheckAxisBounds(HChart, dset, npoints); }
    int ArrDataFastUpdate(int dset, int npoints) { return XrtArrDataFastUpdate(HChart, dset, npoints); }
    void ClearAlternateDataStyles(int dset) { XrtClearAlternateDataStyles(HChart, dset); }
    BOOL DrawToClipboard(XrtDrawFormat format = XRT_DRAW_BITMAP) { return XrtDrawToClipboard(HChart, format); }
    BOOL DrawToDC(HDC hdc, XrtDrawFormat format = XRT_DRAW_ENHMETAFILE, XrtDrawScale scale = XRT_DRAWSCALE_TOFIT, int left = 0, int top = 0, int width = 0, int height = 0) { return XrtDrawToDC(HChart, hdc, format, scale, left, top, width, height); }
    BOOL DrawToFile(char *file, XrtDrawFormat format = XRT_DRAW_BITMAP) { return XrtDrawToFile(HChart, file, format); }
    XrtDataStyle **DupDataStyles(XrtDataStyle **ds) { return XrtDupDataStyles(ds); }
    void FreeDataStyles(XrtDataStyle **ds) { XrtFreeDataStyles(ds); }
    int GenDataFastUpdate(int dset, int set, int npoints) { return XrtGenDataFastUpdate(HChart, dset, set, npoints); }
    int GenCheckAxisBounds(int dset, int set, int npoints) { return XrtGenCheckAxisBounds(HChart, dset, set, npoints); }
    XrtDataStyle *GetAlternateDataStyle(int dset, int set, int point) { return XrtGetAlternateDataStyle(HChart, dset, set, point); }
    XrtAlternateDataStyle **GetAlternateDataStyleList(int dset) { return XrtGetAlternateDataStyleList(HChart, dset); }
    XrtDataStyle *GetNthDataStyle(int index) { return XrtGetNthDataStyle(HChart, index); }
    XrtDataStyle *GetNthDataStyle2(int index) { return XrtGetNthDataStyle2(HChart, index); }
    char *GetNthPointLabel(int index) { return XrtGetNthPointLabel(HChart, index); }
    char *GetNthPointLabel2(int index) { return XrtGetNthPointLabel2(HChart, index); }
    char *GetNthSetLabel(int index) { return XrtGetNthSetLabel(HChart, index); }
    char *GetNthSetLabel2(int index) { return XrtGetNthSetLabel2(HChart, index); }
    BOOL GetPropString(XrtProperty res, char **str) { return XrtGetPropString(HChart, res, str); }
    XrtValueLabel *GetValueLabel(XrtAxis axis, XrtValueLabel *vlabel) { return XrtGetValueLabel(HChart, axis, vlabel); }
    XrtRegion Map(int axis, int x, int y, XrtMapResult *map) { return XrtMap(HChart, axis, x, y, map); }
    XrtRegion Pick(int ds, int x, int y, XrtPickResult *pick, XrtFocus focus) { return XrtPick(HChart, ds, x, y, pick, focus); }
    BOOL Print(XrtDrawFormat format = XRT_DRAW_ENHMETAFILE, XrtDrawScale scale = XRT_DRAWSCALE_TOFIT, int left = 0, int top = 0, int width = 0, int height = 0) { return XrtPrint(HChart, format, scale, left, top, width, height); }
    BOOL SaveImageAsJpeg(char *filename, int quality = 80, BOOL grayscale = FALSE, BOOL optimize = FALSE, BOOL progressive = FALSE) { return XrtSaveImageAsJpeg(HChart, filename, quality, grayscale, optimize, progressive); }
    BOOL SaveImageAsPng(char *filename, BOOL interlace = FALSE) { return XrtSaveImageAsPng(HChart, filename, interlace); }
    void SetAlternateDataStyle(int dset, int set, int point, XrtDataStyle *ds) { XrtSetAlternateDataStyle(HChart, dset, set, point, ds); }
    void SetNthDataStyle(int index, XrtDataStyle *ds) { XrtSetNthDataStyle(HChart, index, ds); }
    void SetNthDataStyle2(int index, XrtDataStyle *ds) { XrtSetNthDataStyle2(HChart, index, ds); }
    void SetNthSetLabel(int index, char *string) { XrtSetNthSetLabel(HChart, index, string); }
    void SetNthSetLabel2(int index, char *string) { XrtSetNthSetLabel2(HChart, index, string); }
    void SetNthPointLabel(int index, char *string) { XrtSetNthPointLabel(HChart, index, string); }
    void SetNthPointLabel2(int index, char *string) { XrtSetNthPointLabel2(HChart, index, string); }
    BOOL SetPropString(XrtProperty res, char *str) { return XrtSetPropString(HChart, res, str); }
    void SetValueLabel(XrtAxis axis, XrtValueLabel *vlabel) { XrtSetValueLabel(HChart, axis, vlabel); }
    void Unmap(int axis, double x, double y, XrtMapResult *map) { XrtUnmap(HChart, axis, x, y, map); }
    void Unpick(int ds, int set, int point, XrtPickResult *pick) { XrtUnpick(HChart, ds, set, point, pick); }

    virtual bool      Create();

    HXRT2D HChart;

protected:
    char far     *GetClassName() { return XRT2D; }

private:
    //
    // hidden to prevent accidental copying or assignment
    //
    TChart2D(const TChart2D&);
    TChart2D& operator =(const TChart2D&);
};


/*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 *
 *  Class TChart2DTextArea
 *
 *-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
*/

class TChart2DTextArea {
public:
    // Constructor
    TChart2DTextArea(TChart2D *chart) { HText = XrtTextAreaCreate(chart->HChart); }

    // Destructor
    ~TChart2DTextArea() { XrtTextAreaDestroy(HText); }

    // Get methods
    XrtAdjust GetAdjust() { XrtAdjust val; XrtTextAreaGetValues(HText, XRT_TEXT_ADJUST, &val, NULL); return(val); }
    XrtAnchor GetAnchor() { XrtAnchor val; XrtTextAreaGetValues(HText, XRT_TEXT_ANCHOR, &val, NULL); return(val); }
    int GetAttachDataset() { int val; XrtTextAreaGetValues(HText, XRT_TEXT_ATTACH_DATASET, &val, NULL); return(val); }
    int GetAttachPixelX() { int val; XrtTextAreaGetValues(HText, XRT_TEXT_ATTACH_PIXEL_X, &val, NULL); return(val); }
    int GetAttachPixelY() { int val; XrtTextAreaGetValues(HText, XRT_TEXT_ATTACH_PIXEL_Y, &val, NULL); return(val); }
    int GetAttachPoint() { int val; XrtTextAreaGetValues(HText, XRT_TEXT_ATTACH_POINT, &val, NULL); return(val); }
    int GetAttachSet() { int val; XrtTextAreaGetValues(HText, XRT_TEXT_ATTACH_SET, &val, NULL); return(val); }
    XrtAttachType GetAttachType() { XrtAttachType val; XrtTextAreaGetValues(HText, XRT_TEXT_ATTACH_TYPE, &val, NULL); return(val); }
    double GetAttachValueX() { double val; XrtTextAreaGetValues(HText, XRT_TEXT_ATTACH_VALUE_X, &val, NULL); return(val); }
    double GetAttachValueY() { double val; XrtTextAreaGetValues(HText, XRT_TEXT_ATTACH_VALUE_Y, &val, NULL); return(val); }
    COLORREF GetBackgroundColor() { COLORREF val; XrtTextAreaGetValues(HText, XRT_TEXT_BACKGROUND_COLOR, &val, NULL); return(val); }
    XrtBorder GetBorder() { XrtBorder val; XrtTextAreaGetValues(HText, XRT_TEXT_BORDER, &val, NULL); return(val); }
    int GetBorderWidth() { int val; XrtTextAreaGetValues(HText, XRT_TEXT_BORDER_WIDTH, &val, NULL); return(val); }
    HFONT GetFont() { HFONT val; XrtTextAreaGetValues(HText, XRT_TEXT_FONT, &val, NULL); return(val); }
    COLORREF GetForegroundColor() { COLORREF val; XrtTextAreaGetValues(HText, XRT_TEXT_FOREGROUND_COLOR, &val, NULL); return(val); }
    int GetHeight() { int val; XrtTextAreaGetValues(HText, XRT_TEXT_HEIGHT, &val, NULL); return(val); }
    XrtImage GetImage() { XrtImage val; XrtTextAreaGetValues(HText, XRT_TEXT_IMAGE, &val, NULL); return(val); }
    XrtImageLayout GetImageLayout() { XrtImageLayout val; XrtTextAreaGetValues(HText, XRT_TEXT_IMAGE_LAYOUT, &val, NULL); return(val); }
    BOOL GetImageMinimumSize() { BOOL val; XrtTextAreaGetValues(HText, XRT_TEXT_IMAGE_MINIMUM_SIZE, &val, NULL); return(val); }
    char * GetImageObsolete() { char * val; XrtTextAreaGetValues(HText, XRT_TEXT_IMAGE_OBSOLETE, &val, NULL); return(val); }
    BOOL GetIsConnected() { BOOL val; XrtTextAreaGetValues(HText, XRT_TEXT_IS_CONNECTED, &val, NULL); return(val); }
    BOOL GetIsShowing() { BOOL val; XrtTextAreaGetValues(HText, XRT_TEXT_IS_SHOWING, &val, NULL); return(val); }
    char * GetName() { char * val; XrtTextAreaGetValues(HText, XRT_TEXT_NAME, &val, NULL); return(val); }
    int GetOffset() { int val; XrtTextAreaGetValues(HText, XRT_TEXT_OFFSET, &val, NULL); return(val); }
    XrtRotate GetRotation() { XrtRotate val; XrtTextAreaGetValues(HText, XRT_TEXT_ROTATION, &val, NULL); return(val); }
    char ** GetStrings() { char ** val; XrtTextAreaGetValues(HText, XRT_TEXT_STRINGS, &val, NULL); return(val); }
    int GetWidth() { int val; XrtTextAreaGetValues(HText, XRT_TEXT_WIDTH, &val, NULL); return(val); }
    int GetX() { int val; XrtTextAreaGetValues(HText, XRT_TEXT_X, &val, NULL); return(val); }
    int GetY() { int val; XrtTextAreaGetValues(HText, XRT_TEXT_Y, &val, NULL); return(val); }

    // Set methods
    void SetAdjust(XrtAdjust val) { XrtTextAreaSetValues(HText, XRT_TEXT_ADJUST, val, NULL); }
    void SetAnchor(XrtAnchor val) { XrtTextAreaSetValues(HText, XRT_TEXT_ANCHOR, val, NULL); }
    void SetAttachDataset(int val) { XrtTextAreaSetValues(HText, XRT_TEXT_ATTACH_DATASET, val, NULL); }
    void SetAttachPixelX(int val) { XrtTextAreaSetValues(HText, XRT_TEXT_ATTACH_PIXEL_X, val, NULL); }
    void SetAttachPixelY(int val) { XrtTextAreaSetValues(HText, XRT_TEXT_ATTACH_PIXEL_Y, val, NULL); }
    void SetAttachPoint(int val) { XrtTextAreaSetValues(HText, XRT_TEXT_ATTACH_POINT, val, NULL); }
    void SetAttachSet(int val) { XrtTextAreaSetValues(HText, XRT_TEXT_ATTACH_SET, val, NULL); }
    void SetAttachType(XrtAttachType val) { XrtTextAreaSetValues(HText, XRT_TEXT_ATTACH_TYPE, val, NULL); }
    void SetAttachValueX(double val) { XrtTextAreaSetValues(HText, XRT_TEXT_ATTACH_VALUE_X, val, NULL); }
    void SetAttachValueY(double val) { XrtTextAreaSetValues(HText, XRT_TEXT_ATTACH_VALUE_Y, val, NULL); }
    void SetBackgroundColor(COLORREF val) { XrtTextAreaSetValues(HText, XRT_TEXT_BACKGROUND_COLOR, val, NULL); }
    void SetBorder(XrtBorder val) { XrtTextAreaSetValues(HText, XRT_TEXT_BORDER, val, NULL); }
    void SetBorderWidth(int val) { XrtTextAreaSetValues(HText, XRT_TEXT_BORDER_WIDTH, val, NULL); }
    void SetFont(HFONT val) { XrtTextAreaSetValues(HText, XRT_TEXT_FONT, (int)val, NULL); }
    void SetForegroundColor(COLORREF val) { XrtTextAreaSetValues(HText, XRT_TEXT_FOREGROUND_COLOR, val, NULL); }
    void SetHeight(int val) { XrtTextAreaSetValues(HText, XRT_TEXT_HEIGHT, val, NULL); }
    void SetImage(XrtImage val) { XrtTextAreaSetValues(HText, XRT_TEXT_IMAGE, val, NULL); }
    void SetImageLayout(XrtImageLayout val) { XrtTextAreaSetValues(HText, XRT_TEXT_IMAGE_LAYOUT, val, NULL); }
    void SetImageMinimumSize(BOOL val) { XrtTextAreaSetValues(HText, XRT_TEXT_IMAGE_MINIMUM_SIZE, val, NULL); }
    void SetImageObsolete(char * val) { XrtTextAreaSetValues(HText, XRT_TEXT_IMAGE_OBSOLETE, val, NULL); }
    void SetIsConnected(BOOL val) { XrtTextAreaSetValues(HText, XRT_TEXT_IS_CONNECTED, val, NULL); }
    void SetIsShowing(BOOL val) { XrtTextAreaSetValues(HText, XRT_TEXT_IS_SHOWING, val, NULL); }
    void SetName(char * val) { XrtTextAreaSetValues(HText, XRT_TEXT_NAME, val, NULL); }
    void SetOffset(int val) { XrtTextAreaSetValues(HText, XRT_TEXT_OFFSET, val, NULL); }
    void SetRotation(XrtRotate val) { XrtTextAreaSetValues(HText, XRT_TEXT_ROTATION, val, NULL); }
    void SetStrings(char ** val) { XrtTextAreaSetValues(HText, XRT_TEXT_STRINGS, val, NULL); }
    void SetWidth(int val) { XrtTextAreaSetValues(HText, XRT_TEXT_WIDTH, val, NULL); }
    void SetX(int val) { XrtTextAreaSetValues(HText, XRT_TEXT_X, val, NULL); }
    void SetY(int val) { XrtTextAreaSetValues(HText, XRT_TEXT_Y, val, NULL); }

private:
    XrtTextHandle HText;
};


/*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 *
 *  Class TChart2DPointStyle
 *
 *-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
*/

class TChart2DPointStyle {
public:
    // Constructor
    TChart2DPointStyle(TChart2D *chart) { HStyle = XrtPointStyleCreate(chart->HChart); }
    TChart2DPointStyle(TChart2D *chart, int dataset, int set, int point)
    {
        HStyle = XrtPointStyleCreate(chart->HChart);
        XrtPointStyleSetValues(HStyle,
            XRT_POINTSTYLE_DATASET, dataset,
            XRT_POINTSTYLE_SET, set,
            XRT_POINTSTYLE_POINT, point,
            NULL);
    }

    // Destructor
    ~TChart2DPointStyle() { XrtPointStyleDestroy(HStyle); }

    // Get methods
    XrtDataStyle * GetDataStyle() { XrtDataStyle * val; XrtPointStyleGetValues(HStyle, XRT_POINTSTYLE_DATA_STYLE, &val, NULL); return(val); }
    BOOL GetDataStyleUseDefault() { BOOL val; XrtPointStyleGetValues(HStyle, XRT_POINTSTYLE_DATA_STYLE_USE_DEFAULT, &val, NULL); return(val); }
    int GetDataset() { int val; XrtPointStyleGetValues(HStyle, XRT_POINTSTYLE_DATASET, &val, NULL); return(val); }
    XrtDisplay GetDisplay() { XrtDisplay val; XrtPointStyleGetValues(HStyle, XRT_POINTSTYLE_DISPLAY, &val, NULL); return(val); }
    XrtDataStyle * GetFillStyle() { XrtDataStyle * val; XrtPointStyleGetValues(HStyle, XRT_POINTSTYLE_FILL_STYLE, &val, NULL); return(val); }
    BOOL GetFillStyleUseDefault() { BOOL val; XrtPointStyleGetValues(HStyle, XRT_POINTSTYLE_FILL_STYLE_USE_DEFAULT, &val, NULL); return(val); }
    XrtDataStyle * GetLineStyle() { XrtDataStyle * val; XrtPointStyleGetValues(HStyle, XRT_POINTSTYLE_LINE_STYLE, &val, NULL); return(val); }
    BOOL GetLineStyleUseDefault() { BOOL val; XrtPointStyleGetValues(HStyle, XRT_POINTSTYLE_LINE_STYLE_USE_DEFAULT, &val, NULL); return(val); }
    COLORREF GetPatternBackgroundColor() { COLORREF val; XrtPointStyleGetValues(HStyle, XRT_POINTSTYLE_PATTERN_BACKGROUND_COLOR, &val, NULL); return(val); }
    int GetPoint() { int val; XrtPointStyleGetValues(HStyle, XRT_POINTSTYLE_POINT, &val, NULL); return(val); }
    int GetSet() { int val; XrtPointStyleGetValues(HStyle, XRT_POINTSTYLE_SET, &val, NULL); return(val); }
    double GetSliceOffset() { double val; XrtPointStyleGetValues(HStyle, XRT_POINTSTYLE_SLICE_OFFSET, &val, NULL); return(val); }
    BOOL GetSliceOffsetUseDefault() { BOOL val; XrtPointStyleGetValues(HStyle, XRT_POINTSTYLE_SLICE_OFFSET_USE_DEFAULT, &val, NULL); return(val); }
    XrtDataStyle * GetSymbolStyle() { XrtDataStyle * val; XrtPointStyleGetValues(HStyle, XRT_POINTSTYLE_SYMBOL_STYLE, &val, NULL); return(val); }
    BOOL GetSymbolStyleUseDefault() { BOOL val; XrtPointStyleGetValues(HStyle, XRT_POINTSTYLE_SYMBOL_STYLE_USE_DEFAULT, &val, NULL); return(val); }
    BOOL GetUseDefault() { BOOL val; XrtPointStyleGetValues(HStyle, XRT_POINTSTYLE_USE_DEFAULT, &val, NULL); return(val); }

    // Set methods
    void SetDataStyle(XrtDataStyle * val) { XrtPointStyleSetValues(HStyle, XRT_POINTSTYLE_DATA_STYLE, val, NULL); }
    void SetDataStyleUseDefault(BOOL val) { XrtPointStyleSetValues(HStyle, XRT_POINTSTYLE_DATA_STYLE_USE_DEFAULT, val, NULL); }
    void SetDataset(int val) { XrtPointStyleSetValues(HStyle, XRT_POINTSTYLE_DATASET, val, NULL); }
    void SetDisplay(XrtDisplay val) { XrtPointStyleSetValues(HStyle, XRT_POINTSTYLE_DISPLAY, val, NULL); }
    void SetFillStyle(XrtDataStyle * val) { XrtPointStyleSetValues(HStyle, XRT_POINTSTYLE_FILL_STYLE, val, NULL); }
    void SetFillStyleUseDefault(BOOL val) { XrtPointStyleSetValues(HStyle, XRT_POINTSTYLE_FILL_STYLE_USE_DEFAULT, val, NULL); }
    void SetLineStyle(XrtDataStyle * val) { XrtPointStyleSetValues(HStyle, XRT_POINTSTYLE_LINE_STYLE, val, NULL); }
    void SetLineStyleUseDefault(BOOL val) { XrtPointStyleSetValues(HStyle, XRT_POINTSTYLE_LINE_STYLE_USE_DEFAULT, val, NULL); }
    void SetPatternBackgroundColor(COLORREF val) { XrtPointStyleSetValues(HStyle, XRT_POINTSTYLE_PATTERN_BACKGROUND_COLOR, val, NULL); }
    void SetPoint(int val) { XrtPointStyleSetValues(HStyle, XRT_POINTSTYLE_POINT, val, NULL); }
    void SetSet(int val) { XrtPointStyleSetValues(HStyle, XRT_POINTSTYLE_SET, val, NULL); }
    void SetSliceOffset(double val) { XrtPointStyleSetValues(HStyle, XRT_POINTSTYLE_SLICE_OFFSET, val, NULL); }
    void SetSliceOffsetUseDefault(BOOL val) { XrtPointStyleSetValues(HStyle, XRT_POINTSTYLE_SLICE_OFFSET_USE_DEFAULT, val, NULL); }
    void SetSymbolStyle(XrtDataStyle * val) { XrtPointStyleSetValues(HStyle, XRT_POINTSTYLE_SYMBOL_STYLE, val, NULL); }
    void SetSymbolStyleUseDefault(BOOL val) { XrtPointStyleSetValues(HStyle, XRT_POINTSTYLE_SYMBOL_STYLE_USE_DEFAULT, val, NULL); }
    void SetUseDefault(BOOL val) { XrtPointStyleSetValues(HStyle, XRT_POINTSTYLE_USE_DEFAULT, val, NULL); }

private:
    XrtPointStyleHandle HStyle;
};


/*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 *
 *  Class TChart2DData
 *
 *-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
*/

class TChart2DData {
public:
    // Constructors
    TChart2DData(XrtDataType type, int nsets, int npoints) { HData = XrtDataCreate(type, nsets, npoints); }
    TChart2DData(char* name, char* error = NULL) { HData = XrtDataCreateFromFile(name, error); }
    TChart2DData(const TChart2DData& from) { HData = XrtDataCopy(from.HData); }
    TChart2DData(XrtDataHandle handle) { HData = handle; }

    // Destructor
    ~TChart2DData() { XrtDataDestroy(HData); }

    // Conversion to handle
    operator XrtDataHandle() { return HData; }

    // Get methods
    XrtDisplay GetDisplay(int set) { return XrtDataGetDisplay(HData, set); }
    int GetFirstPoint(int set) { return XrtDataGetFirstPoint(HData, set); }
    int GetFirstSet() { return XrtDataGetFirstSet(HData); }
    double GetHole() { double value; XrtDataGetHoleIndirect(HData, &value); return value; }
    int GetLastPoint(int set) { return XrtDataGetLastPoint(HData, set); }
    int GetLastSet() { return XrtDataGetLastSet(HData); }
    int GetNPoints(int set) { return XrtDataGetNPoints(HData, set); }
    int GetNSets() { return XrtDataGetNSets(HData); }
    XrtDataType GetType() { return XrtDataGetType(HData); }
    double* GetXData(int set) { return XrtDataGetXData(HData, set); }
    double GetXElement(int set, int point) { double value; XrtDataGetXElementIndirect(HData, set, point, &value); return value; }
    double* GetYData(int set) { return XrtDataGetYData(HData, set); }
    double GetYElement(int set, int point) { double value; XrtDataGetYElementIndirect(HData, set, point, &value); return value; }

    // Set methods
    int SetDisplay(int set, XrtDisplay value) { return XrtDataSetDisplay(HData, set, value); }
    int SetFirstPoint(int set, int value) { return XrtDataSetFirstPoint(HData, set, value); }
    int SetFirstSet(int value) { return XrtDataSetFirstSet(HData, value); }
    int SetHole(double value) { return XrtDataSetHole(HData, value); }
    int SetLastPoint(int set, int value) { return XrtDataSetLastPoint(HData, set, value); }
    int SetLastSet( int value) { return XrtDataSetLastSet(HData, value); }
    int SetNPoints(int set, int value) { return XrtDataSetNPoints(HData, set, value); }
    int SetNSets(int value) { return XrtDataSetNSets(HData, value); }
    int SetType(XrtDataType value) { return XrtDataSetType(HData, value); }
    int SetXData(int set, double* values, int num, int start = 0) { return XrtDataSetXData(HData, set, values, num, start); }
    int SetXElement(int set, int point, double value) { return XrtDataSetXElement(HData, set, point, value); }
    int SetYData(int set, double* values, int num, int start = 0) { return XrtDataSetYData(HData, set, values, num, start); }
    int SetYElement(int set, int point, double value) { return XrtDataSetYElement(HData, set, point, value); }

    // Operations
    TChart2DData& operator =(const TChart2DData& from)
        {
            XrtDataHandle handle;
            if(this != &from)
            {
                handle = XrtDataCopy(from.HData);
                if(handle)
                {
                    XrtDataDestroy(HData);
                    HData = handle;
                }
            }
            return *this;
        }
    TChart2DData operator +(const TChart2DData& arg2) { return XrtDataConcat(HData, arg2.HData); }
    TChart2DData ExtractSet(int set) { return XrtDataExtractSet(HData, set); }
    int Release() { return XrtDataRelease(HData); }
    int RemoveSet(int set) { return XrtDataRemoveSet(HData, set); }
    int SaveToFile(char* name, char* error = NULL) { return XrtDataSaveToFile(HData, name, error); }
    int Sort() { return XrtDataSort(HData); }
    TChart2DData Transpose() { return XrtDataTranspose(HData); }

private:
    XrtDataHandle HData;
};

#endif