V0.9.17

1、添加了QXlsx Linux动态库

Libraries/Libraries.cmake

@@ -55,6 +55,7 @@ list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/hiredis)
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/CURL)
 #链接FreeType库，目前只支持Windows
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/FreeType)
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/QXlsx)
 
 #搜索所有的库
 # find_package(fmt REQUIRED)
@@ -71,7 +72,7 @@ find_package(SM REQUIRED)
 find_package(LHQLog REQUIRED)
 find_package(LHHTTPAPI REQUIRED)
 
-#FreeType库
+find_package(QXlsx REQUIRED)
 
 
 #有些库缺少某些平台、编译器的库，所以这里也根据平台、编译器进行搜索
@@ -133,4 +134,8 @@ message(STATUS "--------------------------------------------------")
 message(STATUS "hiredis Found : ${hiredis_FOUND}")
 message(STATUS "hiredis Version : ${hiredis_VERSION}")
 message(STATUS "--------------------------------------------------")
+message(STATUS "QXlsx Found : ${QXlsx_FOUND}")
+message(STATUS "QXlsx Version : ${QXlsx_VERSION}")
+message(STATUS "--------------------------------------------------")
+
 

Libraries/QXlsx/FindQXlsx.cmake

@@ -0,0 +1,84 @@
+
+#查找LHQLog库
+
+message(STATUS "===== FindQXlsx.cmake =====")
+
+
+#查找头文件
+unset(INCLUDE_DIR CACHE)
+unset(QXlsx_INCLUDE_DIR CACHE)
+
+find_path(INCLUDE_DIR 
+    NAMES xlsxglobal.h
+    PATHS ${CMAKE_CURRENT_LIST_DIR}/include/QXlsxQt5
+    NO_DEFAULT_PATH
+)
+list(APPEND QXlsx_INCLUDE_DIR ${INCLUDE_DIR})
+
+
+#查找源文件
+# unset(SOURCE_DIR CACHE)
+# unset(LHQLog_SOURCE_DIRS CACHE)
+
+# find_path(SOURCE_DIR 
+#     NAMES LHQLogAPI.cpp
+#     PATHS ${CMAKE_CURRENT_LIST_DIR}/src
+#     NO_DEFAULT_PATH
+# )
+
+# list(APPEND LHQLog_SOURCE_DIRS ${SOURCE_DIR})
+
+#查找库文件，在这里区分平台，Debug和Release，32位和64位
+unset(LIBRARY_DIR CACHE)
+unset(QXlsx_LIBRARY CACHE)
+unset(QXlsx_LIBRARY_STATIC CACHE)
+
+if(CMAKE_SYSTEM_NAME MATCHES "Windows")
+    message(STATUS "No Support Windows")
+    #64位
+    if(CMAKE_SIZEOF_VOID_P MATCHES 8)
+        if(CMAKE_BUILD_TYPE MATCHES "Debug")
+        else()
+        endif()
+    #32位
+    elseif(CMAKE_SIZEOF_VOID_P MATCHES 4)
+        if(CMAKE_BUILD_TYPE MATCHES "Debug")
+        else()
+        endif()
+    endif()
+#Linux，Linux直接指定库的名称，使用模糊搜索可能会把后缀版本号搜出来
+elseif(CMAKE_SYSTEM_NAME MATCHES "Linux")
+    if(CMAKE_BUILD_TYPE MATCHES "Debug")
+        list(APPEND QXlsx_LIBRARY ${CMAKE_CURRENT_LIST_DIR}/lib/libQXlsxQt5d.so)
+        list(APPEND QXlsx_LIBRARY_STATIC ${CMAKE_CURRENT_LIST_DIR}/lib/libQXlsxQt5d.a)
+    elseif(CMAKE_BUILD_TYPE MATCHES "Release")
+        list(APPEND QXlsx_LIBRARY ${CMAKE_CURRENT_LIST_DIR}/lib/libQXlsxQt5.so)
+        list(APPEND QXlsx_LIBRARY_STATIC ${CMAKE_CURRENT_LIST_DIR}/lib/libQXlsxQt5.a)
+    endif()
+endif()
+
+
+#设置变量
+if(QXlsx_INCLUDE_DIR AND (QXlsx_LIBRARY OR QXlsx_LIBRARY_STATIC))
+    set(QXlsx_FOUND TRUE)
+    set(QXlsx_VERSION 1.5.0)
+    # CACHE命令用于定义一个名为LHQLog_INCLUDE_DIRS的缓存变量。这个变量用于存储LHQLog的包含目录路径。
+    # 通过将其定义为缓存变量，用户可以在CMake配置过程中通过命令行或图形界面设置该变量的值。CACHE INTERNAL部分
+    # 指定了缓存变量的类型。在这种情况下，INTERNAL表示该变量只能在CMake脚本内部使用，而不能被外部访问或修改。
+    # 通过使用缓存变量，可以使CMake配置更加灵活和可配置。用户可以根据其特定的需求设置缓存变量的值，而不需要修改
+    # CMake脚本本身。这对于构建可定制的软件项目非常有用。
+    set(QXlsx_INCLUDE_DIR ${QXlsx_INCLUDE_DIR} CACHE INTERNAL "QXlsx include directories")
+    set(QXlsx_LIBRARY ${QXlsx_LIBRARY} CACHE INTERNAL "QXlsx library")
+    set(QXlsx_LIBRARY_STATIC ${QXlsx_LIBRARY_STATIC} CACHE INTERNAL "QXlsx static library")
+
+
+    message(STATUS "QXlsx include: QXlsx_INCLUDE_DIR")
+    message(STATUS "QXlsx library: QXlsx_LIBRARY")
+    message(STATUS "QXlsx static library: QXlsx_LIBRARY_STATIC")
+else()
+    set(QXlsx_FOUND FALSE)
+    
+endif()
+
+
+message(STATUS "--------------------------------------------------")

Libraries/QXlsx/include/QXlsxQt5/xlsxabstractooxmlfile.h

@@ -0,0 +1,43 @@
+// xlsxabstractooxmlfile.h
+
+#ifndef QXLSX_XLSXABSTRACTOOXMLFILE_H
+#define QXLSX_XLSXABSTRACTOOXMLFILE_H
+
+#include "xlsxglobal.h"
+
+QT_BEGIN_NAMESPACE_XLSX
+
+class Relationships;
+class AbstractOOXmlFilePrivate;
+
+class QXLSX_EXPORT AbstractOOXmlFile
+{
+    Q_DECLARE_PRIVATE(AbstractOOXmlFile)
+
+public:
+    enum CreateFlag { F_NewFromScratch, F_LoadFromExists };
+
+public:
+    virtual ~AbstractOOXmlFile();
+
+    virtual void saveToXmlFile(QIODevice *device) const = 0;
+    virtual bool loadFromXmlFile(QIODevice *device)     = 0;
+
+    virtual QByteArray saveToXmlData() const;
+    virtual bool loadFromXmlData(const QByteArray &data);
+
+    Relationships *relationships() const;
+
+    void setFilePath(const QString path);
+    QString filePath() const;
+
+protected:
+    AbstractOOXmlFile(CreateFlag flag);
+    AbstractOOXmlFile(AbstractOOXmlFilePrivate *d);
+
+    AbstractOOXmlFilePrivate *d_ptr;
+};
+
+QT_END_NAMESPACE_XLSX
+
+#endif // QXLSX_XLSXABSTRACTOOXMLFILE_H

Libraries/QXlsx/include/QXlsxQt5/xlsxabstractsheet.h

@@ -0,0 +1,49 @@
+// xlsxabstractsheet.h
+
+#ifndef XLSXABSTRACTSHEET_H
+#define XLSXABSTRACTSHEET_H
+
+#include "xlsxabstractooxmlfile.h"
+#include "xlsxglobal.h"
+
+QT_BEGIN_NAMESPACE_XLSX
+
+class Workbook;
+class Drawing;
+class AbstractSheetPrivate;
+
+class QXLSX_EXPORT AbstractSheet : public AbstractOOXmlFile
+{
+    Q_DECLARE_PRIVATE(AbstractSheet)
+
+public:
+    Workbook *workbook() const;
+
+public:
+    // NOTE: If all Qt  compiler supports C++1x, recommend to use a 'class enum'.
+    enum SheetType { ST_WorkSheet, ST_ChartSheet, ST_DialogSheet, ST_MacroSheet };
+    enum SheetState { SS_Visible, SS_Hidden, SS_VeryHidden };
+
+public:
+    QString sheetName() const;
+    SheetType sheetType() const;
+    SheetState sheetState() const;
+    void setSheetState(SheetState ss);
+    bool isHidden() const;
+    bool isVisible() const;
+    void setHidden(bool hidden);
+    void setVisible(bool visible);
+
+protected:
+    friend class Workbook;
+    AbstractSheet(const QString &sheetName, int sheetId, Workbook *book, AbstractSheetPrivate *d);
+    virtual AbstractSheet *copy(const QString &distName, int distId) const = 0;
+    void setSheetName(const QString &sheetName);
+    void setSheetType(SheetType type);
+    int sheetId() const;
+
+    Drawing *drawing() const;
+};
+
+QT_END_NAMESPACE_XLSX
+#endif // XLSXABSTRACTSHEET_H

Libraries/QXlsx/include/QXlsxQt5/xlsxabstractsheet_p.h

@@ -0,0 +1,35 @@
+// xlsxabstractsheet_p/h
+
+#ifndef XLSXABSTRACTSHEET_P_H
+#define XLSXABSTRACTSHEET_P_H
+
+#include "xlsxabstractooxmlfile_p.h"
+#include "xlsxabstractsheet.h"
+#include "xlsxdrawing_p.h"
+#include "xlsxglobal.h"
+
+#include <memory>
+
+#include <QString>
+
+QT_BEGIN_NAMESPACE_XLSX
+
+class AbstractSheetPrivate : public AbstractOOXmlFilePrivate
+{
+    Q_DECLARE_PUBLIC(AbstractSheet)
+public:
+    AbstractSheetPrivate(AbstractSheet *p, AbstractSheet::CreateFlag flag);
+    ~AbstractSheetPrivate();
+
+    Workbook *workbook;
+    std::shared_ptr<Drawing> drawing;
+
+    QString name;
+    int id;
+    AbstractSheet::SheetState sheetState;
+    AbstractSheet::SheetType type;
+};
+
+QT_END_NAMESPACE_XLSX
+
+#endif // XLSXABSTRACTSHEET_P_H

Libraries/QXlsx/include/QXlsxQt5/xlsxcell.h

@@ -0,0 +1,80 @@
+// xlsxcell.h
+
+#ifndef QXLSX_XLSXCELL_H
+#define QXLSX_XLSXCELL_H
+
+#include "xlsxformat.h"
+#include "xlsxglobal.h"
+
+#include <cstdio>
+
+#include <QDate>
+#include <QDateTime>
+#include <QObject>
+#include <QString>
+#include <QTime>
+#include <QVariant>
+
+QT_BEGIN_NAMESPACE_XLSX
+
+class Worksheet;
+class Format;
+class CellFormula;
+class CellPrivate;
+class WorksheetPrivate;
+
+class QXLSX_EXPORT Cell
+{
+    Q_DECLARE_PRIVATE(Cell)
+
+private:
+    friend class Worksheet;
+    friend class WorksheetPrivate;
+
+public:
+    enum CellType // See ECMA 376, 18.18.11. ST_CellType (Cell Type) for more information.
+    {
+        BooleanType,
+        DateType,
+        ErrorType,
+        InlineStringType,
+        NumberType,
+        SharedStringType,
+        StringType,
+        CustomType, // custom or un-defined cell type
+    };
+
+public:
+    Cell(const QVariant &data = QVariant(),
+         CellType type        = NumberType,
+         const Format &format = Format(),
+         Worksheet *parent    = nullptr,
+         qint32 styleIndex    = (-1));
+    Cell(const Cell *const cell);
+    ~Cell();
+
+public:
+    CellPrivate *const d_ptr; // See D-pointer and Q-pointer of Qt, for more information.
+
+public:
+    CellType cellType() const;
+    QVariant value() const;
+    QVariant readValue() const;
+    Format format() const;
+
+    bool hasFormula() const;
+    CellFormula formula() const;
+
+    bool isDateTime() const;
+    QVariant dateTime() const; // QDateTime, QDate, QTime
+
+    bool isRichString() const;
+
+    qint32 styleNumber() const;
+
+    static bool isDateType(CellType cellType, const Format &format);
+};
+
+QT_END_NAMESPACE_XLSX
+
+#endif // QXLSX_XLSXCELL_H

Libraries/QXlsx/include/QXlsxQt5/xlsxcellformula.h

@@ -0,0 +1,56 @@
+// xlsxcellformula.h
+
+#ifndef QXLSX_XLSXCELLFORMULA_H
+#define QXLSX_XLSXCELLFORMULA_H
+
+#include "xlsxglobal.h"
+
+#include <QExplicitlySharedDataPointer>
+
+class QXmlStreamWriter;
+class QXmlStreamReader;
+
+QT_BEGIN_NAMESPACE_XLSX
+
+class CellFormulaPrivate;
+class CellRange;
+class Worksheet;
+class WorksheetPrivate;
+
+class QXLSX_EXPORT CellFormula
+{
+public:
+    enum FormulaType { NormalType, ArrayType, DataTableType, SharedType };
+
+public:
+    CellFormula();
+    CellFormula(const char *formula, FormulaType type = NormalType);
+    CellFormula(const QString &formula, FormulaType type = NormalType);
+    CellFormula(const QString &formula, const CellRange &ref, FormulaType type);
+    CellFormula(const CellFormula &other);
+    ~CellFormula();
+
+public:
+    CellFormula &operator=(const CellFormula &other);
+    bool isValid() const;
+
+    FormulaType formulaType() const;
+    QString formulaText() const;
+    CellRange reference() const;
+    int sharedIndex() const;
+
+    bool operator==(const CellFormula &formula) const;
+    bool operator!=(const CellFormula &formula) const;
+
+    bool saveToXml(QXmlStreamWriter &writer) const;
+    bool loadFromXml(QXmlStreamReader &reader);
+
+private:
+    friend class Worksheet;
+    friend class WorksheetPrivate;
+    QExplicitlySharedDataPointer<CellFormulaPrivate> d;
+};
+
+QT_END_NAMESPACE_XLSX
+
+#endif // QXLSX_XLSXCELLFORMULA_H

Libraries/QXlsx/include/QXlsxQt5/xlsxcelllocation.h

@@ -0,0 +1,32 @@
+// xlsxcelllocation.h
+
+#ifndef CELL_LOCATION_H
+#define CELL_LOCATION_H
+
+#include "xlsxglobal.h"
+
+#include <memory>
+
+#include <QList>
+#include <QMetaType>
+#include <QObject>
+#include <QString>
+#include <QVector>
+
+QT_BEGIN_NAMESPACE_XLSX
+
+class Cell;
+
+class QXLSX_EXPORT CellLocation
+{
+public:
+    CellLocation();
+
+    int col;
+    int row;
+
+    std::shared_ptr<Cell> cell;
+};
+
+QT_END_NAMESPACE_XLSX
+#endif

Libraries/QXlsx/include/QXlsxQt5/xlsxcellrange.h

@@ -0,0 +1,73 @@
+// xlsxcellrange.h
+
+#ifndef QXLSX_XLSXCELLRANGE_H
+#define QXLSX_XLSXCELLRANGE_H
+
+#include "xlsxcellreference.h"
+#include "xlsxglobal.h"
+
+#include <QObject>
+
+QT_BEGIN_NAMESPACE_XLSX
+
+// dev57
+class QXLSX_EXPORT CellRange
+{
+public:
+    CellRange();
+    CellRange(int firstRow, int firstColumn, int lastRow, int lastColumn);
+    CellRange(const CellReference &topLeft, const CellReference &bottomRight);
+    CellRange(const QString &range);
+    CellRange(const char *range);
+    CellRange(const CellRange &other);
+    ~CellRange();
+
+    QString toString(bool row_abs = false, bool col_abs = false) const;
+    bool isValid() const;
+    inline void setFirstRow(int row) { top = row; }
+    inline void setLastRow(int row) { bottom = row; }
+    inline void setFirstColumn(int col) { left = col; }
+    inline void setLastColumn(int col) { right = col; }
+    inline int firstRow() const { return top; }
+    inline int lastRow() const { return bottom; }
+    inline int firstColumn() const { return left; }
+    inline int lastColumn() const { return right; }
+    inline int rowCount() const { return bottom - top + 1; }
+    inline int columnCount() const { return right - left + 1; }
+    inline CellReference topLeft() const { return CellReference(top, left); }
+    inline CellReference topRight() const { return CellReference(top, right); }
+    inline CellReference bottomLeft() const { return CellReference(bottom, left); }
+    inline CellReference bottomRight() const { return CellReference(bottom, right); }
+
+    inline void operator=(const CellRange &other)
+    {
+        top    = other.top;
+        bottom = other.bottom;
+        left   = other.left;
+        right  = other.right;
+    }
+    inline bool operator==(const CellRange &other) const
+    {
+        return top == other.top && bottom == other.bottom && left == other.left &&
+               right == other.right;
+    }
+    inline bool operator!=(const CellRange &other) const
+    {
+        return top != other.top || bottom != other.bottom || left != other.left ||
+               right != other.right;
+    }
+
+private:
+    void init(const QString &range);
+
+    int top;
+    int left;
+    int bottom;
+    int right;
+};
+
+QT_END_NAMESPACE_XLSX
+
+Q_DECLARE_TYPEINFO(QXlsx::CellRange, Q_MOVABLE_TYPE);
+
+#endif // QXLSX_XLSXCELLRANGE_H

Libraries/QXlsx/include/QXlsxQt5/xlsxcellreference.h

@@ -0,0 +1,58 @@
+// xlsxcellreference.h
+
+#ifndef QXLSX_XLSXCELLREFERENCE_H
+#define QXLSX_XLSXCELLREFERENCE_H
+
+#include "xlsxglobal.h"
+
+QT_BEGIN_NAMESPACE_XLSX
+
+class QXLSX_EXPORT CellReference
+{
+public:
+    CellReference();
+    /*!
+        Constructs the Reference from the given \a row, and \a column.
+    */
+    constexpr CellReference(int row, int column)
+        : _row(row)
+        , _column(column)
+    {
+    }
+    CellReference(const QString &cell);
+    CellReference(const char *cell);
+    CellReference(const CellReference &other);
+    ~CellReference();
+
+    QString toString(bool row_abs = false, bool col_abs = false) const;
+    bool isValid() const;
+    inline void setRow(int row) { _row = row; }
+    inline void setColumn(int col) { _column = col; }
+    inline int row() const { return _row; }
+    inline int column() const { return _column; }
+
+    inline bool operator==(const CellReference &other) const
+    {
+        return _row == other._row && _column == other._column;
+    }
+    inline bool operator!=(const CellReference &other) const
+    {
+        return _row != other._row || _column != other._column;
+    }
+
+    inline bool operator>(const CellReference &other) const
+    {
+        return _row > other._row || _column != other._column;
+    }
+
+private:
+    void init(const QString &cell);
+    int _row{-1};
+    int _column{-1};
+};
+
+QT_END_NAMESPACE_XLSX
+
+Q_DECLARE_TYPEINFO(QXlsx::CellReference, Q_MOVABLE_TYPE);
+
+#endif // QXLSX_XLSXCELLREFERENCE_H

Libraries/QXlsx/include/QXlsxQt5/xlsxchart.h

@@ -0,0 +1,76 @@
+// xlsxchart.h
+
+#ifndef QXLSX_CHART_H
+#define QXLSX_CHART_H
+
+#include "xlsxabstractooxmlfile.h"
+
+#include <QXmlStreamReader>
+#include <QXmlStreamWriter>
+
+QT_BEGIN_NAMESPACE_XLSX
+
+class AbstractSheet;
+class Worksheet;
+class ChartPrivate;
+class CellRange;
+class DrawingAnchor;
+
+class QXLSX_EXPORT Chart : public AbstractOOXmlFile
+{
+    Q_DECLARE_PRIVATE(Chart)
+public:
+    enum ChartType {             // 16 type of chart (ECMA 376)
+        CT_NoStatementChart = 0, // Zero is internally used for unknown types
+        CT_AreaChart,
+        CT_Area3DChart,
+        CT_LineChart,
+        CT_Line3DChart,
+        CT_StockChart,
+        CT_RadarChart,
+        CT_ScatterChart,
+        CT_PieChart,
+        CT_Pie3DChart,
+        CT_DoughnutChart,
+        CT_BarChart,
+        CT_Bar3DChart,
+        CT_OfPieChart,
+        CT_SurfaceChart,
+        CT_Surface3DChart,
+        CT_BubbleChart,
+    };
+    enum ChartAxisPos { None = (-1), Left = 0, Right, Top, Bottom };
+
+private:
+    friend class AbstractSheet;
+    friend class Worksheet;
+    friend class Chartsheet;
+    friend class DrawingAnchor;
+
+private:
+    Chart(AbstractSheet *parent, CreateFlag flag);
+
+public:
+    ~Chart();
+
+public:
+    void addSeries(const CellRange &range,
+                   AbstractSheet *sheet = nullptr,
+                   bool headerH         = false,
+                   bool headerV         = false,
+                   bool swapHeaders     = false);
+    void setChartType(ChartType type);
+    void setChartStyle(int id);
+    void setAxisTitle(Chart::ChartAxisPos pos, QString axisTitle);
+    void setChartTitle(QString strchartTitle);
+    void setChartLegend(Chart::ChartAxisPos legendPos, bool overlap = false);
+    void setGridlinesEnable(bool majorGridlinesEnable = false, bool minorGridlinesEnable = false);
+
+public:
+    bool loadFromXmlFile(QIODevice *device) override;
+    void saveToXmlFile(QIODevice *device) const override;
+};
+
+QT_END_NAMESPACE_XLSX
+
+#endif // QXLSX_CHART_H

Libraries/QXlsx/include/QXlsxQt5/xlsxchartsheet.h

@@ -0,0 +1,37 @@
+// xlsxchartsheet.h
+
+#ifndef XLSXCHARTSHEET_H
+#define XLSXCHARTSHEET_H
+
+#include "xlsxabstractsheet.h"
+
+#include <QStringList>
+
+QT_BEGIN_NAMESPACE_XLSX
+
+class Workbook;
+class DocumentPrivate;
+class ChartsheetPrivate;
+class Chart;
+
+class QXLSX_EXPORT Chartsheet : public AbstractSheet
+{
+    Q_DECLARE_PRIVATE(Chartsheet)
+
+public:
+    ~Chartsheet();
+    Chart *chart();
+
+private:
+    friend class DocumentPrivate;
+    friend class Workbook;
+
+    Chartsheet(const QString &sheetName, int sheetId, Workbook *book, CreateFlag flag);
+    Chartsheet *copy(const QString &distName, int distId) const override;
+
+    void saveToXmlFile(QIODevice *device) const override;
+    bool loadFromXmlFile(QIODevice *device) override;
+};
+
+QT_END_NAMESPACE_XLSX
+#endif // XLSXCHARTSHEET_H

Libraries/QXlsx/include/QXlsxQt5/xlsxconditionalformatting.h

@@ -0,0 +1,130 @@
+// xlsxconditionalformatting.h
+
+#ifndef QXLSX_XLSXCONDITIONALFORMATTING_H
+#define QXLSX_XLSXCONDITIONALFORMATTING_H
+
+#include "xlsxcellrange.h"
+#include "xlsxcellreference.h"
+#include "xlsxglobal.h"
+
+#include <QColor>
+#include <QList>
+#include <QSharedDataPointer>
+#include <QString>
+#include <QXmlStreamReader>
+#include <QXmlStreamWriter>
+
+class ConditionalFormattingTest;
+
+QT_BEGIN_NAMESPACE_XLSX
+
+class Format;
+class Worksheet;
+class Styles;
+class ConditionalFormattingPrivate;
+
+class QXLSX_EXPORT ConditionalFormatting
+{
+public:
+    enum HighlightRuleType {
+        Highlight_LessThan,
+        Highlight_LessThanOrEqual,
+        Highlight_Equal,
+        Highlight_NotEqual,
+        Highlight_GreaterThanOrEqual,
+        Highlight_GreaterThan,
+        Highlight_Between,
+        Highlight_NotBetween,
+
+        Highlight_ContainsText,
+        Highlight_NotContainsText,
+        Highlight_BeginsWith,
+        Highlight_EndsWith,
+
+        Highlight_TimePeriod,
+
+        Highlight_Duplicate,
+        Highlight_Unique,
+        Highlight_Blanks,
+        Highlight_NoBlanks,
+        Highlight_Errors,
+        Highlight_NoErrors,
+
+        Highlight_Top,
+        Highlight_TopPercent,
+        Highlight_Bottom,
+        Highlight_BottomPercent,
+
+        Highlight_AboveAverage,
+        Highlight_AboveOrEqualAverage,
+        Highlight_AboveStdDev1,
+        Highlight_AboveStdDev2,
+        Highlight_AboveStdDev3,
+        Highlight_BelowAverage,
+        Highlight_BelowOrEqualAverage,
+        Highlight_BelowStdDev1,
+        Highlight_BelowStdDev2,
+        Highlight_BelowStdDev3,
+
+        Highlight_Expression
+    };
+
+    enum ValueObjectType { VOT_Formula, VOT_Max, VOT_Min, VOT_Num, VOT_Percent, VOT_Percentile };
+
+public:
+    ConditionalFormatting();
+    ConditionalFormatting(const ConditionalFormatting &other);
+    ~ConditionalFormatting();
+
+public:
+    bool addHighlightCellsRule(HighlightRuleType type,
+                               const Format &format,
+                               bool stopIfTrue = false);
+    bool addHighlightCellsRule(HighlightRuleType type,
+                               const QString &formula1,
+                               const Format &format,
+                               bool stopIfTrue = false);
+    bool addHighlightCellsRule(HighlightRuleType type,
+                               const QString &formula1,
+                               const QString &formula2,
+                               const Format &format,
+                               bool stopIfTrue = false);
+    bool addDataBarRule(const QColor &color, bool showData = true, bool stopIfTrue = false);
+    bool addDataBarRule(const QColor &color,
+                        ValueObjectType type1,
+                        const QString &val1,
+                        ValueObjectType type2,
+                        const QString &val2,
+                        bool showData   = true,
+                        bool stopIfTrue = false);
+    bool
+        add2ColorScaleRule(const QColor &minColor, const QColor &maxColor, bool stopIfTrue = false);
+    bool add3ColorScaleRule(const QColor &minColor,
+                            const QColor &midColor,
+                            const QColor &maxColor,
+                            bool stopIfTrue = false);
+
+    QList<CellRange> ranges() const;
+
+    void addCell(const CellReference &cell);
+    void addCell(int row, int col);
+    void addRange(int firstRow, int firstCol, int lastRow, int lastCol);
+    void addRange(const CellRange &range);
+
+    // needed by QSharedDataPointer!!
+    ConditionalFormatting &operator=(const ConditionalFormatting &other);
+
+private:
+    friend class Worksheet;
+    friend class ::ConditionalFormattingTest;
+
+private:
+    bool saveToXml(QXmlStreamWriter &writer) const;
+    bool loadFromXml(QXmlStreamReader &reader, Styles *styles = nullptr);
+
+    QSharedDataPointer<ConditionalFormattingPrivate> d;
+};
+
+QT_END_NAMESPACE_XLSX
+
+#endif // QXLSX_XLSXCONDITIONALFORMATTING_H

Libraries/QXlsx/include/QXlsxQt5/xlsxdatavalidation.h

@@ -0,0 +1,92 @@
+// xlsxvalidation.h
+
+#ifndef QXLSX_XLSXDATAVALIDATION_H
+#define QXLSX_XLSXDATAVALIDATION_H
+
+#include "xlsxglobal.h"
+
+#include <QList>
+#include <QSharedDataPointer>
+#include <QString>
+#include <QXmlStreamReader>
+#include <QXmlStreamWriter>
+
+class QXmlStreamReader;
+class QXmlStreamWriter;
+
+QT_BEGIN_NAMESPACE_XLSX
+
+class Worksheet;
+class CellRange;
+class CellReference;
+
+class DataValidationPrivate;
+class QXLSX_EXPORT DataValidation
+{
+public:
+    enum ValidationType { None, Whole, Decimal, List, Date, Time, TextLength, Custom };
+
+    enum ValidationOperator {
+        Between,
+        NotBetween,
+        Equal,
+        NotEqual,
+        LessThan,
+        LessThanOrEqual,
+        GreaterThan,
+        GreaterThanOrEqual
+    };
+
+    enum ErrorStyle { Stop, Warning, Information };
+
+    DataValidation();
+    DataValidation(ValidationType type,
+                   ValidationOperator op   = Between,
+                   const QString &formula1 = QString(),
+                   const QString &formula2 = QString(),
+                   bool allowBlank         = false);
+    DataValidation(const DataValidation &other);
+    ~DataValidation();
+
+    ValidationType validationType() const;
+    ValidationOperator validationOperator() const;
+    ErrorStyle errorStyle() const;
+    QString formula1() const;
+    QString formula2() const;
+    bool allowBlank() const;
+    QString errorMessage() const;
+    QString errorMessageTitle() const;
+    QString promptMessage() const;
+    QString promptMessageTitle() const;
+    bool isPromptMessageVisible() const;
+    bool isErrorMessageVisible() const;
+    QList<CellRange> ranges() const;
+
+    void setValidationType(ValidationType type);
+    void setValidationOperator(ValidationOperator op);
+    void setErrorStyle(ErrorStyle es);
+    void setFormula1(const QString &formula);
+    void setFormula2(const QString &formula);
+    void setErrorMessage(const QString &error, const QString &title = QString());
+    void setPromptMessage(const QString &prompt, const QString &title = QString());
+    void setAllowBlank(bool enable);
+    void setPromptMessageVisible(bool visible);
+    void setErrorMessageVisible(bool visible);
+
+    void addCell(const CellReference &cell);
+    void addCell(int row, int col);
+    void addRange(int firstRow, int firstCol, int lastRow, int lastCol);
+    void addRange(const CellRange &range);
+
+    DataValidation &operator=(const DataValidation &other);
+
+    bool saveToXml(QXmlStreamWriter &writer) const;
+    static DataValidation loadFromXml(QXmlStreamReader &reader);
+
+private:
+    QSharedDataPointer<DataValidationPrivate> d;
+};
+
+QT_END_NAMESPACE_XLSX
+
+#endif // QXLSX_XLSXDATAVALIDATION_H

Libraries/QXlsx/include/QXlsxQt5/xlsxdatetype.h

@@ -0,0 +1,47 @@
+// xlsxdatetype.h
+
+#ifndef QXLSX_XLSXDATETYPE_H
+#define QXLSX_XLSXDATETYPE_H
+
+#include "xlsxglobal.h"
+
+#include <QDate>
+#include <QDateTime>
+#include <QObject>
+#include <QString>
+#include <QStringList>
+#include <QTime>
+
+QT_BEGIN_NAMESPACE_XLSX
+
+class QXLSX_EXPORT DateType
+{
+public:
+    DateType();
+    /*
+        DateType(bool is1904 = false);
+        DateType(double d, bool is1904 = false);
+        DateType(QDateTime qdt, bool is1904 = false);
+        DateType(QDate qd, bool is1904 = false);
+        DateType(QTime qt, bool is1904 = false);
+    public:
+        enum currentDateType { DateAndTimeType, OnlyDateType, OnlyTimeType };
+    public:
+        currentDateType getType();
+        bool getValue(QDateTime* pQdt);
+        bool getValue(QDate* pQd);
+        bool getValue(QTime* pQt);
+        bool getValue(double* pD);
+
+    protected:
+
+    protected:
+        bool isSet;
+        double dValue;
+        bool is1904Type;
+        currentDateType dType;
+    */
+};
+
+QT_END_NAMESPACE_XLSX
+#endif

Libraries/QXlsx/include/QXlsxQt5/xlsxdocument.h

@@ -0,0 +1,146 @@
+// xlsxdocument.h
+
+#ifndef QXLSX_XLSXDOCUMENT_H
+#define QXLSX_XLSXDOCUMENT_H
+
+#include "xlsxformat.h"
+#include "xlsxglobal.h"
+#include "xlsxworksheet.h"
+
+#include <QIODevice>
+#include <QImage>
+#include <QObject>
+#include <QVariant>
+
+QT_BEGIN_NAMESPACE_XLSX
+
+class Workbook;
+class Cell;
+class CellRange;
+class DataValidation;
+class ConditionalFormatting;
+class Chart;
+class CellReference;
+class DocumentPrivate;
+
+class QXLSX_EXPORT Document : public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(Document) // D-Pointer. Qt classes have a Q_DECLARE_PRIVATE
+                                // macro in the public class. The macro reads: qglobal.h
+public:
+    explicit Document(QObject *parent = nullptr);
+    Document(const QString &xlsxName, QObject *parent = nullptr);
+    Document(QIODevice *device, QObject *parent = nullptr);
+    ~Document();
+
+    bool write(const CellReference &cell, const QVariant &value, const Format &format = Format());
+    bool write(int row, int col, const QVariant &value, const Format &format = Format());
+
+    QVariant read(const CellReference &cell) const;
+    QVariant read(int row, int col) const;
+
+    int insertImage(int row, int col, const QImage &image);
+    bool getImage(int imageIndex, QImage &img);
+    bool getImage(int row, int col, QImage &img);
+    uint getImageCount();
+
+    Chart *insertChart(int row, int col, const QSize &size);
+
+    bool mergeCells(const CellRange &range, const Format &format = Format());
+    bool unmergeCells(const CellRange &range);
+
+    bool setColumnWidth(const CellRange &range, double width);
+    bool setColumnFormat(const CellRange &range, const Format &format);
+    bool setColumnHidden(const CellRange &range, bool hidden);
+    bool setColumnWidth(int column, double width);
+    bool setColumnFormat(int column, const Format &format);
+    bool setColumnHidden(int column, bool hidden);
+    bool setColumnWidth(int colFirst, int colLast, double width);
+    bool setColumnFormat(int colFirst, int colLast, const Format &format);
+    bool setColumnHidden(int colFirst, int colLast, bool hidden);
+
+    double columnWidth(int column);
+    Format columnFormat(int column);
+    bool isColumnHidden(int column);
+
+    bool setRowHeight(int row, double height);
+    bool setRowFormat(int row, const Format &format);
+    bool setRowHidden(int row, bool hidden);
+    bool setRowHeight(int rowFirst, int rowLast, double height);
+    bool setRowFormat(int rowFirst, int rowLast, const Format &format);
+    bool setRowHidden(int rowFirst, int rowLast, bool hidden);
+
+    double rowHeight(int row);
+    Format rowFormat(int row);
+    bool isRowHidden(int row);
+
+    bool groupRows(int rowFirst, int rowLast, bool collapsed = true);
+    bool groupColumns(int colFirst, int colLast, bool collapsed = true);
+
+    bool addDataValidation(const DataValidation &validation);
+    bool addConditionalFormatting(const ConditionalFormatting &cf);
+
+    std::shared_ptr<Cell> cellAt(const CellReference &cell) const;
+    std::shared_ptr<Cell> cellAt(int row, int col) const;
+
+    bool defineName(const QString &name,
+                    const QString &formula,
+                    const QString &comment = QString(),
+                    const QString &scope   = QString());
+
+    CellRange dimension() const;
+
+    QString documentProperty(const QString &name) const;
+    void setDocumentProperty(const QString &name, const QString &property);
+    QStringList documentPropertyNames() const;
+
+    QStringList sheetNames() const;
+    bool addSheet(const QString &name           = QString(),
+                  AbstractSheet::SheetType type = AbstractSheet::ST_WorkSheet);
+    bool insertSheet(int index,
+                     const QString &name           = QString(),
+                     AbstractSheet::SheetType type = AbstractSheet::ST_WorkSheet);
+    bool selectSheet(const QString &name);
+    bool selectSheet(int index);
+    bool renameSheet(const QString &oldName, const QString &newName);
+    bool copySheet(const QString &srcName, const QString &distName = QString());
+    bool moveSheet(const QString &srcName, int distIndex);
+    bool deleteSheet(const QString &name);
+
+    Workbook *workbook() const;
+    AbstractSheet *sheet(const QString &sheetName) const;
+    AbstractSheet *currentSheet() const;
+    Worksheet *currentWorksheet() const;
+
+    bool save() const;
+    bool saveAs(const QString &xlsXname) const;
+    bool saveAs(QIODevice *device) const;
+
+    bool saveAsCsv(const QString mainCSVFileName) const;
+
+    // copy style from one xlsx file to other
+    static bool copyStyle(const QString &from, const QString &to);
+
+    bool isLoadPackage() const;
+    bool load() const; // equals to isLoadPackage()
+
+    bool changeimage(int filenoinmidea, QString newfile); // add by liufeijin20181025
+
+    bool autosizeColumnWidth(const CellRange &range);
+    bool autosizeColumnWidth(int column);
+    bool autosizeColumnWidth(int colFirst, int colLast);
+    bool autosizeColumnWidth();
+
+private:
+    QMap<int, int> getMaximalColumnWidth(int firstRow = 1, int lastRow = INT_MAX);
+
+private:
+    Q_DISABLE_COPY(Document) // Disables the use of copy constructors and
+                             // assignment operators for the given Class.
+    DocumentPrivate *const d_ptr;
+};
+
+QT_END_NAMESPACE_XLSX
+
+#endif // QXLSX_XLSXDOCUMENT_H

Libraries/QXlsx/include/QXlsxQt5/xlsxformat.h

@@ -0,0 +1,255 @@
+// xlsxformat.h
+
+#ifndef QXLSX_FORMAT_H
+#define QXLSX_FORMAT_H
+
+#include "xlsxglobal.h"
+
+#include <QByteArray>
+#include <QColor>
+#include <QExplicitlySharedDataPointer>
+#include <QFont>
+#include <QList>
+#include <QVariant>
+
+class FormatTest;
+
+QT_BEGIN_NAMESPACE_XLSX
+
+class Styles;
+class Worksheet;
+class WorksheetPrivate;
+class RichStringPrivate;
+class SharedStrings;
+
+class FormatPrivate;
+
+class QXLSX_EXPORT Format
+{
+public:
+    enum FontScript { FontScriptNormal, FontScriptSuper, FontScriptSub };
+
+    enum FontUnderline {
+        FontUnderlineNone,
+        FontUnderlineSingle,
+        FontUnderlineDouble,
+        FontUnderlineSingleAccounting,
+        FontUnderlineDoubleAccounting
+    };
+
+    enum HorizontalAlignment {
+        AlignHGeneral,
+        AlignLeft,
+        AlignHCenter,
+        AlignRight,
+        AlignHFill,
+        AlignHJustify,
+        AlignHMerge,
+        AlignHDistributed
+    };
+
+    enum VerticalAlignment {
+        AlignTop,
+        AlignVCenter,
+        AlignBottom,
+        AlignVJustify,
+        AlignVDistributed
+    };
+
+    enum BorderStyle {
+        BorderNone,
+        BorderThin,
+        BorderMedium,
+        BorderDashed,
+        BorderDotted,
+        BorderThick,
+        BorderDouble,
+        BorderHair,
+        BorderMediumDashed,
+        BorderDashDot,
+        BorderMediumDashDot,
+        BorderDashDotDot,
+        BorderMediumDashDotDot,
+        BorderSlantDashDot
+    };
+
+    enum DiagonalBorderType {
+        DiagonalBorderNone,
+        DiagonalBorderDown,
+        DiagonalBorderUp,
+        DiagnoalBorderBoth
+    };
+
+    enum FillPattern {
+        PatternNone,
+        PatternSolid,
+        PatternMediumGray,
+        PatternDarkGray,
+        PatternLightGray,
+        PatternDarkHorizontal,
+        PatternDarkVertical,
+        PatternDarkDown,
+        PatternDarkUp,
+        PatternDarkGrid,
+        PatternDarkTrellis,
+        PatternLightHorizontal,
+        PatternLightVertical,
+        PatternLightDown,
+        PatternLightUp,
+        PatternLightTrellis,
+        PatternGray125,
+        PatternGray0625,
+        PatternLightGrid
+    };
+
+    Format();
+    Format(const Format &other);
+    Format &operator=(const Format &rhs);
+    ~Format();
+
+    int numberFormatIndex() const;
+    void setNumberFormatIndex(int format);
+    QString numberFormat() const;
+    void setNumberFormat(const QString &format);
+    void setNumberFormat(int id, const QString &format);
+    bool isDateTimeFormat() const;
+
+    int fontSize() const;
+    void setFontSize(int size);
+    bool fontItalic() const;
+    void setFontItalic(bool italic);
+    bool fontStrikeOut() const;
+    void setFontStrikeOut(bool);
+    QColor fontColor() const;
+    void setFontColor(const QColor &);
+    bool fontBold() const;
+    void setFontBold(bool bold);
+    FontScript fontScript() const;
+    void setFontScript(FontScript);
+    FontUnderline fontUnderline() const;
+    void setFontUnderline(FontUnderline);
+    bool fontOutline() const;
+    void setFontOutline(bool outline);
+    QString fontName() const;
+    void setFontName(const QString &);
+    QFont font() const;
+    void setFont(const QFont &font);
+
+    HorizontalAlignment horizontalAlignment() const;
+    void setHorizontalAlignment(HorizontalAlignment align);
+    VerticalAlignment verticalAlignment() const;
+    void setVerticalAlignment(VerticalAlignment align);
+    bool textWrap() const;
+    void setTextWrap(bool textWrap);
+    int rotation() const;
+    void setRotation(int rotation);
+    int indent() const;
+    void setIndent(int indent);
+    bool shrinkToFit() const;
+    void setShrinkToFit(bool shink);
+
+    void setBorderStyle(BorderStyle style);
+    void setBorderColor(const QColor &color);
+    BorderStyle leftBorderStyle() const;
+    void setLeftBorderStyle(BorderStyle style);
+    QColor leftBorderColor() const;
+    void setLeftBorderColor(const QColor &color);
+    BorderStyle rightBorderStyle() const;
+    void setRightBorderStyle(BorderStyle style);
+    QColor rightBorderColor() const;
+    void setRightBorderColor(const QColor &color);
+    BorderStyle topBorderStyle() const;
+    void setTopBorderStyle(BorderStyle style);
+    QColor topBorderColor() const;
+    void setTopBorderColor(const QColor &color);
+    BorderStyle bottomBorderStyle() const;
+    void setBottomBorderStyle(BorderStyle style);
+    QColor bottomBorderColor() const;
+    void setBottomBorderColor(const QColor &color);
+    BorderStyle diagonalBorderStyle() const;
+    void setDiagonalBorderStyle(BorderStyle style);
+    DiagonalBorderType diagonalBorderType() const;
+    void setDiagonalBorderType(DiagonalBorderType style);
+    QColor diagonalBorderColor() const;
+    void setDiagonalBorderColor(const QColor &color);
+
+    FillPattern fillPattern() const;
+    void setFillPattern(FillPattern pattern);
+    QColor patternForegroundColor() const;
+    void setPatternForegroundColor(const QColor &color);
+    QColor patternBackgroundColor() const;
+    void setPatternBackgroundColor(const QColor &color);
+
+    bool locked() const;
+    void setLocked(bool locked);
+    bool hidden() const;
+    void setHidden(bool hidden);
+
+    void mergeFormat(const Format &modifier);
+    bool isValid() const;
+    bool isEmpty() const;
+
+    bool operator==(const Format &format) const;
+    bool operator!=(const Format &format) const;
+
+    QVariant property(int propertyId, const QVariant &defaultValue = QVariant()) const;
+    void setProperty(int propertyId,
+                     const QVariant &value,
+                     const QVariant &clearValue = QVariant(),
+                     bool detach                = true);
+    void clearProperty(int propertyId);
+    bool hasProperty(int propertyId) const;
+
+    bool boolProperty(int propertyId, bool defaultValue = false) const;
+    int intProperty(int propertyId, int defaultValue = 0) const;
+    double doubleProperty(int propertyId, double defaultValue = 0.0) const;
+    QString stringProperty(int propertyId, const QString &defaultValue = QString()) const;
+    QColor colorProperty(int propertyId, const QColor &defaultValue = QColor()) const;
+
+    bool hasNumFmtData() const;
+    bool hasFontData() const;
+    bool hasFillData() const;
+    bool hasBorderData() const;
+    bool hasAlignmentData() const;
+    bool hasProtectionData() const;
+
+    bool fontIndexValid() const;
+    int fontIndex() const;
+    QByteArray fontKey() const;
+    bool borderIndexValid() const;
+    QByteArray borderKey() const;
+    int borderIndex() const;
+    bool fillIndexValid() const;
+    QByteArray fillKey() const;
+    int fillIndex() const;
+
+    QByteArray formatKey() const;
+    bool xfIndexValid() const;
+    int xfIndex() const;
+    bool dxfIndexValid() const;
+    int dxfIndex() const;
+
+    void fixNumberFormat(int id, const QString &format);
+    void setFontIndex(int index);
+    void setBorderIndex(int index);
+    void setFillIndex(int index);
+    void setXfIndex(int index);
+    void setDxfIndex(int index);
+
+private:
+    friend class Styles;
+    friend class ::FormatTest;
+    friend QDebug operator<<(QDebug, const Format &f);
+
+    int theme() const;
+
+    QExplicitlySharedDataPointer<FormatPrivate> d;
+};
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug dbg, const Format &f);
+#endif
+
+QT_END_NAMESPACE_XLSX
+
+#endif // QXLSX_FORMAT_H

Libraries/QXlsx/include/QXlsxQt5/xlsxglobal.h

@@ -0,0 +1,32 @@
+// xlsxglobal.h
+
+#ifndef XLSXGLOBAL_H
+#define XLSXGLOBAL_H
+
+#include <cstdio>
+#include <iostream>
+#include <string>
+
+#include <QByteArray>
+#include <QIODevice>
+#include <QObject>
+#include <QString>
+#include <QStringList>
+#include <QVariant>
+
+#if defined(QXlsx_SHAREDLIB)
+#    if defined(QXlsx_EXPORTS)
+#        define QXLSX_EXPORT Q_DECL_EXPORT
+#    else
+#        define QXLSX_EXPORT Q_DECL_IMPORT
+#    endif
+#else
+#    define QXLSX_EXPORT
+#endif
+
+#define QT_BEGIN_NAMESPACE_XLSX namespace QXlsx {
+#define QT_END_NAMESPACE_XLSX }
+
+#define QXLSX_USE_NAMESPACE using namespace QXlsx;
+
+#endif // XLSXGLOBAL_H

Libraries/QXlsx/include/QXlsxQt5/xlsxrichstring.h

@@ -0,0 +1,91 @@
+/****************************************************************************
+** Copyright (c) 2013-2014 Debao Zhang <hello@debao.me>
+** All right reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining
+** a copy of this software and associated documentation files (the
+** "Software"), to deal in the Software without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Software, and to
+** permit persons to whom the Software is furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+** NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+** LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+** OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+** WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**
+****************************************************************************/
+#ifndef XLSXRICHSTRING_H
+#define XLSXRICHSTRING_H
+
+#include "xlsxformat.h"
+#include "xlsxglobal.h"
+
+#include <QSharedDataPointer>
+#include <QStringList>
+#include <QVariant>
+
+QT_BEGIN_NAMESPACE_XLSX
+class RichStringPrivate;
+class RichString;
+// qHash is a friend, but we can't use default arguments for friends (§8.3.6.4)
+uint qHash(const RichString &rs, uint seed = 0) Q_DECL_NOTHROW;
+
+class QXLSX_EXPORT RichString
+{
+public:
+    RichString();
+    explicit RichString(const QString &text);
+    RichString(const RichString &other);
+    ~RichString();
+
+    bool isRichString() const;
+    bool isNull() const;
+    bool isEmtpy() const;
+    QString toPlainString() const;
+    QString toHtml() const;
+    void setHtml(const QString &text);
+
+    int fragmentCount() const;
+    void addFragment(const QString &text, const Format &format);
+    QString fragmentText(int index) const;
+    Format fragmentFormat(int index) const;
+
+    operator QVariant() const;
+
+    RichString &operator=(const RichString &other);
+
+private:
+    friend uint qHash(const RichString &rs, uint seed) Q_DECL_NOTHROW;
+    friend bool operator==(const RichString &rs1, const RichString &rs2);
+    friend bool operator!=(const RichString &rs1, const RichString &rs2);
+    friend bool operator<(const RichString &rs1, const RichString &rs2);
+    friend QDebug operator<<(QDebug dbg, const RichString &rs);
+
+    QSharedDataPointer<RichStringPrivate> d;
+};
+
+bool operator==(const RichString &rs1, const RichString &rs2);
+bool operator!=(const RichString &rs1, const RichString &rs2);
+bool operator<(const RichString &rs1, const RichString &rs2);
+bool operator==(const RichString &rs1, const QString &rs2);
+bool operator==(const QString &rs1, const RichString &rs2);
+bool operator!=(const RichString &rs1, const QString &rs2);
+bool operator!=(const QString &rs1, const RichString &rs2);
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug dbg, const RichString &rs);
+#endif
+
+QT_END_NAMESPACE_XLSX
+
+Q_DECLARE_METATYPE(QXlsx::RichString)
+
+#endif // XLSXRICHSTRING_H

Libraries/QXlsx/include/QXlsxQt5/xlsxworkbook.h

@@ -0,0 +1,101 @@
+// xlsxworkbook.h
+
+#ifndef XLSXWORKBOOK_H
+#define XLSXWORKBOOK_H
+
+#include "xlsxabstractooxmlfile.h"
+#include "xlsxabstractsheet.h"
+#include "xlsxglobal.h"
+
+#include <memory>
+
+#include <QIODevice>
+#include <QImage>
+#include <QList>
+
+QT_BEGIN_NAMESPACE_XLSX
+
+class SharedStrings;
+class Styles;
+class Drawing;
+class Document;
+class Theme;
+class Relationships;
+class DocumentPrivate;
+class MediaFile;
+class Chart;
+class Chartsheet;
+class Worksheet;
+class WorkbookPrivate;
+
+class QXLSX_EXPORT Workbook : public AbstractOOXmlFile
+{
+    Q_DECLARE_PRIVATE(Workbook)
+public:
+    ~Workbook();
+
+    int sheetCount() const;
+    AbstractSheet *sheet(int index) const;
+
+    AbstractSheet *addSheet(const QString &name           = QString(),
+                            AbstractSheet::SheetType type = AbstractSheet::ST_WorkSheet);
+    AbstractSheet *insertSheet(int index,
+                               const QString &name           = QString(),
+                               AbstractSheet::SheetType type = AbstractSheet::ST_WorkSheet);
+    bool renameSheet(int index, const QString &name);
+    bool deleteSheet(int index);
+    bool copySheet(int index, const QString &newName = QString());
+    bool moveSheet(int srcIndex, int distIndex);
+
+    AbstractSheet *activeSheet() const;
+    bool setActiveSheet(int index);
+
+    //    void addChart();
+    bool defineName(const QString &name,
+                    const QString &formula,
+                    const QString &comment = QString(),
+                    const QString &scope   = QString());
+    bool isDate1904() const;
+    void setDate1904(bool date1904);
+    bool isStringsToNumbersEnabled() const;
+    void setStringsToNumbersEnabled(bool enable = true);
+    bool isStringsToHyperlinksEnabled() const;
+    void setStringsToHyperlinksEnabled(bool enable = true);
+    bool isHtmlToRichStringEnabled() const;
+    void setHtmlToRichStringEnabled(bool enable = true);
+    QString defaultDateFormat() const;
+    void setDefaultDateFormat(const QString &format);
+
+    // internal used member
+    void addMediaFile(std::shared_ptr<MediaFile> media, bool force = false);
+    QList<std::shared_ptr<MediaFile>> mediaFiles() const;
+    void addChartFile(std::shared_ptr<Chart> chartFile);
+    QList<std::shared_ptr<Chart>> chartFiles() const;
+
+private:
+    friend class Worksheet;
+    friend class Chartsheet;
+    friend class WorksheetPrivate;
+    friend class Document;
+    friend class DocumentPrivate;
+
+    Workbook(Workbook::CreateFlag flag);
+
+    void saveToXmlFile(QIODevice *device) const override;
+    bool loadFromXmlFile(QIODevice *device) override;
+
+    SharedStrings *sharedStrings() const;
+    Styles *styles();
+    Theme *theme();
+    QList<QImage> images();
+    QList<Drawing *> drawings();
+    QList<std::shared_ptr<AbstractSheet>> getSheetsByTypes(AbstractSheet::SheetType type) const;
+    QStringList worksheetNames() const;
+    AbstractSheet *addSheet(const QString &name,
+                            int sheetId,
+                            AbstractSheet::SheetType type = AbstractSheet::ST_WorkSheet);
+};
+
+QT_END_NAMESPACE_XLSX
+
+#endif // XLSXWORKBOOK_H

Libraries/QXlsx/include/QXlsxQt5/xlsxworksheet.h

@@ -0,0 +1,197 @@
+// xlsxworksheet.h
+
+#ifndef XLSXWORKSHEET_H
+#define XLSXWORKSHEET_H
+
+#include "xlsxabstractsheet.h"
+#include "xlsxcell.h"
+#include "xlsxcelllocation.h"
+#include "xlsxcellrange.h"
+#include "xlsxcellreference.h"
+
+#include <QDateTime>
+#include <QIODevice>
+#include <QImage>
+#include <QMap>
+#include <QObject>
+#include <QPointF>
+#include <QStringList>
+#include <QUrl>
+#include <QVariant>
+
+class WorksheetTest;
+
+QT_BEGIN_NAMESPACE_XLSX
+
+class DocumentPrivate;
+class Workbook;
+class Format;
+class Drawing;
+class DataValidation;
+class ConditionalFormatting;
+class CellRange;
+class RichString;
+class Relationships;
+class Chart;
+
+class WorksheetPrivate;
+class QXLSX_EXPORT Worksheet : public AbstractSheet
+{
+    Q_DECLARE_PRIVATE(Worksheet)
+
+private:
+    friend class DocumentPrivate;
+    friend class Workbook;
+    friend class ::WorksheetTest;
+    Worksheet(const QString &sheetName, int sheetId, Workbook *book, CreateFlag flag);
+    Worksheet *copy(const QString &distName, int distId) const override;
+
+public:
+    ~Worksheet();
+
+public:
+    bool write(const CellReference &row_column,
+               const QVariant &value,
+               const Format &format = Format());
+    bool write(int row, int column, const QVariant &value, const Format &format = Format());
+
+    QVariant read(const CellReference &row_column) const;
+    QVariant read(int row, int column) const;
+
+    bool writeString(const CellReference &row_column,
+                     const QString &value,
+                     const Format &format = Format());
+    bool writeString(int row, int column, const QString &value, const Format &format = Format());
+    bool writeString(const CellReference &row_column,
+                     const RichString &value,
+                     const Format &format = Format());
+    bool writeString(int row, int column, const RichString &value, const Format &format = Format());
+
+    bool writeInlineString(const CellReference &row_column,
+                           const QString &value,
+                           const Format &format = Format());
+    bool writeInlineString(int row,
+                           int column,
+                           const QString &value,
+                           const Format &format = Format());
+
+    bool writeNumeric(const CellReference &row_column,
+                      double value,
+                      const Format &format = Format());
+    bool writeNumeric(int row, int column, double value, const Format &format = Format());
+
+    bool writeFormula(const CellReference &row_column,
+                      const CellFormula &formula,
+                      const Format &format = Format(),
+                      double result        = 0);
+    bool writeFormula(int row,
+                      int column,
+                      const CellFormula &formula,
+                      const Format &format = Format(),
+                      double result        = 0);
+
+    bool writeBlank(const CellReference &row_column, const Format &format = Format());
+    bool writeBlank(int row, int column, const Format &format = Format());
+
+    bool writeBool(const CellReference &row_column, bool value, const Format &format = Format());
+    bool writeBool(int row, int column, bool value, const Format &format = Format());
+
+    bool writeDateTime(const CellReference &row_column,
+                       const QDateTime &dt,
+                       const Format &format = Format());
+    bool writeDateTime(int row, int column, const QDateTime &dt, const Format &format = Format());
+
+    // dev67
+    bool writeDate(const CellReference &row_column,
+                   const QDate &dt,
+                   const Format &format = Format());
+    bool writeDate(int row, int column, const QDate &dt, const Format &format = Format());
+
+    bool
+        writeTime(const CellReference &row_column, const QTime &t, const Format &format = Format());
+    bool writeTime(int row, int column, const QTime &t, const Format &format = Format());
+
+    bool writeHyperlink(const CellReference &row_column,
+                        const QUrl &url,
+                        const Format &format   = Format(),
+                        const QString &display = QString(),
+                        const QString &tip     = QString());
+    bool writeHyperlink(int row,
+                        int column,
+                        const QUrl &url,
+                        const Format &format   = Format(),
+                        const QString &display = QString(),
+                        const QString &tip     = QString());
+
+    bool addDataValidation(const DataValidation &validation);
+    bool addConditionalFormatting(const ConditionalFormatting &cf);
+
+    std::shared_ptr<Cell> cellAt(const CellReference &row_column) const;
+    std::shared_ptr<Cell> cellAt(int row, int column) const;
+
+    int insertImage(int row, int column, const QImage &image);
+    bool getImage(int imageIndex, QImage &img);
+    bool getImage(int row, int column, QImage &img);
+    uint getImageCount();
+
+    Chart *insertChart(int row, int column, const QSize &size);
+
+    bool mergeCells(const CellRange &range, const Format &format = Format());
+    bool unmergeCells(const CellRange &range);
+    QList<CellRange> mergedCells() const;
+
+    bool setColumnWidth(const CellRange &range, double width);
+    bool setColumnFormat(const CellRange &range, const Format &format);
+    bool setColumnHidden(const CellRange &range, bool hidden);
+    bool setColumnWidth(int colFirst, int colLast, double width);
+    bool setColumnFormat(int colFirst, int colLast, const Format &format);
+    bool setColumnHidden(int colFirst, int colLast, bool hidden);
+
+    double columnWidth(int column);
+    Format columnFormat(int column);
+    bool isColumnHidden(int column);
+
+    bool setRowHeight(int rowFirst, int rowLast, double height);
+    bool setRowFormat(int rowFirst, int rowLast, const Format &format);
+    bool setRowHidden(int rowFirst, int rowLast, bool hidden);
+
+    double rowHeight(int row);
+    Format rowFormat(int row);
+    bool isRowHidden(int row);
+
+    bool groupRows(int rowFirst, int rowLast, bool collapsed = true);
+    bool groupColumns(int colFirst, int colLast, bool collapsed = true);
+    bool groupColumns(const CellRange &range, bool collapsed = true);
+    CellRange dimension() const;
+
+    bool isWindowProtected() const;
+    void setWindowProtected(bool protect);
+    bool isFormulasVisible() const;
+    void setFormulasVisible(bool visible);
+    bool isGridLinesVisible() const;
+    void setGridLinesVisible(bool visible);
+    bool isRowColumnHeadersVisible() const;
+    void setRowColumnHeadersVisible(bool visible);
+    bool isZerosVisible() const;
+    void setZerosVisible(bool visible);
+    bool isRightToLeft() const;
+    void setRightToLeft(bool enable);
+    bool isSelected() const;
+    void setSelected(bool select);
+    bool isRulerVisible() const;
+    void setRulerVisible(bool visible);
+    bool isOutlineSymbolsVisible() const;
+    void setOutlineSymbolsVisible(bool visible);
+    bool isWhiteSpaceVisible() const;
+    void setWhiteSpaceVisible(bool visible);
+    bool setStartPage(int spagen); // add by liufeijin20181028
+
+    QVector<CellLocation> getFullCells(int *maxRow, int *maxCol) const;
+
+private:
+    void saveToXmlFile(QIODevice *device) const override;
+    bool loadFromXmlFile(QIODevice *device) override;
+};
+
+QT_END_NAMESPACE_XLSX
+#endif // XLSXWORKSHEET_H

Libraries/QXlsx/lib/cmake/QXlsxQt5/QXlsxQt5Config.cmake

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: (C) 2021 Daniel Nicoletti <dantti12@gmail.com>
+# SPDX-License-Identifier: MIT
+
+# - Config information for QXlsx
+# This file defines:
+#
+#  QXlsx_INCLUDE_DIR - the QXlsx include directory
+#  QXlsx_LIBRARY - Link these to use QXlsx
+
+SET(prefix "/data/home/Apple/Libs/ZIP/QXlsx")
+SET(exec_prefix "/data/home/Apple/Libs/ZIP/QXlsx")
+SET(QXlsx_FOUND "TRUE")
+
+include("${CMAKE_CURRENT_LIST_DIR}/QXlsxQt5Targets.cmake")

Libraries/QXlsx/lib/cmake/QXlsxQt5/QXlsxQt5ConfigVersion.cmake

@@ -0,0 +1,15 @@
+# SPDX-FileCopyrightText: (C) 2021 Daniel Nicoletti <dantti12@gmail.com>
+# SPDX-License-Identifier: MIT
+
+SET(PACKAGE_VERSION 1.5.0)
+IF (PACKAGE_FIND_VERSION VERSION_EQUAL PACKAGE_VERSION)
+  SET(PACKAGE_VERSION_EXACT "true")
+ENDIF (PACKAGE_FIND_VERSION VERSION_EQUAL PACKAGE_VERSION)
+IF (NOT PACKAGE_FIND_VERSION VERSION_GREATER PACKAGE_VERSION)
+  SET(PACKAGE_VERSION_COMPATIBLE "true")
+ELSE (NOT PACKAGE_FIND_VERSION VERSION_GREATER PACKAGE_VERSION)
+  SET(PACKAGE_VERSION_UNSUITABLE "true")
+ENDIF (NOT PACKAGE_FIND_VERSION VERSION_GREATER PACKAGE_VERSION)
+IF (PACKAGE_VERSION_UNSUITABLE)
+  MESSAGE("VERSION CHECK FAILED FOR ${PACKAGE_FIND_NAME}. WANTED ${PACKAGE_FIND_VERSION}, HAVE ${PACKAGE_VERSION}")
+ENDIF(PACKAGE_VERSION_UNSUITABLE)

Libraries/QXlsx/lib/cmake/QXlsxQt5/QXlsxQt5Targets-release.cmake

@@ -0,0 +1,19 @@
+#----------------------------------------------------------------
+# Generated CMake target import file for configuration "Release".
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Import target "QXlsx::QXlsx" for configuration "Release"
+set_property(TARGET QXlsx::QXlsx APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(QXlsx::QXlsx PROPERTIES
+  IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/libQXlsxQt5.a"
+  )
+
+list(APPEND _IMPORT_CHECK_TARGETS QXlsx::QXlsx )
+list(APPEND _IMPORT_CHECK_FILES_FOR_QXlsx::QXlsx "${_IMPORT_PREFIX}/lib/libQXlsxQt5.a" )
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)

Libraries/QXlsx/lib/cmake/QXlsxQt5/QXlsxQt5Targets.cmake

@@ -0,0 +1,100 @@
+# Generated by CMake
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.6)
+   message(FATAL_ERROR "CMake >= 2.6.0 required")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 2.6...3.20)
+#----------------------------------------------------------------
+# Generated CMake target import file.
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Protect against multiple inclusion, which would fail when already imported targets are added once more.
+set(_targetsDefined)
+set(_targetsNotDefined)
+set(_expectedTargets)
+foreach(_expectedTarget QXlsx::QXlsx)
+  list(APPEND _expectedTargets ${_expectedTarget})
+  if(NOT TARGET ${_expectedTarget})
+    list(APPEND _targetsNotDefined ${_expectedTarget})
+  endif()
+  if(TARGET ${_expectedTarget})
+    list(APPEND _targetsDefined ${_expectedTarget})
+  endif()
+endforeach()
+if("${_targetsDefined}" STREQUAL "${_expectedTargets}")
+  unset(_targetsDefined)
+  unset(_targetsNotDefined)
+  unset(_expectedTargets)
+  set(CMAKE_IMPORT_FILE_VERSION)
+  cmake_policy(POP)
+  return()
+endif()
+if(NOT "${_targetsDefined}" STREQUAL "")
+  message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_targetsDefined}\nTargets not yet defined: ${_targetsNotDefined}\n")
+endif()
+unset(_targetsDefined)
+unset(_targetsNotDefined)
+unset(_expectedTargets)
+
+
+# Compute the installation prefix relative to this file.
+get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+if(_IMPORT_PREFIX STREQUAL "/")
+  set(_IMPORT_PREFIX "")
+endif()
+
+# Create imported target QXlsx::QXlsx
+add_library(QXlsx::QXlsx STATIC IMPORTED)
+
+set_target_properties(QXlsx::QXlsx PROPERTIES
+  INTERFACE_COMPILE_FEATURES "cxx_std_11"
+  INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/QXlsxQt5"
+  INTERFACE_LINK_LIBRARIES "Qt5::Core;Qt5::GuiPrivate"
+)
+
+if(CMAKE_VERSION VERSION_LESS 2.8.12)
+  message(FATAL_ERROR "This file relies on consumers using CMake 2.8.12 or greater.")
+endif()
+
+# Load information for each installed configuration.
+get_filename_component(_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
+file(GLOB CONFIG_FILES "${_DIR}/QXlsxQt5Targets-*.cmake")
+foreach(f ${CONFIG_FILES})
+  include(${f})
+endforeach()
+
+# Cleanup temporary variables.
+set(_IMPORT_PREFIX)
+
+# Loop over all imported files and verify that they actually exist
+foreach(target ${_IMPORT_CHECK_TARGETS} )
+  foreach(file ${_IMPORT_CHECK_FILES_FOR_${target}} )
+    if(NOT EXISTS "${file}" )
+      message(FATAL_ERROR "The imported target \"${target}\" references the file
+   \"${file}\"
+but this file does not exist.  Possible reasons include:
+* The file was deleted, renamed, or moved to another location.
+* An install or uninstall procedure did not complete successfully.
+* The installation package was faulty and contained
+   \"${CMAKE_CURRENT_LIST_FILE}\"
+but not all the files it references.
+")
+    endif()
+  endforeach()
+  unset(_IMPORT_CHECK_FILES_FOR_${target})
+endforeach()
+unset(_IMPORT_CHECK_TARGETS)
+
+# This file does not depend on other imported targets which have
+# been exported from the same project but in a separate export set.
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+cmake_policy(POP)

Libraries/QXlsx/lib/libQXlsxQt5.so

@@ -0,0 +1 @@
+libQXlsxQt5.so.1

Libraries/QXlsx/lib/libQXlsxQt5.so.1

@@ -0,0 +1 @@
+libQXlsxQt5.so.1.5.0

Libraries/QXlsx/lib/libQXlsxQt5d.so

@@ -0,0 +1 @@
+libQXlsxQt5d.so.1

Libraries/QXlsx/lib/libQXlsxQt5d.so.1

@@ -0,0 +1 @@
+libQXlsxQt5d.so.1.5.0