转码工具页面功能

2026-05-25 10:18:19 +08:00
commit 3db5fe7f13
107 changed files with 8591 additions and 0 deletions
@@ -0,0 +1,39 @@
+#ifndef ELAACRYLICURLCARD_H
+#define ELAACRYLICURLCARD_H
+
+#include <QPixmap>
+#include <QPushButton>
+
+#include "ElaDef.h"
+#include "ElaProperty.h"
+class ElaAcrylicUrlCardPrivate;
+class ELA_EXPORT ElaAcrylicUrlCard : public QPushButton
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaAcrylicUrlCard);
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+    Q_PROPERTY_CREATE_Q_H(qreal, MainOpacity)
+    Q_PROPERTY_CREATE_Q_H(qreal, NoiseOpacity)
+    Q_PROPERTY_CREATE_Q_H(int, BrushAlpha)
+    Q_PROPERTY_CREATE_Q_H(QString, Title);
+    Q_PROPERTY_CREATE_Q_H(QString, SubTitle);
+    Q_PROPERTY_CREATE_Q_H(int, TitlePixelSize);
+    Q_PROPERTY_CREATE_Q_H(int, SubTitlePixelSize);
+    Q_PROPERTY_CREATE_Q_H(int, TitleSpacing);
+    Q_PROPERTY_CREATE_Q_H(int, SubTitleSpacing);
+    Q_PROPERTY_CREATE_Q_H(QPixmap, CardPixmap);
+    Q_PROPERTY_CREATE_Q_H(QSize, CardPixmapSize);
+    Q_PROPERTY_CREATE_Q_H(int, CardPixmapBorderRadius)
+    Q_PROPERTY_CREATE_Q_H(ElaCardPixType::PixMode, CardPixMode);
+    Q_PROPERTY_CREATE_Q_H(QString, Url);
+
+public:
+    explicit ElaAcrylicUrlCard(QWidget* parent = nullptr);
+    ~ElaAcrylicUrlCard() override;
+    void setCardPixmapSize(int width, int height);
+
+protected:
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELAACRYLICURLCARD_H
@@ -0,0 +1,45 @@
+#ifndef ELAACTIONCOMMANDER_H
+#define ELAACTIONCOMMANDER_H
+
+#include <QObject>
+#include <QVariantMap>
+
+#include "ElaDef.h"
+#include "ElaSingleton.h"
+
+class ELA_EXPORT ElaActionCommand : public QObject
+{
+    Q_OBJECT
+public:
+    explicit ElaActionCommand(QObject* parent = nullptr);
+    ~ElaActionCommand() override;
+
+    virtual void undo() = 0;
+    virtual void redo() = 0;
+};
+
+class ElaActionCommanderPrivate;
+class ELA_EXPORT ElaActionCommander : public QObject
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaActionCommander)
+    Q_SINGLETON_CREATE_H(ElaActionCommander)
+    Q_PROPERTY_CREATE_Q_H(int, MaxRouteCount)
+private:
+    explicit ElaActionCommander(QObject* parent = nullptr);
+    ~ElaActionCommander() override;
+
+Q_SIGNALS:
+    Q_SIGNAL void commanderStateChanged(const QString& domainName, ElaActionCommanderType::CommanderState state);
+
+public:
+    void recordCommand(const QString& domainName, ElaActionCommand* command, bool isRedo = true);
+    void clearCommand(const QString& domainName);
+    void undoCommand(const QString& domainName);
+    void redoCommand(const QString& domainName);
+
+    ElaActionCommanderType::CommanderState getCommanderUndoState(const QString& domainName) const;
+    ElaActionCommanderType::CommanderState getCommanderRedoState(const QString& domainName) const;
+};
+
+#endif // ELAACTIONCOMMANDER_H
@@ -0,0 +1,101 @@
+#ifndef ELAAPPBAR_H
+#define ELAAPPBAR_H
+
+#include <QWidget>
+
+#include "ElaDef.h"
+
+#ifdef Q_OS_WIN
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+#define Q_TAKEOVER_NATIVEEVENT_H virtual bool nativeEvent(const QByteArray& eventType, void* message, qintptr* result) override;
+#else
+#define Q_TAKEOVER_NATIVEEVENT_H virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result) override;
+#endif
+#else
+#define Q_TAKEOVER_NATIVEEVENT_H
+#endif
+
+#ifdef Q_OS_WIN
+#define ELAAPPBAR_HANDLE(ElaAppBar)                                           \
+    if (ElaAppBar)                                                            \
+    {                                                                         \
+        int ret = ElaAppBar->takeOverNativeEvent(eventType, message, result); \
+        if (ret == -1)                                                        \
+        {                                                                     \
+            return QWidget::nativeEvent(eventType, message, result);          \
+        }                                                                     \
+        return (bool)ret;                                                     \
+    }                                                                         \
+    return QWidget::nativeEvent(eventType, message, result);
+#endif
+
+#ifdef Q_OS_WIN
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+#define Q_TAKEOVER_NATIVEEVENT_CPP(CLASS, ElaAppBar)                                     \
+    bool CLASS::nativeEvent(const QByteArray& eventType, void* message, qintptr* result) \
+    {                                                                                    \
+        ELAAPPBAR_HANDLE(ElaAppBar)                                                      \
+    }
+#else
+#define Q_TAKEOVER_NATIVEEVENT_CPP(CLASS, ElaAppBar)                                  \
+    bool CLASS::nativeEvent(const QByteArray& eventType, void* message, long* result) \
+    {                                                                                 \
+        ELAAPPBAR_HANDLE(ElaAppBar)                                                   \
+    }
+#endif
+#else
+#define Q_TAKEOVER_NATIVEEVENT_CPP(CLASS, ElaAppBar)
+#endif
+
+class QMenu;
+class ElaAppBarPrivate;
+class ELA_EXPORT ElaAppBar : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaAppBar)
+    Q_PROPERTY_CREATE_Q_H(bool, IsStayTop)
+    Q_PROPERTY_CREATE_Q_H(bool, IsFixedSize)
+    Q_PROPERTY_CREATE_Q_H(bool, IsDefaultClosed)
+    Q_PROPERTY_CREATE_Q_H(bool, IsOnlyAllowMinAndClose)
+    Q_PROPERTY_CREATE_Q_H(int, AppBarHeight)
+public:
+    explicit ElaAppBar(QWidget* parent = nullptr);
+    ~ElaAppBar() override;
+
+    void setCustomWidget(ElaAppBarType::CustomArea customArea, QWidget* customWidget, QObject* hitTestObject = nullptr, const QString& hitTestFunctionName = "");
+    QWidget* getCustomWidget(ElaAppBarType::CustomArea customArea) const;
+
+    void setCustomMenu(QMenu* customMenu);
+    QMenu* getCustomMenu() const;
+
+    void setWindowButtonFlag(ElaAppBarType::ButtonType buttonFlag, bool isEnable = true);
+    void setWindowButtonFlags(ElaAppBarType::ButtonFlags buttonFlags);
+    ElaAppBarType::ButtonFlags getWindowButtonFlags() const;
+
+    void setRouteBackButtonEnable(bool isEnable);
+    void setRouteForwardButtonEnable(bool isEnable);
+
+#ifdef Q_OS_WIN
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    int takeOverNativeEvent(const QByteArray& eventType, void* message, qintptr* result);
+#else
+    int takeOverNativeEvent(const QByteArray& eventType, void* message, long* result);
+#endif
+#endif
+Q_SIGNALS:
+    Q_SIGNAL void routeBackButtonClicked();
+    Q_SIGNAL void routeForwardButtonClicked();
+    Q_SIGNAL void navigationButtonClicked();
+    Q_SIGNAL void themeChangeButtonClicked();
+    Q_SIGNAL void closeButtonClicked();
+    Q_SIGNAL void customWidgetChanged();
+    Q_SIGNAL void customMenuChanged();
+
+protected:
+    virtual bool eventFilter(QObject* obj, QEvent* event) override;
+#ifdef Q_OS_WIN
+    virtual void paintEvent(QPaintEvent* event) override;
+#endif
+};
+
+#endif // ELAAPPBAR_H
@@ -0,0 +1,28 @@
+#ifndef ELAAPPLICATION_H
+#define ELAAPPLICATION_H
+
+#include <QIcon>
+#include <QObject>
+
+#include "ElaDef.h"
+#include "ElaSingleton.h"
+#define eApp ElaApplication::getInstance()
+class ElaApplicationPrivate;
+class ELA_EXPORT ElaApplication : public QObject
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaApplication)
+    Q_SINGLETON_CREATE_H(ElaApplication)
+    Q_PROPERTY_CREATE_Q_H(ElaApplicationType::WindowDisplayMode, WindowDisplayMode)
+    Q_PROPERTY_CREATE_Q_H(QString, ElaMicaImagePath)
+private:
+    explicit ElaApplication(QObject* parent = nullptr);
+    ~ElaApplication() override;
+
+public:
+    void init();
+    void syncWindowDisplayMode(QWidget* widget, bool isSync = true);
+    static bool containsCursorToItem(QWidget* item);
+};
+
+#endif // ELAAPPLICATION_H
@@ -0,0 +1,28 @@
+#ifndef ELABREADCRUMBBAR_H
+#define ELABREADCRUMBBAR_H
+#include <QWidget>
+
+#include "ElaProperty.h"
+
+class ElaBreadcrumbBarPrivate;
+class ELA_EXPORT ElaBreadcrumbBar : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaBreadcrumbBar)
+    Q_PROPERTY_CREATE_Q_H(int, TextPixelSize)
+    Q_PROPERTY_CREATE_Q_H(bool, IsAutoRemove)
+public:
+    explicit ElaBreadcrumbBar(QWidget* parent = nullptr);
+    ~ElaBreadcrumbBar() override;
+    void setBreadcrumbList(QStringList breadcrumbList);
+    QStringList appendBreadcrumb(QString breadcrumb);
+    QStringList removeBreadcrumb(QString breadcrumb);
+
+    int getBreadcrumbListCount() const;
+    QStringList getBreadcrumbList() const;
+
+Q_SIGNALS:
+    Q_SIGNAL void breadcrumbClicked(QString breadcrumb, QStringList lastBreadcrumbList);
+};
+
+#endif // ELABREADCRUMBBAR_H
@@ -0,0 +1,26 @@
+#ifndef ELACALENDAR_H
+#define ELACALENDAR_H
+
+#include "ElaProperty.h"
+#include <QDate>
+#include <QWidget>
+class ElaCalendarPrivate;
+class ELA_EXPORT ElaCalendar : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaCalendar)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRaiuds)
+    Q_PROPERTY_CREATE_Q_H(QDate, SelectedDate)
+    Q_PROPERTY_CREATE_Q_H(QDate, MinimumDate)
+    Q_PROPERTY_CREATE_Q_H(QDate, MaximumDate)
+public:
+    explicit ElaCalendar(QWidget* parent = nullptr);
+    ~ElaCalendar() override;
+Q_SIGNALS:
+    Q_SIGNAL void clicked(QDate date);
+
+protected:
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELACALENDAR_H
@@ -0,0 +1,25 @@
+#ifndef ELACALENDARPICKER_H
+#define ELACALENDARPICKER_H
+
+#include "ElaProperty.h"
+#include <QDate>
+#include <QPushButton>
+class ElaCalendarPickerPrivate;
+class ELA_EXPORT ElaCalendarPicker : public QPushButton
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaCalendarPicker)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+    Q_PRIVATE_CREATE_Q_H(QDate, SelectedDate)
+public:
+    explicit ElaCalendarPicker(QWidget* parent = nullptr);
+    ~ElaCalendarPicker() override;
+
+Q_SIGNALS:
+    Q_SIGNAL void selectedDateChanged(QDate date);
+
+protected:
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELACALENDARPICKER_H
@@ -0,0 +1,17 @@
+#ifndef ELACHECKBOX_H
+#define ELACHECKBOX_H
+
+#include <QCheckBox>
+
+#include "ElaProperty.h"
+class ELA_EXPORT ElaCheckBox : public QCheckBox
+{
+    Q_OBJECT
+    Q_PROPERTY_CREATE(int, BorderRadius)
+public:
+    explicit ElaCheckBox(QWidget* parent = nullptr);
+    explicit ElaCheckBox(const QString& text, QWidget* parent = nullptr);
+    ~ElaCheckBox() override;
+};
+
+#endif // ELACHECKBOX_H
@@ -0,0 +1,29 @@
+#ifndef ELACOLORDIALOG_H
+#define ELACOLORDIALOG_H
+
+#include <QDialog>
+
+#include "ElaAppBar.h"
+#include "ElaProperty.h"
+class ElaColorDialogPrivate;
+class ELA_EXPORT ElaColorDialog : public QDialog
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaColorDialog)
+    Q_PROPERTY_CREATE_Q_H(QColor, CurrentColor)
+    Q_TAKEOVER_NATIVEEVENT_H
+public:
+    explicit ElaColorDialog(QWidget* parent = nullptr);
+    ~ElaColorDialog() override;
+
+    QList<QColor> getCustomColorList() const;
+    QColor getCustomColor(int index) const;
+    QString getCurrentColorRGB() const;
+Q_SIGNALS:
+    Q_SIGNAL void colorSelected(const QColor& color);
+
+protected:
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELACOLORDIALOG_H
@@ -0,0 +1,26 @@
+#ifndef ELACOMBOBOX_H
+#define ELACOMBOBOX_H
+
+#include <QComboBox>
+
+#include "ElaProperty.h"
+
+class ElaComboBoxPrivate;
+class ELA_EXPORT ElaComboBox : public QComboBox
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaComboBox);
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+public:
+    explicit ElaComboBox(QWidget* parent = nullptr);
+    ~ElaComboBox() override;
+
+    void setEditable(bool editable);
+
+protected:
+    virtual void showPopup() override;
+    virtual void hidePopup() override;
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELACOMBOBOX_H
@@ -0,0 +1,38 @@
+#ifndef ELACONTENTDIALOG_H
+#define ELACONTENTDIALOG_H
+#include <QAbstractNativeEventFilter>
+#include <QDialog>
+
+#include "ElaAppBar.h"
+#include "ElaProperty.h"
+class ElaContentDialogPrivate;
+class ELA_EXPORT ElaContentDialog : public QDialog
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaContentDialog)
+    Q_TAKEOVER_NATIVEEVENT_H
+public:
+    explicit ElaContentDialog(QWidget* parent);
+    ~ElaContentDialog() override;
+    Q_SLOT virtual void onLeftButtonClicked();
+    Q_SLOT virtual void onMiddleButtonClicked();
+    Q_SLOT virtual void onRightButtonClicked();
+    void setCentralWidget(QWidget* centralWidget);
+
+    void setLeftButtonText(QString text);
+    void setMiddleButtonText(QString text);
+    void setRightButtonText(QString text);
+
+    void close();
+Q_SIGNALS:
+    Q_SIGNAL void leftButtonClicked();
+    Q_SIGNAL void middleButtonClicked();
+    Q_SIGNAL void rightButtonClicked();
+
+protected:
+    virtual void showEvent(QShowEvent* event) override;
+    virtual void paintEvent(QPaintEvent* event) override;
+    virtual void keyPressEvent(QKeyEvent* event) override;
+};
+
+#endif // ELACONTENTDIALOG_H
@@ -0,0 +1,37 @@
+#ifndef ELAFRAMEWORK_ELADIALOG_H
+#define ELAFRAMEWORK_ELADIALOG_H
+
+#include "ElaAppBar.h"
+#include "ElaDef.h"
+#include <QDialog>
+
+class ElaDialogPrivate;
+class ELA_EXPORT ElaDialog : public QDialog
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaDialog)
+    Q_PROPERTY_CREATE_Q_H(bool, IsStayTop)
+    Q_PROPERTY_CREATE_Q_H(bool, IsFixedSize)
+    Q_PROPERTY_CREATE_Q_H(bool, IsDefaultClosed)
+    Q_PROPERTY_CREATE_Q_H(int, AppBarHeight)
+    Q_TAKEOVER_NATIVEEVENT_H
+public:
+    explicit ElaDialog(QWidget* parent = nullptr);
+    ~ElaDialog() override;
+    void moveToCenter();
+
+    void setWindowButtonFlag(ElaAppBarType::ButtonType buttonFlag, bool isEnable = true);
+    void setWindowButtonFlags(ElaAppBarType::ButtonFlags buttonFlags);
+    ElaAppBarType::ButtonFlags getWindowButtonFlags() const;
+
+Q_SIGNALS:
+    Q_SIGNAL void routeBackButtonClicked();
+    Q_SIGNAL void navigationButtonClicked();
+    Q_SIGNAL void themeChangeButtonClicked();
+    Q_SIGNAL void closeButtonClicked();
+
+protected:
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif //ELAFRAMEWORK_ELADIALOG_H
@@ -0,0 +1,29 @@
+#ifndef ELADOCKWIDGET_H
+#define ELADOCKWIDGET_H
+
+#include <QDockWidget>
+
+#include "ElaProperty.h"
+class ElaDockWidgetPrivate;
+class ELA_EXPORT ElaDockWidget : public QDockWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaDockWidget)
+public:
+    explicit ElaDockWidget(QWidget* parent = nullptr, Qt::WindowFlags flags = Qt::WindowFlags());
+    explicit ElaDockWidget(const QString& title, QWidget* parent = nullptr, Qt::WindowFlags flags = Qt::WindowFlags());
+    ~ElaDockWidget() override;
+
+protected:
+    virtual void paintEvent(QPaintEvent* event) override;
+#ifdef Q_OS_WIN
+    virtual bool event(QEvent* event) override;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    virtual bool nativeEvent(const QByteArray& eventType, void* message, qintptr* result) override;
+#else
+    virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result) override;
+#endif
+#endif
+};
+
+#endif // ELADOCKWIDGET_H
@@ -0,0 +1,25 @@
+#ifndef ELADOUBLESPINBOX_H
+#define ELADOUBLESPINBOX_H
+
+#include <QDoubleSpinBox>
+
+#include "ElaDef.h"
+
+class ElaDoubleSpinBoxPrivate;
+class ELA_EXPORT ElaDoubleSpinBox : public QDoubleSpinBox
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaDoubleSpinBox)
+    Q_PROPERTY_CREATE_Q_H(ElaSpinBoxType::ButtonMode, ButtonMode)
+public:
+    explicit ElaDoubleSpinBox(QWidget* parent = nullptr);
+    ~ElaDoubleSpinBox() override;
+
+protected:
+    void focusInEvent(QFocusEvent* event) override;
+    void focusOutEvent(QFocusEvent* event) override;
+    void paintEvent(QPaintEvent* event) override;
+    void contextMenuEvent(QContextMenuEvent* event) override;
+};
+
+#endif // ELADOUBLESPINBOX_H
@@ -0,0 +1,31 @@
+#ifndef ELAFRAMEWORK_ELAWIDGETTOOLS_INCLUDE_ELADRAWERAREA_H_
+#define ELAFRAMEWORK_ELAWIDGETTOOLS_INCLUDE_ELADRAWERAREA_H_
+
+#include "ElaProperty.h"
+#include <QWidget>
+
+class ElaDrawerAreaPrivate;
+class ELA_EXPORT ElaDrawerArea : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaDrawerArea)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+    Q_PROPERTY_CREATE_Q_H(int, HeaderHeight)
+public:
+    explicit ElaDrawerArea(QWidget* parent = nullptr);
+    ~ElaDrawerArea() override;
+
+    void setDrawerHeader(QWidget* widget);
+
+    void addDrawer(QWidget* widget);
+    void removeDrawer(QWidget* widget);
+
+    void expand();
+    void collapse();
+
+    bool getIsExpand() const;
+Q_SIGNALS:
+    Q_SIGNAL void expandStateChanged(bool isExpand);
+};
+
+#endif //ELAFRAMEWORK_ELAWIDGETTOOLS_INCLUDE_ELADRAWERAREA_H_
@@ -0,0 +1,58 @@
+#ifndef ELADXGIMANAGER_H
+#define ELADXGIMANAGER_H
+
+#include <QWidget>
+#ifdef Q_OS_WIN
+#include "ElaProperty.h"
+#include "ElaSingleton.h"
+
+class ElaDxgiManagerPrivate;
+class ELA_EXPORT ElaDxgiManager : public QObject
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaDxgiManager)
+    Q_SINGLETON_CREATE_H(ElaDxgiManager);
+
+private:
+    explicit ElaDxgiManager(QObject* parent = nullptr);
+    ~ElaDxgiManager() override;
+
+public:
+    QStringList getDxDeviceList() const;
+    QStringList getOutputDeviceList() const;
+    QImage grabScreenToImage() const;
+    void startGrabScreen();
+    void stopGrabScreen();
+    bool getIsGrabScreen() const;
+    bool setDxDeviceID(int dxID);
+    int getDxDeviceID() const;
+    bool setOutputDeviceID(int deviceID);
+    int getOutputDeviceID() const;
+    void setGrabArea(int width, int height); //从屏幕中心向外延伸
+    void setGrabArea(int x, int y, int width, int height);
+    QRect getGrabArea() const;
+    void setGrabFrameRate(int frameRateValue);
+    int getGrabFrameRate() const;
+    void setTimeoutMsValue(int timeoutValue);
+    int getTimeoutMsValue() const;
+Q_SIGNALS:
+    Q_SIGNAL void grabImageUpdate(QImage img);
+};
+
+class ElaDxgiScreenPrivate;
+class ELA_EXPORT ElaDxgiScreen : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaDxgiScreen)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+public:
+    explicit ElaDxgiScreen(QWidget* parent = nullptr);
+    ~ElaDxgiScreen();
+    void setIsSyncGrabSize(bool isSyncGrabSize);
+    bool getIsSyncGrabSize() const;
+
+protected:
+    void paintEvent(QPaintEvent* event) override;
+};
+#endif
+#endif // ELADXGIMANAGER_H
@@ -0,0 +1,45 @@
+#ifndef ELAEVENTBUS_H
+#define ELAEVENTBUS_H
+
+#include <QObject>
+#include <QVariantMap>
+
+#include "ElaDef.h"
+#include "ElaProperty.h"
+#include "ElaSingleton.h"
+class ElaEventPrivate;
+class ELA_EXPORT ElaEvent : public QObject
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaEvent)
+    Q_PROPERTY_CREATE_Q_H(QString, EventName);
+    Q_PROPERTY_CREATE_Q_H(QString, FunctionName);
+    Q_PROPERTY_CREATE_Q_H(Qt::ConnectionType, ConnectionType);
+
+public:
+    explicit ElaEvent(QObject* parent = nullptr);
+    explicit ElaEvent(QString eventName, QString functionName, QObject* parent = nullptr);
+    ~ElaEvent() override;
+    ElaEventBusType::EventBusReturnType registerAndInit();
+};
+
+class ElaEventBusPrivate;
+class ELA_EXPORT ElaEventBus : public QObject
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaEventBus)
+    Q_SINGLETON_CREATE_H(ElaEventBus);
+
+private:
+    explicit ElaEventBus(QObject* parent = nullptr);
+    ~ElaEventBus() override;
+
+public:
+    ElaEventBusType::EventBusReturnType post(const QString& eventName, const QVariantMap& data = {});
+    QStringList getRegisteredEventsName() const;
+
+private:
+    friend class ElaEvent;
+};
+
+#endif // ELAEVENTBUS_H
@@ -0,0 +1,23 @@
+#ifndef ELAEXPONENTIALBLUR_H
+#define ELAEXPONENTIALBLUR_H
+
+#include <QObject>
+
+#include "ElaProperty.h"
+#include "ElaSingleton.h"
+
+class ElaExponentialBlurPrivate;
+class ELA_EXPORT ElaExponentialBlur : public QObject
+{
+    Q_OBJECT
+    Q_SINGLETON_CREATE_H(ElaExponentialBlur)
+    Q_Q_CREATE(ElaExponentialBlur)
+private:
+    explicit ElaExponentialBlur(QObject* parent = nullptr);
+    ~ElaExponentialBlur();
+
+public:
+    static QPixmap doExponentialBlur(QImage img, const quint16& blurRadius);
+};
+
+#endif // ELAEXPONENTIALBLUR_H
@@ -0,0 +1,35 @@
+#ifndef ELAFLOWLAYOUT_H
+#define ELAFLOWLAYOUT_H
+
+#include <QLayout>
+#include <QMap>
+#include <QStyle>
+
+#include "ElaProperty.h"
+class ElaFlowLayoutPrivate;
+class ELA_EXPORT ElaFlowLayout : public QLayout
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaFlowLayout)
+public:
+    explicit ElaFlowLayout(QWidget* parent, int margin = -1, int hSpacing = -1, int vSpacing = -1);
+    explicit ElaFlowLayout(int margin = -1, int hSpacing = -1, int vSpacing = -1);
+    ~ElaFlowLayout() override;
+
+    void addItem(QLayoutItem* item) override;
+    int horizontalSpacing() const;
+    int verticalSpacing() const;
+    Qt::Orientations expandingDirections() const override;
+    bool hasHeightForWidth() const override;
+    int heightForWidth(int) const override;
+    int count() const override;
+    QLayoutItem* itemAt(int index) const override;
+    QSize minimumSize() const override;
+    void setGeometry(const QRect& rect) override;
+    QSize sizeHint() const override;
+    QLayoutItem* takeAt(int index) override;
+
+    void setIsAnimation(bool isAnimation);
+};
+
+#endif // ELAFLOWLAYOUT_H
@@ -0,0 +1,48 @@
+#ifndef ELAGRAPHICSITEM_H
+#define ELAGRAPHICSITEM_H
+
+#include <QGraphicsObject>
+#include <QJsonObject>
+#include <QObject>
+#include <QPainter>
+
+#include "ElaProperty.h"
+class ElaGraphicsScene;
+class ElaGraphicsItemPrivate;
+class ELA_EXPORT ElaGraphicsItem : public QGraphicsObject
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaGraphicsItem)
+    Q_PROPERTY_CREATE_Q_H(int, Width)
+    Q_PROPERTY_CREATE_Q_H(int, Height)
+    Q_PROPERTY_CREATE_Q_H(QImage, ItemImage)
+    Q_PROPERTY_CREATE_Q_H(QImage, ItemSelectedImage)
+    Q_PROPERTY_CREATE_Q_H(QString, ItemName)
+    Q_PROPERTY_CREATE_Q_H(QVariantMap, DataRoutes)
+    Q_PROPERTY_CREATE_Q_H(int, MaxLinkPortCount)
+public:
+    explicit ElaGraphicsItem(QGraphicsItem* parent = nullptr);
+    explicit ElaGraphicsItem(int width, int height, QGraphicsItem* parent = nullptr);
+    ~ElaGraphicsItem();
+
+    QString getItemUID() const;
+
+    void setLinkPortState(bool isFullLink);
+    void setLinkPortState(bool isLink, int portIndex);
+
+    bool getLinkPortState(int portIndex) const;
+    QVector<bool> getLinkPortState() const;
+
+    int getUsedLinkPortCount() const;
+    QVector<int> getUsedLinkPort() const;
+    int getUnusedLinkPortCount() const;
+    QVector<int> getUnusedLinkPort() const;
+
+protected:
+    virtual QRectF boundingRect() const override;
+    virtual void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = nullptr) override;
+    friend QDataStream& operator<<(QDataStream& stream, const ElaGraphicsItem* item);
+    friend QDataStream& operator>>(QDataStream& stream, ElaGraphicsItem* item);
+};
+
+#endif // ELAGRAPHICSITEM_H
@@ -0,0 +1,33 @@
+#ifndef ELAGRAPHICSLINEITEM_H
+#define ELAGRAPHICSLINEITEM_H
+
+#include <QGraphicsPathItem>
+
+#include "ElaProperty.h"
+class ElaGraphicsItem;
+class ElaGraphicsLineItemPrivate;
+class ELA_EXPORT ElaGraphicsLineItem : public QGraphicsPathItem
+{
+    Q_Q_CREATE(ElaGraphicsLineItem)
+    Q_PRIVATE_CREATE_Q_H(QPointF, StartPoint);
+    Q_PRIVATE_CREATE_Q_H(QPointF, EndPoint);
+    Q_PRIVATE_CREATE_Q_H(ElaGraphicsItem*, StartItem);
+    Q_PRIVATE_CREATE_Q_H(ElaGraphicsItem*, EndItem);
+    Q_PRIVATE_CREATE_Q_H(int, StartItemPort);
+    Q_PRIVATE_CREATE_Q_H(int, EndItemPort);
+
+public:
+    explicit ElaGraphicsLineItem(ElaGraphicsItem* startItem, ElaGraphicsItem* endItem, int startItemPort, int endItemPort, QGraphicsItem* parent = nullptr);
+    explicit ElaGraphicsLineItem(QPointF startPoint, QPointF endPoint, QGraphicsItem* parent = nullptr);
+    ~ElaGraphicsLineItem();
+
+    bool isTargetLink(ElaGraphicsItem* item) const;
+    bool isTargetLink(ElaGraphicsItem* item1, ElaGraphicsItem* item2) const;
+    bool isTargetLink(ElaGraphicsItem* item1, ElaGraphicsItem* item2, int port1, int port2) const;
+
+protected:
+    void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = nullptr) override;
+    QRectF boundingRect() const override;
+};
+
+#endif // ELAGRAPHICSLINEITEM_H
@@ -0,0 +1,70 @@
+#ifndef ELAGRAPHICSSCENE_H
+#define ELAGRAPHICSSCENE_H
+
+#include <QDataStream>
+#include <QEvent>
+#include <QGraphicsScene>
+#include <QJsonObject>
+#include <QObject>
+#include <QPainter>
+
+#include "ElaDef.h"
+#include "ElaProperty.h"
+
+class ElaGraphicsItem;
+class ElaGraphicsScenePrivate;
+class ELA_EXPORT ElaGraphicsScene : public QGraphicsScene
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaGraphicsScene)
+    Q_PROPERTY_CREATE_Q_H(bool, IsCheckLinkPort)
+    Q_PROPERTY_CREATE_Q_H(QString, SerializePath)
+public:
+    explicit ElaGraphicsScene(QObject* parent = nullptr);
+    ~ElaGraphicsScene();
+    void addItem(ElaGraphicsItem* item);
+    void removeItem(ElaGraphicsItem* item);
+    void removeSelectedItems();
+    void clear();
+
+    QList<ElaGraphicsItem*> createAndAddItem(int width, int height, int count = 1);
+    QList<ElaGraphicsItem*> getSelectedElaItems() const;
+    QList<ElaGraphicsItem*> getElaItems();
+    QList<ElaGraphicsItem*> getElaItems(QPoint pos);
+    QList<ElaGraphicsItem*> getElaItems(QPointF pos);
+    QList<ElaGraphicsItem*> getElaItems(QRect rect);
+    QList<ElaGraphicsItem*> getElaItems(QRectF rect);
+
+    void setSceneMode(ElaGraphicsSceneType::SceneMode mode);
+    ElaGraphicsSceneType::SceneMode getSceneMode() const;
+
+    void selectAllItems();
+
+    QList<QVariantMap> getItemLinkList() const;
+    bool addItemLink(ElaGraphicsItem* item1, ElaGraphicsItem* item2, int port1 = 0, int port2 = 0);
+    bool removeItemLink(ElaGraphicsItem* item1);
+    bool removeItemLink(ElaGraphicsItem* item1, ElaGraphicsItem* item2, int port1 = 0, int port2 = 0);
+
+    QVector<QVariantMap> getItemsDataRoute() const;
+
+    // 序列化 反序列化
+    void serialize();
+    void deserialize();
+
+Q_SIGNALS:
+    void showItemLink();
+    void mouseLeftClickedItem(ElaGraphicsItem* item);
+    void mouseRightClickedItem(ElaGraphicsItem* item);
+    void mouseDoubleClickedItem(ElaGraphicsItem* item);
+
+protected:
+    virtual void focusOutEvent(QFocusEvent* event) override;
+    virtual void keyPressEvent(QKeyEvent* event) override;
+    virtual void keyReleaseEvent(QKeyEvent* event) override;
+    virtual void mousePressEvent(QGraphicsSceneMouseEvent* event) override;
+    virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent* event) override;
+    virtual void mouseMoveEvent(QGraphicsSceneMouseEvent* event) override;
+    virtual void mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event) override;
+};
+
+#endif // ELAGRAPHICSSCENE_H
@@ -0,0 +1,26 @@
+#ifndef ELAGRAPHICSVIEW_H
+#define ELAGRAPHICSVIEW_H
+
+#include <QGraphicsView>
+
+#include "ElaProperty.h"
+class ElaGraphicsViewPrivate;
+class ELA_EXPORT ElaGraphicsView : public QGraphicsView
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaGraphicsView)
+    Q_PROPERTY_CREATE_Q_H(qreal, MaxTransform);
+    Q_PROPERTY_CREATE_Q_H(qreal, MinTransform);
+
+public:
+    explicit ElaGraphicsView(QWidget* parent = nullptr);
+    explicit ElaGraphicsView(QGraphicsScene* scene, QWidget* parent = nullptr);
+    ~ElaGraphicsView();
+
+protected:
+    void wheelEvent(QWheelEvent* event) override;
+    void keyPressEvent(QKeyEvent* event) override;
+    void keyReleaseEvent(QKeyEvent* event) override;
+};
+
+#endif // ELAGRAPHICSVIEW_H
@@ -0,0 +1,24 @@
+#ifndef ELAICON_H
+#define ELAICON_H
+#include <QIcon>
+
+#include "ElaDef.h"
+#include "ElaProperty.h"
+#include "ElaSingleton.h"
+class ELA_EXPORT ElaIcon
+{
+    Q_SINGLETON_CREATE_H(ElaIcon)
+private:
+    explicit ElaIcon();
+    ~ElaIcon();
+
+public:
+    QIcon getElaIcon(ElaIconType::IconName awesome);
+    QIcon getElaIcon(ElaIconType::IconName awesome, QColor iconColor);
+    QIcon getElaIcon(ElaIconType::IconName awesome, int pixelSize);
+    QIcon getElaIcon(ElaIconType::IconName awesome, int pixelSize, QColor iconColor);
+    QIcon getElaIcon(ElaIconType::IconName awesome, int pixelSize, int fixedWidth, int fixedHeight);
+    QIcon getElaIcon(ElaIconType::IconName awesome, int pixelSize, int fixedWidth, int fixedHeight, QColor iconColor);
+};
+
+#endif // ELAICON_H
@@ -0,0 +1,39 @@
+#ifndef ELAICONBUTTON_H
+#define ELAICONBUTTON_H
+
+#include <QPushButton>
+
+#include "ElaDef.h"
+#include "ElaProperty.h"
+class ElaIconButtonPrivate;
+class ELA_EXPORT ElaIconButton : public QPushButton
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaIconButton)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+    Q_PROPERTY_CREATE_Q_H(qreal, Opacity);
+    Q_PROPERTY_CREATE_Q_H(QColor, LightHoverColor);
+    Q_PROPERTY_CREATE_Q_H(QColor, DarkHoverColor);
+    Q_PROPERTY_CREATE_Q_H(QColor, LightIconColor);
+    Q_PROPERTY_CREATE_Q_H(QColor, DarkIconColor);
+    Q_PROPERTY_CREATE_Q_H(QColor, LightHoverIconColor);
+    Q_PROPERTY_CREATE_Q_H(QColor, DarkHoverIconColor);
+    Q_PROPERTY_CREATE_Q_H(bool, IsSelected);
+
+public:
+    ElaIconButton(QPixmap pix, QWidget* parent = nullptr);
+    ElaIconButton(ElaIconType::IconName awesome, QWidget* parent = nullptr);
+    ElaIconButton(ElaIconType::IconName awesome, int pixelSize, QWidget* parent = nullptr);
+    ElaIconButton(ElaIconType::IconName awesome, int pixelSize, int fixedWidth, int fixedHeight, QWidget* parent = nullptr);
+    ~ElaIconButton();
+    void setAwesome(ElaIconType::IconName awesome);
+    ElaIconType::IconName getAwesome() const;
+
+    void setPixmap(QPixmap pix);
+
+protected:
+    virtual bool event(QEvent* event) override;
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELAICONBUTTON_H
@@ -0,0 +1,24 @@
+#ifndef ELAIMAGECARD_H
+#define ELAIMAGECARD_H
+
+#include <QWidget>
+
+#include "ElaProperty.h"
+
+class ElaImageCardPrivate;
+class ELA_EXPORT ElaImageCard : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaImageCard)
+    Q_PROPERTY_CREATE_Q_H(QImage, CardImage);
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+    Q_PROPERTY_CREATE_Q_H(bool, IsPreserveAspectCrop)
+public:
+    explicit ElaImageCard(QWidget* parent = nullptr);
+    ~ElaImageCard() override;
+
+protected:
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELAIMAGECARD_H
@@ -0,0 +1,35 @@
+#ifndef ELAINTERACTIVECARD_H
+#define ELAINTERACTIVECARD_H
+
+#include <QPixmap>
+#include <QPushButton>
+
+#include "ElaDef.h"
+#include "ElaProperty.h"
+
+class ElaInteractiveCardPrivate;
+class ELA_EXPORT ElaInteractiveCard : public QPushButton
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaInteractiveCard)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+    Q_PROPERTY_CREATE_Q_H(QString, Title);
+    Q_PROPERTY_CREATE_Q_H(QString, SubTitle);
+    Q_PROPERTY_CREATE_Q_H(int, TitlePixelSize);
+    Q_PROPERTY_CREATE_Q_H(int, SubTitlePixelSize);
+    Q_PROPERTY_CREATE_Q_H(int, TitleSpacing);
+    Q_PROPERTY_CREATE_Q_H(QPixmap, CardPixmap);
+    Q_PROPERTY_CREATE_Q_H(QSize, CardPixmapSize);
+    Q_PROPERTY_CREATE_Q_H(int, CardPixmapBorderRadius)
+    Q_PROPERTY_CREATE_Q_H(ElaCardPixType::PixMode, CardPixMode);
+
+public:
+    explicit ElaInteractiveCard(QWidget* parent = nullptr);
+    ~ElaInteractiveCard();
+    void setCardPixmapSize(int width, int height);
+
+protected:
+    void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELAINTERACTIVECARD_H
@@ -0,0 +1,29 @@
+#ifndef ELAWIDGETTOOLS_SRC_ELAKEYBINDER_H_
+#define ELAWIDGETTOOLS_SRC_ELAKEYBINDER_H_
+
+#include "ElaDef.h"
+#include <QLabel>
+
+class ElaKeyBinderPrivate;
+class ELA_EXPORT ElaKeyBinder : public QLabel
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaKeyBinder)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+    Q_PROPERTY_CREATE_Q_H(QString, BinderKeyText)
+    Q_PROPERTY_CREATE_Q_H(quint32, NativeVirtualBinderKey)
+public:
+    explicit ElaKeyBinder(QWidget* parent = nullptr);
+    ~ElaKeyBinder();
+
+Q_SIGNALS:
+    Q_SIGNAL void binderKeyTextChanged(QString binderKeyText);
+    Q_SIGNAL void nativeVirtualBinderKeyChanged(quint32 binderKey);
+
+protected:
+    virtual bool event(QEvent* event) override;
+    virtual void mouseReleaseEvent(QMouseEvent* event) override;
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif //ELAWIDGETTOOLS_SRC_ELAKEYBINDER_H_
@@ -0,0 +1,26 @@
+#ifndef ELAWIDGETTOOLS_ELALCDNUMBER_H
+#define ELAWIDGETTOOLS_ELALCDNUMBER_H
+
+#include <QLCDNumber>
+
+#include "ElaProperty.h"
+
+class ElaLCDNumberPrivate;
+class ELA_EXPORT ElaLCDNumber : public QLCDNumber
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaLCDNumber)
+    Q_PROPERTY_CREATE_Q_H(bool, IsUseAutoClock)
+    Q_PROPERTY_CREATE_Q_H(QString, AutoClockFormat)
+    Q_PROPERTY_CREATE_Q_H(bool, IsTransparent)
+
+public:
+    explicit ElaLCDNumber(QWidget* parent = nullptr);
+    explicit ElaLCDNumber(uint numDigits, QWidget* parent = nullptr);
+    ~ElaLCDNumber() override;
+
+protected:
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif //ELAWIDGETTOOLS_ELALCDNUMBER_H
@@ -0,0 +1,31 @@
+#ifndef ELALINEEDIT_H
+#define ELALINEEDIT_H
+
+#include <QLineEdit>
+
+#include "ElaProperty.h"
+
+class ElaLineEditPrivate;
+class ELA_EXPORT ElaLineEdit : public QLineEdit
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaLineEdit)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+    Q_PROPERTY_CREATE_Q_H(bool, IsClearButtonEnable)
+public:
+    explicit ElaLineEdit(QWidget* parent = nullptr);
+    ~ElaLineEdit() override;
+
+Q_SIGNALS:
+    Q_SIGNAL void focusIn(QString text);
+    Q_SIGNAL void focusOut(QString text);
+    Q_SIGNAL void wmFocusOut(QString text);
+
+protected:
+    void focusInEvent(QFocusEvent* event) override;
+    void focusOutEvent(QFocusEvent* event) override;
+    void paintEvent(QPaintEvent* event) override;
+    void contextMenuEvent(QContextMenuEvent* event) override;
+};
+
+#endif // ELALINEEDIT_H
@@ -0,0 +1,20 @@
+#ifndef ELALISTVIEW_H
+#define ELALISTVIEW_H
+
+#include <QListView>
+
+#include "ElaProperty.h"
+
+class ElaListViewPrivate;
+class ELA_EXPORT ElaListView : public QListView
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaListView)
+    Q_PROPERTY_CREATE_Q_H(int, ItemHeight)
+    Q_PROPERTY_CREATE_Q_H(bool, IsTransparent)
+public:
+    explicit ElaListView(QWidget* parent = nullptr);
+    ~ElaListView();
+};
+
+#endif // ELALISTVIEW_H
@@ -0,0 +1,29 @@
+#ifndef ELALOG_H
+#define ELALOG_H
+
+#include <QObject>
+
+#include "ElaProperty.h"
+#include "ElaSingleton.h"
+
+class ElaLogPrivate;
+class ELA_EXPORT ElaLog : public QObject
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaLog)
+    Q_PROPERTY_CREATE_Q_H(QString, LogSavePath)
+    Q_PROPERTY_CREATE_Q_H(QString, LogFileName)
+    Q_PROPERTY_CREATE_Q_H(bool, IsLogFileNameWithTime)
+    Q_SINGLETON_CREATE_H(ElaLog);
+
+private:
+    explicit ElaLog(QObject* parent = nullptr);
+    ~ElaLog();
+
+public:
+    void initMessageLog(bool isEnable);
+Q_SIGNALS:
+    void logMessage(QString log);
+};
+
+#endif // ELALOG_H
@@ -0,0 +1,40 @@
+#ifndef ELAMENU_H
+#define ELAMENU_H
+
+#include <QMenu>
+#include <QWidget>
+
+#include "ElaDef.h"
+#include "ElaProperty.h"
+class ElaMenuPrivate;
+class ELA_EXPORT ElaMenu : public QMenu
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaMenu)
+
+public:
+    explicit ElaMenu(QWidget* parent = nullptr);
+    explicit ElaMenu(const QString& title, QWidget* parent = nullptr);
+    ~ElaMenu();
+    void setMenuItemHeight(int menuItemHeight);
+    int getMenuItemHeight() const;
+
+    QAction* addMenu(QMenu* menu);
+    ElaMenu* addMenu(const QString& title);
+    ElaMenu* addMenu(const QIcon& icon, const QString& title);
+    ElaMenu* addMenu(ElaIconType::IconName icon, const QString& title);
+
+    QAction* addElaIconAction(ElaIconType::IconName icon, const QString& text);
+    QAction* addElaIconAction(ElaIconType::IconName icon, const QString& text, const QKeySequence& shortcut);
+
+    bool isHasChildMenu() const;
+    bool isHasIcon() const;
+Q_SIGNALS:
+    Q_SIGNAL void menuShow();
+
+protected:
+    virtual void showEvent(QShowEvent* event) override;
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELAMENU_H
@@ -0,0 +1,26 @@
+#ifndef ELAMENUBAR_H
+#define ELAMENUBAR_H
+
+#include <QMenuBar>
+
+#include "ElaDef.h"
+#include "ElaProperty.h"
+
+class ElaMenu;
+class ELA_EXPORT ElaMenuBar : public QMenuBar
+{
+    Q_OBJECT
+public:
+    explicit ElaMenuBar(QWidget* parent = nullptr);
+    ~ElaMenuBar();
+
+    QAction* addMenu(QMenu* menu);
+    ElaMenu* addMenu(const QString& title);
+    ElaMenu* addMenu(const QIcon& icon, const QString& title);
+    ElaMenu* addMenu(ElaIconType::IconName, const QString& title);
+
+    QAction* addElaIconAction(ElaIconType::IconName icon, const QString& text);
+    QAction* addElaIconAction(ElaIconType::IconName icon, const QString& text, const QKeySequence& shortcut);
+};
+
+#endif // ELAMENUBAR_H
@@ -0,0 +1,30 @@
+#ifndef ELAMESSAGEBAR_H
+#define ELAMESSAGEBAR_H
+
+#include <QWidget>
+
+#include "ElaDef.h"
+#include "ElaProperty.h"
+
+class ElaMessageBarPrivate;
+class ELA_EXPORT ElaMessageBar : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaMessageBar)
+
+public:
+    static void success(ElaMessageBarType::PositionPolicy policy, QString title, QString text, int displayMsec, QWidget* parent = nullptr);
+    static void warning(ElaMessageBarType::PositionPolicy policy, QString title, QString text, int displayMsec, QWidget* parent = nullptr);
+    static void information(ElaMessageBarType::PositionPolicy policy, QString title, QString text, int displayMsec, QWidget* parent = nullptr);
+    static void error(ElaMessageBarType::PositionPolicy policy, QString title, QString text, int displayMsec, QWidget* parent = nullptr);
+
+protected:
+    void paintEvent(QPaintEvent* event) override;
+    bool eventFilter(QObject* watched, QEvent* event) override;
+
+private:
+    explicit ElaMessageBar(ElaMessageBarType::PositionPolicy policy, ElaMessageBarType::MessageMode messageMode, QString& title, QString& text, int displayMsec, QWidget* parent = nullptr);
+    ~ElaMessageBar() override;
+};
+
+#endif // ELAMESSAGEBAR_H
@@ -0,0 +1,33 @@
+#ifndef ELAMESSAGEBUTTON_H
+#define ELAMESSAGEBUTTON_H
+
+#include <QPushButton>
+#include <QWidget>
+
+#include "ElaDef.h"
+#include "ElaProperty.h"
+class ElaMessageButtonPrivate;
+class ELA_EXPORT ElaMessageButton : public QPushButton
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaMessageButton)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+    Q_PROPERTY_CREATE_Q_H(QString, BarTitle);
+    Q_PROPERTY_CREATE_Q_H(QString, BarText);
+    Q_PROPERTY_CREATE_Q_H(int, DisplayMsec);
+    Q_PROPERTY_CREATE_Q_H(QWidget*, MessageTargetWidget)
+    Q_PROPERTY_CREATE_Q_H(ElaMessageBarType::MessageMode, MessageMode);
+    Q_PROPERTY_CREATE_Q_H(ElaMessageBarType::PositionPolicy, PositionPolicy);
+
+public:
+    explicit ElaMessageButton(QWidget* parent = nullptr);
+    explicit ElaMessageButton(QString text, QWidget* parent = nullptr);
+    ~ElaMessageButton();
+
+protected:
+    virtual void mousePressEvent(QMouseEvent* event) override;
+    virtual void mouseReleaseEvent(QMouseEvent* event) override;
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELAMESSAGEBUTTON_H
@@ -0,0 +1,31 @@
+#ifndef ELAMULTISELECTCOMBOBOX_H
+#define ELAMULTISELECTCOMBOBOX_H
+#include <QComboBox>
+
+#include "ElaProperty.h"
+class ElaMultiSelectComboBoxPrivate;
+class ELA_EXPORT ElaMultiSelectComboBox : public QComboBox
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaMultiSelectComboBox)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+public:
+    explicit ElaMultiSelectComboBox(QWidget* parent = nullptr);
+    ~ElaMultiSelectComboBox();
+    void setCurrentSelection(QString selection);
+    void setCurrentSelection(QStringList selection);
+    void setCurrentSelection(int index);
+    void setCurrentSelection(QList<int> selectionIndex);
+    QStringList getCurrentSelection() const;
+    QList<int> getCurrentSelectionIndex() const;
+Q_SIGNALS:
+    Q_SIGNAL void itemSelectionChanged(QVector<bool> itemSelection);
+    Q_SIGNAL void currentTextListChanged(QStringList selectedTextList);
+
+protected:
+    void paintEvent(QPaintEvent* e) override;
+    void showPopup() override;
+    void hidePopup() override;
+};
+
+#endif // ELAMULTISELECTCOMBOBOX_H
@@ -0,0 +1,66 @@
+#ifndef ELANAVIGATIONBAR_H
+#define ELANAVIGATIONBAR_H
+
+#include <QWidget>
+
+#include "ElaDef.h"
+#include "ElaProperty.h"
+#include "ElaSuggestBox.h"
+class ElaNavigationBarPrivate;
+class ELA_EXPORT ElaNavigationBar : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaNavigationBar)
+    Q_PROPERTY_CREATE_Q_H(bool, IsTransparent)
+    Q_PROPERTY_CREATE_Q_H(bool, IsAllowPageOpenInNewWindow)
+    Q_PROPERTY_CREATE_Q_H(int, NavigationBarWidth)
+public:
+    explicit ElaNavigationBar(QWidget* parent = nullptr);
+    ~ElaNavigationBar() override;
+    void setUserInfoCardVisible(bool isVisible);
+    void setUserInfoCardPixmap(QPixmap pix);
+    void setUserInfoCardTitle(QString title);
+    void setUserInfoCardSubTitle(QString subTitle);
+
+    ElaNavigationType::NodeResult addExpanderNode(const QString& expanderTitle, QString& expanderKey, ElaIconType::IconName awesome = ElaIconType::None);
+    ElaNavigationType::NodeResult addExpanderNode(const QString& expanderTitle, QString& expanderKey, const QString& targetExpanderKey, ElaIconType::IconName awesome = ElaIconType::None);
+    ElaNavigationType::NodeResult addPageNode(const QString& pageTitle, QWidget* page, ElaIconType::IconName awesome = ElaIconType::None);
+    ElaNavigationType::NodeResult addPageNode(const QString& pageTitle, QWidget* page, int keyPoints, ElaIconType::IconName awesome = ElaIconType::None);
+    ElaNavigationType::NodeResult addPageNode(const QString& pageTitle, QWidget* page, const QString& targetExpanderKey, ElaIconType::IconName awesome = ElaIconType::None);
+    ElaNavigationType::NodeResult addPageNode(const QString& pageTitle, QWidget* page, const QString& targetExpanderKey, int keyPoints, ElaIconType::IconName awesome = ElaIconType::None);
+    ElaNavigationType::NodeResult addFooterNode(const QString& footerTitle, QString& footerKey, int keyPoints = 0, ElaIconType::IconName awesome = ElaIconType::None);
+    ElaNavigationType::NodeResult addFooterNode(const QString& footerTitle, QWidget* page, QString& footerKey, int keyPoints = 0, ElaIconType::IconName awesome = ElaIconType::None);
+    ElaNavigationType::NodeResult addCategoryNode(const QString& categoryTitle, QString& categoryKey);
+    ElaNavigationType::NodeResult addCategoryNode(const QString& categoryTitle, QString& categoryKey, const QString& targetExpanderKey);
+
+    bool getNodeIsExpanded(QString expanderKey) const;
+    void expandNode(QString expanderKey);
+    void collapseNode(QString expanderKey);
+    void removeNode(QString nodeKey);
+
+    void setNodeKeyPoints(QString nodeKey, int keyPoints);
+    int getNodeKeyPoints(QString nodeKey) const;
+
+    void setNodeTitle(QString nodeKey, QString nodeTitle);
+    QString getNodeTitle(QString nodeKey) const;
+
+    void navigation(QString pageKey, bool isLogClicked = true, bool isRouteBack = false);
+    void setDisplayMode(ElaNavigationType::NavigationDisplayMode displayMode, bool isAnimation = true);
+    ElaNavigationType::NavigationDisplayMode getDisplayMode() const;
+
+    int getPageOpenInNewWindowCount(QString nodeKey) const;
+
+    QList<ElaSuggestBox::SuggestData> getSuggestDataList() const;
+
+Q_SIGNALS:
+    Q_SIGNAL void pageOpenInNewWindow(QString nodeKey);
+    Q_SIGNAL void userInfoCardClicked();
+    Q_SIGNAL void navigationNodeClicked(ElaNavigationType::NavigationNodeType nodeType, QString nodeKey, bool isRouteBack);
+    Q_SIGNAL void navigationNodeAdded(ElaNavigationType::NavigationNodeType nodeType, QString nodeKey, QWidget* page);
+    Q_SIGNAL void navigationNodeRemoved(ElaNavigationType::NavigationNodeType nodeType, QString nodeKey);
+
+protected:
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELANAVIGATIONBAR_H
@@ -0,0 +1,28 @@
+#ifndef ELAPIVOT_H
+#define ELAPIVOT_H
+#include <QWidget>
+
+#include "ElaProperty.h"
+
+class ElaPivotPrivate;
+class ELA_EXPORT ElaPivot : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaPivot)
+    Q_PROPERTY_CREATE_Q_H(int, TextPixelSize)
+    Q_PROPERTY_CREATE_Q_H(int, CurrentIndex)
+    Q_PROPERTY_CREATE_Q_H(int, PivotSpacing)
+    Q_PROPERTY_CREATE_Q_H(int, MarkWidth)
+public:
+    explicit ElaPivot(QWidget* parent = nullptr);
+    ~ElaPivot();
+
+    void appendPivot(QString pivotTitle);
+    void removePivot(QString pivotTitle);
+
+Q_SIGNALS:
+    Q_SIGNAL void pivotClicked(int index);
+    Q_SIGNAL void pivotDoubleClicked(int index);
+};
+
+#endif // ELAPIVOT_H
@@ -0,0 +1,25 @@
+#ifndef ELAPLAINTEXTEDIT_H
+#define ELAPLAINTEXTEDIT_H
+
+#include <QPlainTextEdit>
+
+#include "ElaProperty.h"
+
+class ElaPlainTextEditPrivate;
+class ELA_EXPORT ElaPlainTextEdit : public QPlainTextEdit
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaPlainTextEdit)
+public:
+    explicit ElaPlainTextEdit(QWidget* parent = nullptr);
+    explicit ElaPlainTextEdit(const QString& text, QWidget* parent = nullptr);
+    ~ElaPlainTextEdit() override;
+
+protected:
+    virtual void focusInEvent(QFocusEvent* event) override;
+    virtual void focusOutEvent(QFocusEvent* event) override;
+    virtual void contextMenuEvent(QContextMenuEvent* event) override;
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELAPLAINTEXTEDIT_H
@@ -0,0 +1,34 @@
+#ifndef ELAPOPULARCARD_H
+#define ELAPOPULARCARD_H
+
+#include <QPixmap>
+#include <QWidget>
+
+#include "ElaProperty.h"
+class ElaPopularCardPrivate;
+class ELA_EXPORT ElaPopularCard : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaPopularCard)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+    Q_PROPERTY_CREATE_Q_H(QPixmap, CardPixmap)
+    Q_PROPERTY_CREATE_Q_H(QString, Title)
+    Q_PROPERTY_CREATE_Q_H(QString, SubTitle)
+    Q_PROPERTY_CREATE_Q_H(QString, InteractiveTips)
+    Q_PROPERTY_CREATE_Q_H(QString, DetailedText)
+    Q_PROPERTY_CREATE_Q_H(QString, CardButtonText)
+    Q_PROPERTY_CREATE_Q_H(QWidget*, CardFloatArea)
+    Q_PROPERTY_CREATE_Q_H(QPixmap, CardFloatPixmap)
+public:
+    explicit ElaPopularCard(QWidget* parent = nullptr);
+    ~ElaPopularCard() override;
+Q_SIGNALS:
+    Q_SIGNAL void popularCardClicked();
+    Q_SIGNAL void popularCardButtonClicked();
+
+protected:
+    virtual bool event(QEvent* event) override;
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELAPOPULARCARD_H
@@ -0,0 +1,24 @@
+#ifndef ELAPROGRESSBAR_H
+#define ELAPROGRESSBAR_H
+
+#include <QProgressBar>
+
+#include "ElaProperty.h"
+
+class ElaProgressBarPrivate;
+class ELA_EXPORT ElaProgressBar : public QProgressBar
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaProgressBar)
+public:
+    explicit ElaProgressBar(QWidget* parent = nullptr);
+    ~ElaProgressBar() override;
+    void setMinimum(int minimum);
+    void setMaximum(int maximum);
+
+protected:
+    virtual void paintEvent(QPaintEvent* event) override;
+    virtual void resizeEvent(QResizeEvent* event) override;
+};
+
+#endif // ELAPROGRESSBAR_H
@@ -0,0 +1,36 @@
+#ifndef ELAFRAMEWORK_ELAWIDGETTOOLS_INCLUDE_ELAPROGRESSRING_H_
+#define ELAFRAMEWORK_ELAWIDGETTOOLS_INCLUDE_ELAPROGRESSRING_H_
+
+#include "ElaDef.h"
+
+#include <QWidget>
+
+class ElaProgressRingPrivate;
+class ELA_EXPORT ElaProgressRing : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaProgressRing);
+    Q_PROPERTY_CREATE_Q_H(bool, IsBusying)
+    Q_PROPERTY_CREATE_Q_H(bool, IsTransparent)
+    Q_PROPERTY_CREATE_Q_H(bool, IsDisplayValue)
+    Q_PROPERTY_CREATE_Q_H(ElaProgressRingType::ValueDisplayMode, ValueDisplayMode)
+    Q_PROPERTY_CREATE_Q_H(int, BusyingWidth)
+    Q_PROPERTY_CREATE_Q_H(int, BusyingDurationTime)
+    Q_PROPERTY_CREATE_Q_H(int, Minimum)
+    Q_PROPERTY_CREATE_Q_H(int, Maximum)
+    Q_PROPERTY_CREATE_Q_H(int, Value)
+    Q_PROPERTY_CREATE_Q_H(int, ValuePixelSize)
+public:
+    explicit ElaProgressRing(QWidget* parent = nullptr);
+    ~ElaProgressRing() override;
+
+    void setRange(int min, int max);
+
+Q_SIGNALS:
+    Q_SIGNAL void rangeChanged(int min, int max);
+
+protected:
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif //ELAFRAMEWORK_ELAWIDGETTOOLS_INCLUDE_ELAPROGRESSRING_H_
@@ -0,0 +1,39 @@
+#ifndef ELAPROMOTIONCARD_H
+#define ELAPROMOTIONCARD_H
+#include <QWidget>
+
+#include "ElaProperty.h"
+class ElaPromotionCardPrivate;
+class ELA_EXPORT ElaPromotionCard : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaPromotionCard)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+    Q_PROPERTY_CREATE_Q_H(QPixmap, CardPixmap)
+    Q_PROPERTY_CREATE_Q_H(QString, CardTitle)
+    Q_PROPERTY_CREATE_Q_H(QString, PromotionTitle)
+    Q_PROPERTY_CREATE_Q_H(QString, Title)
+    Q_PROPERTY_CREATE_Q_H(QString, SubTitle)
+    Q_PROPERTY_CREATE_Q_H(QColor, CardTitleColor)
+    Q_PROPERTY_CREATE_Q_H(QColor, PromotionTitleColor)
+    Q_PROPERTY_CREATE_Q_H(QColor, PromotionTitleBaseColor)
+    Q_PROPERTY_CREATE_Q_H(QColor, TitleColor)
+    Q_PROPERTY_CREATE_Q_H(QColor, SubTitleColor)
+    Q_PROPERTY_CREATE_Q_H(int, CardTitlePixelSize)
+    Q_PROPERTY_CREATE_Q_H(int, PromotionTitlePixelSize)
+    Q_PROPERTY_CREATE_Q_H(int, TitlePixelSize)
+    Q_PROPERTY_CREATE_Q_H(int, SubTitlePixelSize)
+    Q_PROPERTY_CREATE_Q_H(qreal, HorizontalCardPixmapRatio)
+    Q_PROPERTY_CREATE_Q_H(qreal, VerticalCardPixmapRatio)
+public:
+    explicit ElaPromotionCard(QWidget* parent = nullptr);
+    ~ElaPromotionCard();
+Q_SIGNALS:
+    Q_SIGNAL void promotionCardClicked();
+
+protected:
+    virtual bool event(QEvent* event) override;
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELAPROMOTIONCARD_H
@@ -0,0 +1,30 @@
+#ifndef ELAPROMOTIONVIEW_H
+#define ELAPROMOTIONVIEW_H
+
+#include <QPixmap>
+#include <QWidget>
+
+#include "ElaProperty.h"
+class ElaPromotionCard;
+class ElaPromotionViewPrivate;
+class ELA_EXPORT ElaPromotionView : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaPromotionView)
+    Q_PROPERTY_CREATE_Q_H(int, CardExpandWidth)
+    Q_PROPERTY_CREATE_Q_H(int, CardCollapseWidth)
+    Q_PROPERTY_CREATE_Q_H(int, CurrentIndex)
+    Q_PROPERTY_CREATE_Q_H(bool, IsAutoScroll)
+    Q_PROPERTY_CREATE_Q_H(int, AutoScrollInterval)
+public:
+    explicit ElaPromotionView(QWidget* parent = nullptr);
+    ~ElaPromotionView();
+
+    void appendPromotionCard(ElaPromotionCard* card);
+
+protected:
+    virtual void wheelEvent(QWheelEvent* event) override;
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELAPROMOTIONVIEW_H
@@ -0,0 +1,168 @@
+#ifndef ELAFRAMEWORK_ELAWIDGETTOOLS_ELAPROPERTY_H_
+#define ELAFRAMEWORK_ELAWIDGETTOOLS_ELAPROPERTY_H_
+
+#include <QtCore/qglobal.h>
+
+#ifdef ELAWIDGETTOOLS_LIBRARY
+#define ELA_EXPORT Q_DECL_EXPORT
+#else
+#define ELA_EXPORT Q_DECL_IMPORT
+#endif
+
+#define Q_PROPERTY_CREATE(TYPE, M)                          \
+    Q_PROPERTY(TYPE p##M MEMBER _p##M NOTIFY p##M##Changed) \
+public:                                                     \
+    Q_SIGNAL void p##M##Changed();                          \
+    void set##M(TYPE M)                                     \
+    {                                                       \
+        _p##M = std::move(M);                               \
+        Q_EMIT p##M##Changed();                             \
+    }                                                       \
+    TYPE get##M() const                                     \
+    {                                                       \
+        return _p##M;                                       \
+    }                                                       \
+                                                            \
+private:                                                    \
+    TYPE _p##M;
+
+#define Q_PROPERTY_REF_CREATE(TYPE, M)                      \
+    Q_PROPERTY(TYPE p##M MEMBER _p##M NOTIFY p##M##Changed) \
+public:                                                     \
+    Q_SIGNAL void p##M##Changed();                          \
+    void set##M(const TYPE& M)                              \
+    {                                                       \
+        _p##M = M;                                          \
+        Q_EMIT p##M##Changed();                             \
+    }                                                       \
+    const TYPE& get##M() const                              \
+    {                                                       \
+        return _p##M;                                       \
+    }                                                       \
+                                                            \
+private:                                                    \
+    TYPE _p##M;
+
+#define Q_PROPERTY_CREATE_Q_H(TYPE, M)                                  \
+    Q_PROPERTY(TYPE p##M READ get##M WRITE set##M NOTIFY p##M##Changed) \
+public:                                                                 \
+    Q_SIGNAL void p##M##Changed();                                      \
+    void set##M(TYPE M);                                                \
+    TYPE get##M() const;
+
+#define Q_PROPERTY_REF_CREATE_Q_H(TYPE, M)                              \
+    Q_PROPERTY(TYPE p##M READ get##M WRITE set##M NOTIFY p##M##Changed) \
+public:                                                                 \
+    Q_SIGNAL void p##M##Changed();                                      \
+    void set##M(const TYPE& M);                                         \
+    const TYPE& get##M() const;
+
+#define Q_PRIVATE_CREATE_Q_H(TYPE, M) \
+public:                               \
+    void set##M(TYPE M);              \
+    TYPE get##M() const;
+
+#define Q_PRIVATE_REF_CREATE_Q_H(TYPE, M) \
+public:                                   \
+    void set##M(const TYPE& M);           \
+    const TYPE& get##M() const;
+
+#define Q_PROPERTY_CREATE_Q_CPP(CLASS, TYPE, M) \
+    void CLASS::set##M(TYPE M)                  \
+    {                                           \
+        Q_D(CLASS);                             \
+        d->_p##M = std::move(M);                \
+        Q_EMIT p##M##Changed();                 \
+    }                                           \
+    TYPE CLASS::get##M() const                  \
+    {                                           \
+        return d_ptr->_p##M;                    \
+    }
+
+#define Q_PROPERTY_REF_CREATE_Q_CPP(CLASS, TYPE, M) \
+    void CLASS::set##M(const TYPE& M)               \
+    {                                               \
+        Q_D(CLASS);                                 \
+        d->_p##M = M;                               \
+        Q_EMIT p##M##Changed();                     \
+    }                                               \
+    const TYPE& CLASS::get##M() const               \
+    {                                               \
+        return d_ptr->_p##M;                        \
+    }
+
+#define Q_PRIVATE_CREATE_Q_CPP(CLASS, TYPE, M) \
+    void CLASS::set##M(TYPE M)                 \
+    {                                          \
+        Q_D(CLASS);                            \
+        d->_p##M = std::move(M);               \
+    }                                          \
+    TYPE CLASS::get##M() const                 \
+    {                                          \
+        return d_ptr->_p##M;                   \
+    }
+
+#define Q_PRIVATE_REF_CREATE_Q_CPP(CLASS, TYPE, M) \
+    void CLASS::set##M(const TYPE& M)              \
+    {                                              \
+        Q_D(CLASS);                                \
+        d->_p##M = M;                              \
+    }                                              \
+    const TYPE& CLASS::get##M() const              \
+    {                                              \
+        return d_ptr->_p##M;                       \
+    }
+
+#define Q_PROPERTY_CREATE_D(TYPE, M) \
+private:                             \
+    TYPE _p##M;
+
+#define Q_PRIVATE_CREATE_D(TYPE, M) \
+private:                            \
+    TYPE _p##M;
+
+#define Q_PRIVATE_CREATE(TYPE, M) \
+public:                           \
+    void set##M(TYPE M)           \
+    {                             \
+        _p##M = std::move(M);     \
+    }                             \
+    TYPE get##M() const           \
+    {                             \
+        return _p##M;             \
+    }                             \
+                                  \
+private:                          \
+    TYPE _p##M;
+
+#define Q_PRIVATE_REF_CREATE(TYPE, M) \
+public:                               \
+    void set##M(const TYPE& M)        \
+    {                                 \
+        _p##M = M;                    \
+    }                                 \
+    const TYPE& get##M() const        \
+    {                                 \
+        return _p##M;                 \
+    }                                 \
+                                      \
+private:                              \
+    TYPE _p##M;
+
+#define Q_Q_CREATE(CLASS)                                        \
+protected:                                                       \
+    explicit CLASS(CLASS##Private& dd, CLASS* parent = nullptr); \
+    QScopedPointer<CLASS##Private> d_ptr;                        \
+                                                                 \
+private:                                                         \
+    Q_DISABLE_COPY(CLASS)                                        \
+    Q_DECLARE_PRIVATE(CLASS);
+
+#define Q_D_CREATE(CLASS) \
+protected:                \
+    CLASS* q_ptr;         \
+                          \
+private:                  \
+    Q_DECLARE_PUBLIC(CLASS);
+
+#endif // ELAFRAMEWORK_ELAWIDGETTOOLS_ELAPROPERTY_H_
@@ -0,0 +1,36 @@
+#ifndef ELAPUSHBUTTON_H
+#define ELAPUSHBUTTON_H
+
+#include <QPushButton>
+
+#include "ElaProperty.h"
+class ElaPushButtonPrivate;
+class ELA_EXPORT ElaPushButton : public QPushButton
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaPushButton)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+    Q_PROPERTY_CREATE_Q_H(QColor, LightDefaultColor)
+    Q_PROPERTY_CREATE_Q_H(QColor, DarkDefaultColor)
+    Q_PROPERTY_CREATE_Q_H(QColor, LightHoverColor)
+    Q_PROPERTY_CREATE_Q_H(QColor, DarkHoverColor)
+    Q_PROPERTY_CREATE_Q_H(QColor, LightPressColor)
+    Q_PROPERTY_CREATE_Q_H(QColor, DarkPressColor)
+public:
+    explicit ElaPushButton(QWidget* parent = nullptr);
+    explicit ElaPushButton(QString text, QWidget* parent = nullptr);
+    ~ElaPushButton();
+
+    void setLightTextColor(QColor color);
+    QColor getLightTextColor() const;
+
+    void setDarkTextColor(QColor color);
+    QColor getDarkTextColor() const;
+
+protected:
+    virtual void mousePressEvent(QMouseEvent* event) override;
+    virtual void mouseReleaseEvent(QMouseEvent* event) override;
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELAPUSHBUTTON_H
@@ -0,0 +1,21 @@
+#ifndef ELARADIOBUTTON_H
+#define ELARADIOBUTTON_H
+
+#include <QRadioButton>
+
+#include "ElaProperty.h"
+class ElaRadioButtonPrivate;
+class ELA_EXPORT ElaRadioButton : public QRadioButton
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaRadioButton)
+public:
+    explicit ElaRadioButton(QWidget* parent = nullptr);
+    explicit ElaRadioButton(const QString& text, QWidget* parent = nullptr);
+    ~ElaRadioButton() override;
+
+protected:
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELARADIOBUTTON_H
@@ -0,0 +1,32 @@
+#ifndef ELAREMINDERCARD_H
+#define ELAREMINDERCARD_H
+
+#include <QPushButton>
+
+#include "ElaDef.h"
+class ElaReminderCardPrivate;
+class ELA_EXPORT ElaReminderCard : public QPushButton
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaReminderCard)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+    Q_PROPERTY_CREATE_Q_H(QString, Title);
+    Q_PROPERTY_CREATE_Q_H(QString, SubTitle);
+    Q_PROPERTY_CREATE_Q_H(int, TitlePixelSize);
+    Q_PROPERTY_CREATE_Q_H(int, SubTitlePixelSize);
+    Q_PROPERTY_CREATE_Q_H(int, TitleSpacing);
+    Q_PROPERTY_CREATE_Q_H(QPixmap, CardPixmap);
+    Q_PROPERTY_CREATE_Q_H(QSize, CardPixmapSize);
+    Q_PROPERTY_CREATE_Q_H(int, CardPixmapBorderRadius)
+    Q_PROPERTY_CREATE_Q_H(ElaCardPixType::PixMode, CardPixMode);
+
+public:
+    explicit ElaReminderCard(QWidget* parent = nullptr);
+    ~ElaReminderCard();
+    void setCardPixmapSize(int width, int height);
+
+protected:
+    void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELAREMINDERCARD_H
@@ -0,0 +1,37 @@
+#ifndef ELAFRAMEWORK_ELAWIDGETTOOLS_INCLUDE_ELAROLLER_H_
+#define ELAFRAMEWORK_ELAWIDGETTOOLS_INCLUDE_ELAROLLER_H_
+
+#include "ElaProperty.h"
+#include <QWidget>
+
+class ElaRollerPrivate;
+class ELA_EXPORT ElaRoller : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaRoller)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+    Q_PROPERTY_CREATE_Q_H(QStringList, ItemList)
+    Q_PROPERTY_CREATE_Q_H(int, ItemHeight)
+    Q_PROPERTY_CREATE_Q_H(int, MaxVisibleItems)
+    Q_PROPERTY_CREATE_Q_H(int, CurrentIndex)
+    Q_PROPERTY_CREATE_Q_H(bool, IsContainer)
+    Q_PROPERTY_CREATE_Q_H(bool, IsEnableLoop)
+public:
+    explicit ElaRoller(QWidget* parent = nullptr);
+    ~ElaRoller() override;
+
+    void setCurrentData(const QString& data);
+    QString getCurrentData() const;
+Q_SIGNALS:
+    Q_SIGNAL void currentDataChanged(const QString& data);
+
+protected:
+    virtual void wheelEvent(QWheelEvent* event) override;
+    virtual void mousePressEvent(QMouseEvent* event) override;
+    virtual void mouseReleaseEvent(QMouseEvent* event) override;
+    virtual void mouseMoveEvent(QMouseEvent* event);
+    virtual void leaveEvent(QEvent* event);
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif //ELAFRAMEWORK_ELAWIDGETTOOLS_INCLUDE_ELAROLLER_H_
@@ -0,0 +1,41 @@
+#ifndef ELAFRAMEWORK_ELAROLLERPICKER_H
+#define ELAFRAMEWORK_ELAROLLERPICKER_H
+
+#include "ElaProperty.h"
+#include <QPushButton>
+
+class ElaRollerPickerPrivate;
+class ELA_EXPORT ElaRollerPicker : public QPushButton
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaRollerPicker)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+public:
+    explicit ElaRollerPicker(QWidget* parent = nullptr);
+    ~ElaRollerPicker() override;
+
+    void addRoller(const QStringList& itemList, bool isEnableLoop = true);
+    void removeRoller(int index);
+
+    void setRollerItemList(int index, const QStringList& itemList);
+    void setRollerWidth(int index, int width);
+
+    void setCurrentData(int index, const QString& data);
+    void setCurrentData(const QStringList& dataList);
+    QString getCurrentData(int index) const;
+    QStringList getCurrentData() const;
+
+    void setCurrentIndex(int rollerIndex, int index);
+    void setCurrentIndex(const QList<int>& indexList);
+    int getCurrentIndex(int rollerIndex) const;
+    QList<int> getCurrentIndex() const;
+
+Q_SIGNALS:
+    Q_SIGNAL void currentDataChanged(const QStringList& dataList);
+    Q_SIGNAL void currentDataSelectionChanged(const QStringList& dataList);
+
+protected:
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif //ELAFRAMEWORK_ELAROLLERPICKER_H
@@ -0,0 +1,26 @@
+#ifndef ELASCROLLAREA_H
+#define ELASCROLLAREA_H
+
+#include <QScrollArea>
+
+#include "ElaProperty.h"
+
+class ElaScrollAreaPrivate;
+class ELA_EXPORT ElaScrollArea : public QScrollArea
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaScrollArea)
+public:
+    explicit ElaScrollArea(QWidget* parent = nullptr);
+    ~ElaScrollArea();
+
+    void setIsGrabGesture(bool isEnable, qreal mousePressEventDelay = 0.5);
+
+    void setIsOverShoot(Qt::Orientation orientation, bool isEnable);
+    bool getIsOverShoot(Qt::Orientation orientation) const;
+
+    void setIsAnimation(Qt::Orientation orientation, bool isAnimation);
+    bool getIsAnimation(Qt::Orientation orientation) const;
+};
+
+#endif // ELASCROLLAREA_H
@@ -0,0 +1,35 @@
+#ifndef ELASCROLLBAR_H
+#define ELASCROLLBAR_H
+
+#include <QAbstractScrollArea>
+#include <QScrollBar>
+
+#include "ElaProperty.h"
+
+class ElaScrollBarPrivate;
+class ELA_EXPORT ElaScrollBar : public QScrollBar
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaScrollBar)
+    Q_PROPERTY_CREATE_Q_H(bool, IsAnimation)
+    Q_PROPERTY_CREATE_Q_H(qreal, SpeedLimit)
+public:
+    explicit ElaScrollBar(QWidget* parent = nullptr);
+    explicit ElaScrollBar(Qt::Orientation orientation, QWidget* parent = nullptr);
+    explicit ElaScrollBar(QScrollBar* originScrollBar, QAbstractScrollArea* parent = nullptr);
+    ~ElaScrollBar() override;
+
+Q_SIGNALS:
+    Q_SIGNAL void rangeAnimationFinished();
+
+protected:
+    virtual bool event(QEvent* event) override;
+    virtual bool eventFilter(QObject* watched, QEvent* event) override;
+    virtual void mousePressEvent(QMouseEvent* event) override;
+    virtual void mouseReleaseEvent(QMouseEvent* event) override;
+    virtual void mouseMoveEvent(QMouseEvent* event) override;
+    virtual void wheelEvent(QWheelEvent* event) override;
+    virtual void contextMenuEvent(QContextMenuEvent* event) override;
+};
+
+#endif // ELASCROLLBAR_H
@@ -0,0 +1,29 @@
+#ifndef ELASCROLLPAGE_H
+#define ELASCROLLPAGE_H
+
+#include <QWidget>
+
+#include "ElaProperty.h"
+class ElaScrollArea;
+class ElaText;
+class QHBoxLayout;
+class ElaScrollPagePrivate;
+class ELA_EXPORT ElaScrollPage : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaScrollPage)
+    Q_PROPERTY_CREATE_Q_H(QWidget*, CustomWidget)
+public:
+    explicit ElaScrollPage(QWidget* parent = nullptr);
+    ~ElaScrollPage() override;
+
+    void addCentralWidget(QWidget* centralWidget, bool isWidgetResizeable = true, bool isVerticalGrabGesture = true, qreal mousePressEventDelay = 0.5);
+
+    void navigation(int widgetIndex, bool isLogRoute = true);
+
+    void setPageTitleSpacing(int spacing);
+    int getPageTitleSpacing() const;
+    void setTitleVisible(bool isVisible);
+};
+
+#endif // ELASCROLLPAGE_H
@@ -0,0 +1,21 @@
+#ifndef ELASCROLLPAGEAREA_H
+#define ELASCROLLPAGEAREA_H
+
+#include <QWidget>
+
+#include "ElaProperty.h"
+class ElaScrollPageAreaPrivate;
+class ELA_EXPORT ElaScrollPageArea : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaScrollPageArea)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+public:
+    explicit ElaScrollPageArea(QWidget* parent = nullptr);
+    ~ElaScrollPageArea() override;
+
+protected:
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELASCROLLPAGEAREA_H
@@ -0,0 +1,60 @@
+#ifndef ELASINGLETON_H
+#define ELASINGLETON_H
+
+#include <QMutex>
+
+#ifndef Q_SINGLETON_CREATE_H
+template <typename T>
+class Singleton
+{
+public:
+    static T* getInstance();
+
+private:
+    Q_DISABLE_COPY(Singleton)
+};
+
+template <typename T>
+T* Singleton<T>::getInstance()
+{
+    static QMutex mutex;
+    QMutexLocker locker(&mutex);
+    static T* instance = nullptr;
+    if (instance == nullptr)
+    {
+        instance = new T();
+    }
+    return instance;
+}
+
+#define Q_SINGLETON_CREATE(Class)               \
+private:                                        \
+    friend class Singleton<Class>;              \
+                                                \
+public:                                         \
+    static Class* getInstance()                 \
+    {                                           \
+        return Singleton<Class>::getInstance(); \
+    }
+
+#define Q_SINGLETON_CREATE_H(Class) \
+private:                            \
+    static Class* _instance;        \
+                                    \
+public:                             \
+    static Class* getInstance();
+
+#define Q_SINGLETON_CREATE_CPP(Class)  \
+    Class* Class::_instance = nullptr; \
+    Class* Class::getInstance()        \
+    {                                  \
+        static QMutex mutex;           \
+        QMutexLocker locker(&mutex);   \
+        if (_instance == nullptr)      \
+        {                              \
+            _instance = new Class();   \
+        }                              \
+        return _instance;              \
+    }
+#endif
+#endif // ELASINGLETON_H
@@ -0,0 +1,16 @@
+#ifndef ELASLIDER_H
+#define ELASLIDER_H
+
+#include <QSlider>
+
+#include "ElaProperty.h"
+class ELA_EXPORT ElaSlider : public QSlider
+{
+    Q_OBJECT
+public:
+    explicit ElaSlider(QWidget* parent = nullptr);
+    explicit ElaSlider(Qt::Orientation orientation, QWidget* parent = nullptr);
+    ~ElaSlider();
+};
+
+#endif // ELASLIDER_H
@@ -0,0 +1,25 @@
+#ifndef ELASPINBOX_H
+#define ELASPINBOX_H
+
+#include <QSpinBox>
+
+#include "ElaDef.h"
+
+class ElaSpinBoxPrivate;
+class ELA_EXPORT ElaSpinBox : public QSpinBox
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaSpinBox)
+    Q_PROPERTY_CREATE_Q_H(ElaSpinBoxType::ButtonMode, ButtonMode)
+public:
+    explicit ElaSpinBox(QWidget* parent = nullptr);
+    ~ElaSpinBox() override;
+
+protected:
+    void focusInEvent(QFocusEvent* event) override;
+    void focusOutEvent(QFocusEvent* event) override;
+    void paintEvent(QPaintEvent* event) override;
+    void contextMenuEvent(QContextMenuEvent* event) override;
+};
+
+#endif // ELASPINBOX_H
@@ -0,0 +1,15 @@
+#ifndef ELASTATUSBAR_H
+#define ELASTATUSBAR_H
+
+#include <QStatusBar>
+
+#include "ElaProperty.h"
+class ELA_EXPORT ElaStatusBar : public QStatusBar
+{
+    Q_OBJECT
+public:
+    explicit ElaStatusBar(QWidget* parent = nullptr);
+    ~ElaStatusBar() override;
+};
+
+#endif // ELASTATUSBAR_H
@@ -0,0 +1,47 @@
+#ifndef ELASUGGESTBOX_H
+#define ELASUGGESTBOX_H
+
+#include <QVariantMap>
+#include <QWidget>
+
+#include "ElaDef.h"
+#include "ElaProperty.h"
+
+class ElaSuggestBoxPrivate;
+class ELA_EXPORT ElaSuggestBox : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaSuggestBox)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+    Q_PROPERTY_CREATE_Q_H(Qt::CaseSensitivity, CaseSensitivity)
+public:
+    explicit ElaSuggestBox(QWidget* parent = nullptr);
+    ~ElaSuggestBox() override;
+    void setPlaceholderText(const QString& placeholderText);
+    void setFixedSize(const QSize& size);
+    void setFixedSize(int w, int h);
+    void setFixedHeight(int h);
+
+    struct ELA_EXPORT SuggestData {
+        Q_PRIVATE_CREATE(ElaIconType::IconName, ElaIcon)
+        Q_PRIVATE_CREATE(QString, SuggestText)
+        Q_PRIVATE_CREATE(QString, SuggestKey)
+        Q_PRIVATE_CREATE(QVariantMap, SuggestData)
+    public:
+        explicit SuggestData();
+        explicit SuggestData(ElaIconType::IconName icon, const QString& suggestText, const QVariantMap& suggestData = {});
+        ~SuggestData();
+    };
+    QString addSuggestion(const QString& suggestText, const QVariantMap& suggestData = {});
+    QString addSuggestion(ElaIconType::IconName icon, const QString& suggestText, const QVariantMap& suggestData = {});
+    QString addSuggestion(const ElaSuggestBox::SuggestData& suggestData);
+    QStringList addSuggestion(const QList<ElaSuggestBox::SuggestData>& suggestDataList);
+
+    void removeSuggestion(const QString& suggestKey);
+    void removeSuggestion(int index);
+    void clearSuggestion();
+Q_SIGNALS:
+    Q_SIGNAL void suggestionClicked(const ElaSuggestBox::SuggestData& suggestData);
+};
+
+#endif // ELASUGGESTBOX_H
@@ -0,0 +1,34 @@
+#ifndef ELATABBAR_H
+#define ELATABBAR_H
+
+#include <QDrag>
+#include <QTabBar>
+
+#include "ElaProperty.h"
+class ElaTabBarPrivate;
+class ELA_EXPORT ElaTabBar : public QTabBar
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaTabBar)
+    Q_PROPERTY_CREATE_Q_H(QSize, TabSize)
+public:
+    explicit ElaTabBar(QWidget* parent = nullptr);
+    ~ElaTabBar() override;
+Q_SIGNALS:
+    Q_SIGNAL void tabDragCreate(QMimeData* mimeData);
+    Q_SIGNAL void tabDragEnter(QMimeData* mimeData);
+    Q_SIGNAL void tabDragLeave(QMimeData* mimeData);
+    Q_SIGNAL void tabDragDrop(QMimeData* mimeData);
+
+protected:
+    QSize sizeHint() const;
+    virtual void mouseMoveEvent(QMouseEvent* event) override;
+    virtual void dragEnterEvent(QDragEnterEvent* event) override;
+    virtual void dragMoveEvent(QDragMoveEvent* event) override;
+    virtual void dragLeaveEvent(QDragLeaveEvent* event) override;
+    virtual void dropEvent(QDropEvent* event) override;
+    virtual void wheelEvent(QWheelEvent* event) override;
+    void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELATABBAR_H
@@ -0,0 +1,31 @@
+#ifndef ELATABWIDGET_H
+#define ELATABWIDGET_H
+
+#include <QTabWidget>
+
+#include "ElaProperty.h"
+
+class ElaTabWidgetPrivate;
+class ELA_EXPORT ElaTabWidget : public QTabWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaTabWidget)
+    Q_PROPERTY_CREATE_Q_H(bool, IsTabTransparent);
+    Q_PROPERTY_CREATE_Q_H(bool, IsContainerAcceptDrops);
+    Q_PROPERTY_CREATE_Q_H(QSize, TabSize)
+public:
+    explicit ElaTabWidget(QWidget* parent = nullptr);
+    ~ElaTabWidget() override;
+    void setTabPosition(TabPosition position);
+
+protected:
+    virtual void paintEvent(QPaintEvent* event) override;
+    virtual void dragEnterEvent(QDragEnterEvent* event) override;
+    virtual void dropEvent(QDropEvent* event) override;
+    virtual void tabInserted(int index);
+
+private:
+    friend class ElaCustomTabWidget;
+};
+
+#endif // ELATABWIDGET_H
@@ -0,0 +1,29 @@
+#ifndef ELATABLEVIEW_H
+#define ELATABLEVIEW_H
+
+#include <QTableView>
+
+#include "ElaProperty.h"
+
+class ElaTableViewPrivate;
+class ELA_EXPORT ElaTableView : public QTableView
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaTableView)
+    Q_PROPERTY_CREATE_Q_H(int, HeaderMargin)
+public:
+    explicit ElaTableView(QWidget* parent = nullptr);
+    ~ElaTableView();
+
+Q_SIGNALS:
+    Q_SIGNAL void tableViewShow();
+    Q_SIGNAL void tableViewHide();
+
+protected:
+    virtual void showEvent(QShowEvent* event) override;
+    virtual void hideEvent(QHideEvent* event) override;
+    virtual void mouseMoveEvent(QMouseEvent* event) override;
+    virtual void leaveEvent(QEvent* event) override;
+};
+
+#endif // ELATABLEVIEW_H
@@ -0,0 +1,28 @@
+#ifndef ELATEXT_H
+#define ELATEXT_H
+
+#include <QLabel>
+
+#include "ElaDef.h"
+#include "ElaProperty.h"
+class ElaTextPrivate;
+class ELA_EXPORT ElaText : public QLabel
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaText)
+    Q_PROPERTY_CREATE_Q_H(bool, IsWrapAnywhere)
+    Q_PROPERTY_CREATE_Q_H(int, TextPixelSize)
+    Q_PROPERTY_CREATE_Q_H(int, TextPointSize)
+    Q_PROPERTY_CREATE_Q_H(ElaTextType::TextStyle, TextStyle)
+    Q_PROPERTY_CREATE_Q_H(ElaIconType::IconName, ElaIcon)
+public:
+    explicit ElaText(QWidget* parent = nullptr);
+    explicit ElaText(QString text, QWidget* parent = nullptr);
+    explicit ElaText(QString text, int pixelSize, QWidget* parent = nullptr);
+    ~ElaText() override;
+
+protected:
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELATEXT_H
@@ -0,0 +1,35 @@
+#ifndef ELATHEME_H
+#define ELATHEME_H
+
+#include <QObject>
+
+#include "ElaDef.h"
+#include "ElaProperty.h"
+#include "ElaSingleton.h"
+
+#define eTheme ElaTheme::getInstance()
+#define ElaThemeColor(themeMode, themeColor) eTheme->getThemeColor(themeMode, ElaThemeType::themeColor)
+class QPainter;
+class ElaThemePrivate;
+class ELA_EXPORT ElaTheme : public QObject
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaTheme)
+    Q_SINGLETON_CREATE_H(ElaTheme)
+private:
+    explicit ElaTheme(QObject* parent = nullptr);
+    ~ElaTheme();
+
+public:
+    void setThemeMode(ElaThemeType::ThemeMode themeMode);
+    ElaThemeType::ThemeMode getThemeMode() const;
+
+    void drawEffectShadow(QPainter* painter, QRect widgetRect, int shadowBorderWidth, int borderRadius);
+
+    void setThemeColor(ElaThemeType::ThemeMode themeMode, ElaThemeType::ThemeColor themeColor, QColor newColor);
+    const QColor& getThemeColor(ElaThemeType::ThemeMode themeMode, ElaThemeType::ThemeColor themeColor);
+Q_SIGNALS:
+    Q_SIGNAL void themeModeChanged(ElaThemeType::ThemeMode themeMode);
+};
+
+#endif // ELATHEME_H
@@ -0,0 +1,31 @@
+#ifndef ELATOGGLEBUTTON_H
+#define ELATOGGLEBUTTON_H
+
+#include <QPushButton>
+
+#include "ElaProperty.h"
+class ElaToggleButtonPrivate;
+class ELA_EXPORT ElaToggleButton : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaToggleButton)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+    Q_PROPERTY_CREATE_Q_H(QString, Text)
+public:
+    explicit ElaToggleButton(QWidget* parent = nullptr);
+    explicit ElaToggleButton(QString text, QWidget* parent = nullptr);
+    ~ElaToggleButton();
+
+    void setIsToggled(bool isToggled);
+    bool getIsToggled() const;
+Q_SIGNALS:
+    Q_SIGNAL void toggled(bool checked);
+
+protected:
+    virtual bool event(QEvent* event) override;
+    virtual void mousePressEvent(QMouseEvent* event) override;
+    virtual void mouseReleaseEvent(QMouseEvent* event) override;
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELATOGGLEBUTTON_H
@@ -0,0 +1,29 @@
+#ifndef ELATOGGLESWITCH_H
+#define ELATOGGLESWITCH_H
+
+#include <QWidget>
+
+#include "ElaProperty.h"
+class ElaToggleSwitchPrivate;
+class ELA_EXPORT ElaToggleSwitch : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaToggleSwitch);
+
+public:
+    explicit ElaToggleSwitch(QWidget* parent = nullptr);
+    ~ElaToggleSwitch() override;
+    void setIsToggled(bool isToggled);
+    bool getIsToggled() const;
+Q_SIGNALS:
+    Q_SIGNAL void toggled(bool checked);
+
+protected:
+    virtual bool event(QEvent* event) override;
+    virtual void mousePressEvent(QMouseEvent* event) override;
+    virtual void mouseReleaseEvent(QMouseEvent* event) override;
+    virtual void mouseMoveEvent(QMouseEvent* event) override;
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELATOGGLESWITCH_H
@@ -0,0 +1,30 @@
+#ifndef ELATOOLBAR_H
+#define ELATOOLBAR_H
+
+#include <QToolBar>
+
+#include "ElaDef.h"
+class ElaToolBarPrivate;
+class ELA_EXPORT ElaToolBar : public QToolBar
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaToolBar)
+public:
+    explicit ElaToolBar(QWidget* parent = nullptr);
+    explicit ElaToolBar(const QString& title, QWidget* parent = nullptr);
+    ~ElaToolBar() override;
+
+    void setToolBarSpacing(int spacing);
+    int getToolBarSpacing() const;
+
+    void setToolButtonSize(const QSize& size);
+    const QSize& getToolButtonSize() const;
+
+    QAction* addElaIconAction(ElaIconType::IconName icon, const QString& text);
+    QAction* addElaIconAction(ElaIconType::IconName icon, const QString& text, const QKeySequence& shortcut);
+
+protected:
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELATOOLBAR_H
@@ -0,0 +1,31 @@
+#ifndef ELATOOLBUTTON_H
+#define ELATOOLBUTTON_H
+
+#include <QToolButton>
+
+#include "ElaDef.h"
+class ElaMenu;
+class ElaToolButtonPrivate;
+class ELA_EXPORT ElaToolButton : public QToolButton
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaToolButton)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius);
+    Q_PROPERTY_CREATE_Q_H(bool, IsSelected);
+
+public:
+    explicit ElaToolButton(QWidget* parent = nullptr);
+    ~ElaToolButton() override;
+
+    void setIsTransparent(bool isTransparent);
+    bool getIsTransparent() const;
+
+    void setMenu(ElaMenu* menu);
+    void setElaIcon(ElaIconType::IconName icon);
+    void setElaIcon(ElaIconType::IconName icon, int rotate);
+
+protected:
+    virtual bool eventFilter(QObject* watched, QEvent* event) override;
+};
+
+#endif // ELATOOLBUTTON_H
@@ -0,0 +1,28 @@
+#ifndef ELATOOLTIP_H
+#define ELATOOLTIP_H
+
+#include <QWidget>
+
+#include "ElaProperty.h"
+class ElaToolTipPrivate;
+class ELA_EXPORT ElaToolTip : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaToolTip)
+    Q_PROPERTY_CREATE_Q_H(int, BorderRadius)
+    Q_PROPERTY_CREATE_Q_H(int, DisplayMsec)
+    Q_PROPERTY_CREATE_Q_H(int, ShowDelayMsec)
+    Q_PROPERTY_CREATE_Q_H(int, HideDelayMsec)
+    Q_PROPERTY_CREATE_Q_H(QString, ToolTip)
+    Q_PROPERTY_CREATE_Q_H(QWidget*, CustomWidget)
+public:
+    explicit ElaToolTip(QWidget* parent = nullptr);
+    ~ElaToolTip() override;
+
+    void updatePos();
+
+protected:
+    virtual void paintEvent(QPaintEvent* event);
+};
+
+#endif // ELATOOLTIP_H
@@ -0,0 +1,20 @@
+#ifndef ELATREEVIEW_H
+#define ELATREEVIEW_H
+
+#include <QTreeView>
+
+#include "ElaProperty.h"
+
+class ElaTreeViewPrivate;
+class ELA_EXPORT ElaTreeView : public QTreeView
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaTreeView)
+    Q_PROPERTY_CREATE_Q_H(int, ItemHeight)
+    Q_PROPERTY_CREATE_Q_H(int, HeaderMargin)
+public:
+    explicit ElaTreeView(QWidget* parent = nullptr);
+    ~ElaTreeView();
+};
+
+#endif // ELATREEVIEW_H
@@ -0,0 +1,36 @@
+#ifndef ELAWIDGET_H
+#define ELAWIDGET_H
+
+#include <QWidget>
+
+#include "ElaAppBar.h"
+#include "ElaDef.h"
+class ElaWidgetPrivate;
+class ELA_EXPORT ElaWidget : public QWidget
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaWidget)
+    Q_PROPERTY_CREATE_Q_H(bool, IsStayTop)
+    Q_PROPERTY_CREATE_Q_H(bool, IsFixedSize)
+    Q_PROPERTY_CREATE_Q_H(bool, IsDefaultClosed)
+    Q_PROPERTY_CREATE_Q_H(int, AppBarHeight)
+    Q_TAKEOVER_NATIVEEVENT_H
+public:
+    explicit ElaWidget(QWidget* parent = nullptr);
+    ~ElaWidget() override;
+    void moveToCenter();
+
+    void setWindowButtonFlag(ElaAppBarType::ButtonType buttonFlag, bool isEnable = true);
+    void setWindowButtonFlags(ElaAppBarType::ButtonFlags buttonFlags);
+    ElaAppBarType::ButtonFlags getWindowButtonFlags() const;
+Q_SIGNALS:
+    Q_SIGNAL void routeBackButtonClicked();
+    Q_SIGNAL void navigationButtonClicked();
+    Q_SIGNAL void themeChangeButtonClicked();
+    Q_SIGNAL void closeButtonClicked();
+
+protected:
+    virtual void paintEvent(QPaintEvent* event) override;
+};
+
+#endif // ELAWIDGET_H
@@ -0,0 +1,115 @@
+#ifndef ELAWINDOW_H
+#define ELAWINDOW_H
+
+#include <QMainWindow>
+
+#include "ElaAppBar.h"
+#include "ElaDef.h"
+#include "ElaSuggestBox.h"
+class ElaWindowPrivate;
+class ELA_EXPORT ElaWindow : public QMainWindow
+{
+    Q_OBJECT
+    Q_Q_CREATE(ElaWindow)
+    Q_PROPERTY_CREATE_Q_H(bool, IsStayTop)
+    Q_PROPERTY_CREATE_Q_H(bool, IsFixedSize)
+    Q_PROPERTY_CREATE_Q_H(bool, IsDefaultClosed)
+    Q_PROPERTY_CREATE_Q_H(int, AppBarHeight)
+    Q_PROPERTY_CREATE_Q_H(int, ThemeChangeTime)
+    Q_PROPERTY_CREATE_Q_H(bool, IsCentralStackedWidgetTransparent)
+    Q_PROPERTY_CREATE_Q_H(bool, IsAllowPageOpenInNewWindow)
+    Q_PROPERTY_CREATE_Q_H(bool, IsNavigationBarEnable)
+    Q_PROPERTY_CREATE_Q_H(int, NavigationBarWidth)
+    Q_PROPERTY_CREATE_Q_H(int, CurrentStackIndex)
+    Q_PROPERTY_CREATE_Q_H(ElaNavigationType::NavigationDisplayMode, NavigationBarDisplayMode)
+    Q_PROPERTY_CREATE_Q_H(ElaWindowType::StackSwitchMode, StackSwitchMode)
+    Q_PROPERTY_CREATE_Q_H(ElaWindowType::PaintMode, WindowPaintMode)
+    Q_TAKEOVER_NATIVEEVENT_H
+public:
+    Q_INVOKABLE explicit ElaWindow(QWidget* parent = nullptr);
+    ~ElaWindow() override;
+
+    void moveToCenter();
+
+    void setCustomWidget(ElaAppBarType::CustomArea customArea, QWidget* customWidget, QObject* hitTestObject = nullptr, const QString& hitTestFunctionName = "");
+    QWidget* getCustomWidget(ElaAppBarType::CustomArea customArea) const;
+
+    void setCentralCustomWidget(QWidget* customWidget);
+    QWidget* getCentralCustomWidget() const;
+
+    void setCustomMenu(QMenu* customMenu);
+    QMenu* getCustomMenu() const;
+
+    void setUserInfoCardVisible(bool isVisible);
+    void setUserInfoCardPixmap(QPixmap pix);
+    void setUserInfoCardTitle(QString title);
+    void setUserInfoCardSubTitle(QString subTitle);
+    ElaNavigationType::NodeResult addExpanderNode(const QString& expanderTitle, QString& expanderKey, ElaIconType::IconName awesome = ElaIconType::None) const;
+    ElaNavigationType::NodeResult addExpanderNode(const QString& expanderTitle, QString& expanderKey, const QString& targetExpanderKey, ElaIconType::IconName awesome = ElaIconType::None) const;
+    ElaNavigationType::NodeResult addPageNode(const QString& pageTitle, QWidget* page, ElaIconType::IconName awesome = ElaIconType::None);
+    ElaNavigationType::NodeResult addPageNode(const QString& pageTitle, QWidget* page, int keyPoints, ElaIconType::IconName awesome = ElaIconType::None);
+    ElaNavigationType::NodeResult addPageNode(const QString& pageTitle, QWidget* page, const QString& targetExpanderKey, ElaIconType::IconName awesome = ElaIconType::None);
+    ElaNavigationType::NodeResult addPageNode(const QString& pageTitle, QWidget* page, const QString& targetExpanderKey, int keyPoints, ElaIconType::IconName awesome = ElaIconType::None);
+    ElaNavigationType::NodeResult addFooterNode(const QString& footerTitle, QString& footerKey, int keyPoints = 0, ElaIconType::IconName awesome = ElaIconType::None) const;
+    ElaNavigationType::NodeResult addFooterNode(const QString& footerTitle, QWidget* page, QString& footerKey, int keyPoints = 0, ElaIconType::IconName awesome = ElaIconType::None);
+    ElaNavigationType::NodeResult addCategoryNode(const QString& categoryTitle, QString& categoryKey);
+    ElaNavigationType::NodeResult addCategoryNode(const QString& categoryTitle, QString& categoryKey, const QString& targetExpanderKey);
+
+    void addCentralWidget(QWidget* centralWidget);
+    QWidget* getCentralWidget(int index) const;
+
+    bool getNavigationNodeIsExpanded(QString expanderKey) const;
+    void expandNavigationNode(QString expanderKey);
+    void collapseNavigationNode(QString expanderKey);
+    void removeNavigationNode(QString nodeKey) const;
+    int getPageOpenInNewWindowCount(QString nodeKey) const;
+    void backtrackNavigationNode(QString nodeKey);
+
+    void setNodeKeyPoints(QString nodeKey, int keyPoints);
+    int getNodeKeyPoints(QString nodeKey) const;
+
+    void setNavigationNodeTitle(QString nodeKey, QString nodeTitle);
+    QString getNavigationNodeTitle(QString nodeKey) const;
+
+    void navigation(QString pageKey);
+    int getCurrentNavigationIndex() const;
+    QString getCurrentNavigationPageKey() const;
+
+    QList<ElaSuggestBox::SuggestData> getNavigationSuggestDataList() const;
+
+    void setWindowButtonFlag(ElaAppBarType::ButtonType buttonFlag, bool isEnable = true);
+    void setWindowButtonFlags(ElaAppBarType::ButtonFlags buttonFlags);
+    ElaAppBarType::ButtonFlags getWindowButtonFlags() const;
+
+    void setWindowMoviePath(ElaThemeType::ThemeMode themeMode, const QString& moviePath);
+    QString getWindowMoviePath(ElaThemeType::ThemeMode themeMode) const;
+
+    void setWindowPixmap(ElaThemeType::ThemeMode themeMode, const QPixmap& pixmap);
+    QPixmap getWindowPixmap(ElaThemeType::ThemeMode themeMode) const;
+
+    void setWindowMovieRate(qreal rate);
+    qreal getWindowMovieRate() const;
+
+    void tabifyDockWidget(QDockWidget* targetDockWidget, QDockWidget* dockWidget);
+    void tabifyDockWidget(Qt::DockWidgetArea area, const QString& targetDockTitle, QDockWidget* dockWidget);
+
+Q_SIGNALS:
+    Q_SIGNAL void userInfoCardClicked();
+    Q_SIGNAL void closeButtonClicked();
+    Q_SIGNAL void navigationNodeClicked(ElaNavigationType::NavigationNodeType nodeType, QString nodeKey);
+    Q_SIGNAL void customWidgetChanged();
+    Q_SIGNAL void centralCustomWidgetChanged();
+    Q_SIGNAL void customMenuChanged();
+    Q_SIGNAL void pageOpenInNewWindow(QString nodeKey);
+
+protected:
+    virtual bool eventFilter(QObject* watched, QEvent* event) override;
+    virtual QMenu* createPopupMenu() override;
+    virtual void paintEvent(QPaintEvent* event) override;
+
+private:
+    QWidget* centralWidget() const;
+    void setCentralWidget(QWidget* widget);
+};
+
+#endif // ELAWINDOW_H