SimpleXlsxDef.h

#ifndef __SIMPLE_XLSX_DEF_H__
#define __SIMPLE_XLSX_DEF_H__

#include <stdint.h>
#include <vector>
#include <map>
#include <string>
#include <utility>
#include <ctime>
#include <fstream>

#ifdef _WIN32
#include <tchar.h>
#else
#include "../tchar.h"
#endif  // _WIN32

#ifdef _UNICODE
        typedef std::wofstream          _tofstream;
        typedef std::wstring            _tstring;
        typedef std::wostringstream     _tstringstream;
        typedef std::wostream           _tstream;
#else
        typedef std::ofstream           _tofstream;
        typedef std::string                     _tstring;
        typedef std::ostringstream      _tstringstream;
        typedef std::ostream            _tstream;
#endif // _UNICODE

#define SIMPLE_XLSX_VERSION     _T("0.19")

namespace SimpleXlsx {

enum EChartTypes {
        CHART_NONE = -1,
        CHART_LINEAR = 0,
        CHART_BAR,
        CHART_SCATTER,
};

enum EBorderStyle {
        BORDER_NONE = 0,
        BORDER_THIN,
        BORDER_MEDIUM,
        BORDER_DASHED,
        BORDER_DOTTED,
        BORDER_THICK,
        BORDER_DOUBLE,
        BORDER_HAIR,
        BORDER_MEDIUM_DASHED,
        BORDER_DASH_DOT,
        BORDER_MEDIUM_DASH_DOT,
        BORDER_DASH_DOT_DOT,
        BORDER_MEDIUM_DASH_DOT_DOT,
        BORDER_SLANT_DASH_DOT
};

enum EFontAttributes {
        FONT_NORMAL     = 0,
        FONT_BOLD       = 1,
        FONT_ITALIC     = 2,
        FONT_UNDERLINED = 4,
        FONT_STRIKE     = 8,
        FONT_OUTLINE    = 16,
        FONT_SHADOW     = 32,
        FONT_CONDENSE   = 64,
        FONT_EXTEND     = 128,
};

enum EPatternType {
        PATTERN_NONE = 0,
        PATTERN_SOLID,
        PATTERN_MEDIUM_GRAY,
        PATTERN_DARK_GRAY,
        PATTERN_LIGHT_GRAY,
        PATTERN_DARK_HORIZ,
        PATTERN_DARK_VERT,
        PATTERN_DARK_DOWN,
        PATTERN_DARK_UP,
        PATTERN_DARK_GRID,
        PATTERN_DARK_TRELLIS,
        PATTERN_LIGHT_HORIZ,
        PATTERN_LIGHT_VERT,
        PATTERN_LIGHT_DOWN,
        PATTERN_LIGHT_UP,
        PATTERN_LIGHT_GRID,
        PATTERN_LIGHT_TRELLIS,
        PATTERN_GRAY_125,
        PATTERN_GRAY_0625
};

enum EAlignHoriz {
        ALIGN_H_NONE = 0,
        ALIGN_H_LEFT,
        ALIGN_H_CENTER,
        ALIGN_H_RIGHT
};

enum EAlignVert {
        ALIGN_V_NONE = 0,
        ALIGN_V_TOP,
        ALIGN_V_CENTER,
        ALIGN_V_BOTTOM
};

enum ENumericStyle {
        NUMSTYLE_GENERAL = 0,
        NUMSTYLE_NUMERIC,
        NUMSTYLE_PERCENTAGE,
        NUMSTYLE_EXPONENTIAL,
        NUMSTYLE_FINANCIAL,
        NUMSTYLE_MONEY,
        NUMSTYLE_DATE,
        NUMSTYLE_TIME,
        NUMSTYLE_DATETIME,
};

enum ENumericStyleColor {
        NUMSTYLE_COLOR_DEFAULT = 0,
        NUMSTYLE_COLOR_BLACK,
        NUMSTYLE_COLOR_GREEN,
        NUMSTYLE_COLOR_WHITE,
        NUMSTYLE_COLOR_BLUE,
        NUMSTYLE_COLOR_MAGENTA,
        NUMSTYLE_COLOR_YELLOW,
        NUMSTYLE_COLOR_CYAN,
        NUMSTYLE_COLOR_RED
};

class Font {
public:
        int32_t size;           
        _tstring name;          
        bool theme;                     
        _tstring color;         
        int32_t attributes;     

public:
        Font() {
                Clear();
        }

        void Clear() {
                size = 11;
                name = _T("Calibri");
                theme = true;
                color = _T("");
                attributes = FONT_NORMAL;
        }

        bool operator==(const Font& _font) const {
                return (size == _font.size && name == _font.name && theme == _font.theme &&
                                color == _font.color && attributes == _font.attributes);
        }
};

class Fill {
public:
        EPatternType patternType;       
        _tstring fgColor;                       
        _tstring bgColor;                       

public:
        Fill() {
                Clear();
        }

        void Clear() {
                patternType = PATTERN_NONE;
                fgColor = _T("");
                bgColor = _T("");
        }

        bool operator==(const Fill& _fill) const {
                return (patternType == _fill.patternType && fgColor == _fill.fgColor && bgColor == _fill.bgColor);
        }
};

class Border {
public:
        struct BorderItem {
                EBorderStyle style;             
                _tstring color;                 

                BorderItem() {
                        Clear();
                }

                void Clear() {
                        style = BORDER_NONE;
                        color = _T("");
                }

                bool operator==(const BorderItem& _borderItem) const {
                        return (color == _borderItem.color && style == _borderItem.style);
                }
        };

public:
        BorderItem left;                        
        BorderItem right;                       
        BorderItem bottom;                      
        BorderItem top;                         
        BorderItem diagonal;            
        bool isDiagonalUp;                      
        bool isDiagonalDown;            

public:
        Border() {
                Clear();
        }

        void Clear() {
                isDiagonalUp = false;
                isDiagonalDown = false;

                left.Clear();
                right.Clear();
                bottom.Clear();
                top.Clear();
        }

        bool operator==(const Border& _border) const {
                return (isDiagonalUp == _border.isDiagonalUp && isDiagonalDown == _border.isDiagonalDown &&
                                left == _border.left && right == _border.right &&
                                bottom == _border.bottom && top == _border.top);
        }
};

class NumFormat {
public:
        mutable size_t id;                                      

        _tstring formatString;                          

        ENumericStyle numberStyle;                      
        ENumericStyleColor positiveColor;       
        ENumericStyleColor negativeColor;       
        ENumericStyleColor zeroColor;           
        bool showThousandsSeparator;            
        size_t numberOfDigitsAfterPoint;        

public:
        NumFormat() {
                Clear();
        }

        void Clear() {
                id = 164;
                formatString = _T("");

                numberStyle = NUMSTYLE_GENERAL;
                positiveColor = NUMSTYLE_COLOR_DEFAULT;
                negativeColor = NUMSTYLE_COLOR_DEFAULT;
                zeroColor = NUMSTYLE_COLOR_DEFAULT;
                showThousandsSeparator = false;
                numberOfDigitsAfterPoint = 2;
        }

        bool operator==(const NumFormat& _num) const {
                return (formatString == _num.formatString &&
                                numberStyle == _num.numberStyle && numberOfDigitsAfterPoint == _num.numberOfDigitsAfterPoint &&
                                positiveColor == _num.positiveColor && negativeColor == _num.negativeColor &&
                                zeroColor == _num.zeroColor && showThousandsSeparator == _num.showThousandsSeparator);
        }
};

class Style {
public:
        Font font;                              
        Fill fill;                              
        Border border;                  
        NumFormat numFormat;    
        EAlignHoriz horizAlign; 
        EAlignVert vertAlign;   
        bool wrapText;                  

public:
        Style() {
                Clear();
        }

        void Clear() {
                font.Clear();
                fill.Clear();
                border.Clear();
                horizAlign = ALIGN_H_NONE;
                vertAlign = ALIGN_V_NONE;
                wrapText = false;
        }
};

class CellCoord {
public:
        uint32_t row;   
        uint32_t col;   

public:
        CellCoord() { Clear(); }
        CellCoord(uint32_t _r, uint32_t _c) : row(_r), col(_c) {}

        void Clear() {
                row = 1;
                col = 0;
        }
};

class ColumnWidth {
public:
        uint32_t colFrom;       
        uint32_t colTo;         
        float width;            

public:
        ColumnWidth() {colFrom = colTo = 0; width = 15;}
        ColumnWidth(uint32_t min, uint32_t max, float w) : colFrom(min), colTo(max), width(w) {}
};

class CellDataStr {
public:
    _tstring value;
    int32_t style_id;

public:
    CellDataStr() : value(_T("")), style_id(0) {}
    CellDataStr(const TCHAR *pStr) : value(pStr), style_id(0) {}
    CellDataStr(const _tstring &_str) : value(_str), style_id(0) {}

    CellDataStr& operator=(const CellDataStr& obj) {
                value = obj.value;
                style_id = obj.style_id;
                return *this;
    }

    CellDataStr& operator=(const TCHAR *pStr) {
                value = pStr;
                return *this;
    }

    CellDataStr& operator=(const _tstring &_str) {
                value = _str;
                return *this;
    }
};      
class CellDataTime {
public:
    time_t value;
    int32_t style_id;

public:
    CellDataTime() : value(0), style_id(0) {}
    CellDataTime(time_t _val) : value(_val), style_id(0) {}

    CellDataTime& operator=(const CellDataTime& obj) {
                value = obj.value;
                style_id = obj.style_id;
                return *this;
    }

    CellDataTime& operator=(time_t _val) {
                value = _val;
                return *this;
    }
};      
class CellDataInt {
public:
    int32_t value;
    int32_t style_id;

public:
    CellDataInt() : value(0), style_id(0) {}
    CellDataInt(int32_t _val) : value(_val), style_id(0) {}

    CellDataInt& operator=(const CellDataInt& obj) {
                value = obj.value;
                style_id = obj.style_id;
                return *this;
    }

    CellDataInt& operator=(int32_t _val) {
                value = _val;
                return *this;
    }
};      
class CellDataUInt {
public:
    uint32_t value;
    int32_t style_id;

public:
    CellDataUInt() : value(0), style_id(0) {}
    CellDataUInt(uint32_t _val) : value(_val), style_id(0) {}

    CellDataUInt& operator=(const CellDataUInt& obj) {
                value = obj.value;
                style_id = obj.style_id;
                return *this;
    }

    CellDataUInt& operator=(uint32_t _val) {
                value = _val;
                return *this;
    }
};      
class CellDataDbl {
public:
    double value;
    int32_t style_id;

public:
    CellDataDbl() : value(0.0), style_id(0) {}
    CellDataDbl(double _val) : value(_val), style_id(0) {}

    CellDataDbl& operator=(const CellDataDbl& obj) {
                value = obj.value;
                style_id = obj.style_id;
                return *this;
    }

    CellDataDbl& operator=(double _val) {
                value = _val;
                return *this;
    }
};      
class CellDataFlt {
public:
    float value;
    int32_t style_id;

public:
    CellDataFlt() : value(0.0), style_id(0) {}
    CellDataFlt(float _val) : value(_val), style_id(0) {}

    CellDataFlt& operator=(const CellDataFlt& obj) {
                value = obj.value;
                style_id = obj.style_id;
                return *this;
    }

    CellDataFlt& operator=(float _val) {
                value = _val;
                return *this;
    }
};      

struct Comment {
        int sheetIndex;                                                                         
        std::vector<std::pair<Font, _tstring> > contents;       
        CellCoord cellRef;                                                                      
        _tstring fillColor;                                                                     
        bool isHidden;                                                                          
        int x;                                                                                          
        int y;                                                                                          
        int width;                                                                                      
        int height;                                                                                     

        Comment() {
                Clear();
        }

        void Clear() {
                contents.clear();
                cellRef.Clear();
                fillColor = _T("#FFEFD5");      // papaya whip
                isHidden = true;
                x = y = 50;
                width = height = 100;
        }

        bool operator < (const Comment& _comm) const {
        return (sheetIndex < _comm.sheetIndex);
    }
};

}       // namespace SimpleXlsx

#endif // __SIMPLE_XLSX_DEF_H__