TSCPlots.h

/*  ===================================================================
*
*                 T R A D I N G   S Y S T E M   A P I ™
*    Copyright © 1999 - 2014 by Peter Ritter ( TradingSystemAPI.com )
*                A L L   R I G H T S   R E S E R V E D
*
*     Consult your license regarding permissions and restrictions.
*             You may obtain a copy of the License at:
*     http://www.TradingSystemAPI.com/licenses/LICENSE-TSAPI-3.0.html
*
*  ====================================================================
*/
#ifndef __TSC_PLOT_H
#define __TSC_PLOT_H

#include "TSCPropertyMap.h"
#include "TSCShapes.h"

namespace tsa {

        class chart;

        namespace plot {

            class plot_base {
              public:
                enum plot_type_t {
                    UNDEFINED,
                    OHLC_BAR,
                    BAR,
                    AREA,
                    LINE,
                    MARKER,
                    MULTI_MARKER,
                    ORDERS_INFO,
                    TRANS_INFO
                };
              public:
                size_t  m_num_series;
                tsa::variant m_values[10];
              public:
                plot_type_t   m_type;
                size_t   m_weight;
                bool     m_dynamic_color;
                color    m_color_primary;
                color    m_color_secondary;
                int      m_jump_signal;
                bool     m_has_pivot;
                double   m_pivot;
                marker_t m_marker_type;
              public:
                plot_base(void);
                plot_base(plot_type_t _t, const tsa::variant& _v, const color& _pc,
                          const color& _sc, size_t _w, bool _dc, int _js, bool _has_pivot, double _piv);
                plot_base(plot_type_t _t, size_t _nv, const color& _pc, const color& _sc, size_t _w, bool _dc,
                          int _js, bool _has_pivot, double _piv);
                ~plot_base(void);
            };


            class marker : public plot_base {
              public:
                explicit marker(
                    marker_t type, 
                    variant y_value,  
                    const color& color = color::auto_color, 
                    size_t weight = DEFAULT_WEIGHT 
                );
                ~marker(void);
            };

            class multi_marker : public plot_base {
              public:
                // @brief Constructor.
           /*     explicit multi_marker(
                    marker_t type, ///< The type of marker.
                    const std::string& csv_values, ///< A comma separated list of y-values (prices) on which shapes will be drawn (e.g. "100.0, 101.0, 102.0").
                    const color& color = color::auto_color, ///< The shape color.
                    size_t weight = DEFAULT_WEIGHT ///< The weight with which the shapes are to be drawn.
                );*/

                explicit multi_marker(
                    marker_t type, 
                    const std::vector<double>& y_values, 
                    const color& color = color::auto_color,
                    size_t weight = DEFAULT_WEIGHT);

                ~multi_marker(void);
            };

            class transactions : public plot_base {
              public:
                explicit transactions(tsa::instrument& inst);
                ~transactions(void);
            };


            class orders : public plot_base {
              public:
                explicit orders(tsa::instrument& inst);
                ~orders(void);
            };

            class line : public plot_base {
              public:
                explicit line(
                    const tsa::variant& value, 
                    const color& color = color::auto_color, 
                    size_t weight = DEFAULT_WEIGHT, 
                    bool dynamic_color = false, 
                    int jump_signal = (-1)   
                );
                ~line(void);
            };


            class rbar : public plot_base {
              public:
                explicit rbar(
                    const tsa::variant& value, 
                    const color& color = color::auto_color, 
                    size_t weight = DEFAULT_WEIGHT, 
                    bool dynamicColor = false  
                );
                explicit rbar(
                    const tsa::variant& value, 
                    const color& color_primary, 
                    const color& color_secondary, 
                    size_t weight = DEFAULT_WEIGHT 
                );
                ~rbar(void);
            };


            class bar : public plot_base {
              public:
                explicit bar(
                    const tsa::variant& value,  
                    const color& color = color::auto_color, 
                    size_t weight = DEFAULT_WEIGHT,  
                    bool dynamicColor = false 
                );
                explicit bar(
                    const tsa::variant& value,  
                    const color& colorPrim,  
                    const color& colorSec, 
                    size_t weight = DEFAULT_WEIGHT 
                );
                ~bar(void);
            };



            class rarea : public plot_base {
              public:
                explicit rarea(
                    const tsa::variant& value, 
                    const color& color = color::auto_color, 
                    bool dynamic_color = false,  
                    int jump_signal = (-1),    
                    bool has_pivot = false,  
                    double pivot = 0.0 
                );
                ~rarea(void);
            };


            class area : public plot_base {
              public:
                explicit area(
                    const tsa::variant& value,  
                    const color& color = color::auto_color, 
                    bool dynamic_color = false,  
                    int jumpSignal = (-1)   
                );
                explicit area(
                    const tsa::variant& value,  
                    const color& color_prim, 
                    const color& color_sec,  
                    int jumpSignal = (-1)   
                );
                ~area(void);
            };


            class ohlc : public plot_base {
              public:
                explicit ohlc(
                    const tsa::variant& op,  
                    const tsa::variant& hi,  
                    const tsa::variant& lo,  
                    const tsa::variant& cl,  
                    const color& col = color::gold,  
                    size_t weight = DEFAULT_WEIGHT,  
                    bool dynamic_color = false); 

                explicit ohlc(
                    const tsa::in_stream&,  
                    const color& col = color::gold, 
                    size_t weight = DEFAULT_WEIGHT,  
                    bool dynamic_color = false 
                );

                explicit ohlc(
                    const tsa::instrument&,  
                    const color& col = color::gold, 
                    size_t weight = DEFAULT_WEIGHT,  
                    bool dynamic_color = false 
                );

                ~ohlc(void);
            };


            class hlc : public plot_base {
              public:
                explicit hlc(

                    const tsa::variant& h,  
                    const tsa::variant& l,  
                    const tsa::variant& c,  
                    const color& col = color::auto_color, 
                    size_t weight = DEFAULT_WEIGHT,  
                    bool dynamic_color = false 
                );
                explicit hlc(
                    const tsa::in_stream&,  
                    const color& col = color::auto_color, 
                    size_t weight = DEFAULT_WEIGHT,  
                    bool dynamic_color = false 
                );
                explicit hlc(
                    const tsa::instrument&,  
                    const color& col = color::auto_color, 
                    size_t weight = DEFAULT_WEIGHT,  
                    bool dynamic_color = false 
                );
                ~hlc(void);
            };

            //Combinations plots

            class area_line {
              public:
                color m_areaColor;
                color m_altAreaColor;
                color m_lineColor;
                double m_dValue;
              public:
                explicit area_line(
                    double value, 
                    const color& area_color = color::aquamarine, 
                    const color& alt_area_color = color::dim_gray, 
                    const color& line_color = color::white 
                );
            };


            class position {
              public:
                const instrument* m_instrument_ptr;
              public:
                explicit position(const instrument& c);
            };


        }//plot


        chart& operator<<(chart&, const plot::area_line&);

        chart& operator<<(chart&, const plot::position&);

   // }//graphics

}//tsa

#endif