win32/latest/_t_edu_board_8h_source.html

#pragma once


#if defined(WIN32) //Windows


#ifdef EDUSDK_EXPORTS

#define EDUSDK_API __declspec(dllexport)

#else

#define EDUSDK_API __declspec(dllimport)

#endif


#include <windows.h>


#undef DeleteFile


#define WINDOW_HANDLE HWND


#else //Unix


#define EDUSDK_API __attribute__ ((visibility("default")))


#if defined(__APPLE__) //macOS


#ifdef __cplusplus

#ifdef __OBJC__

@class NSView;

#else

struct NSView;

#endif

#define WINDOW_HANDLE NSView*

#else

#define WINDOW_HANDLE void*

#endif


#else //Linux


#define WINDOW_HANDLE unsigned long


#define AUDIO_HANDLER_SUPPORT


#endif


#endif


#include <cstdint>

#include <ostream>

class TEduBoardController;


#ifdef __cplusplus

extern "C" {

#endif


#if defined(WIN32)

    typedef long(__stdcall* PFNOnProgress)(unsigned long dwEvent, unsigned long dwReadByte, unsigned long dwTotalByte, void* pParam);

#endif


    EDUSDK_API TEduBoardController* CreateTEduBoardController(bool disableCefInit = false, const char* cefRenderPath = nullptr);


    EDUSDK_API void DestroyTEduBoardController(TEduBoardController** ppBoardController);


    EDUSDK_API void ClearTEduBoardSDKEnv();


    EDUSDK_API const char* GetTEduBoardVersion();


    EDUSDK_API bool SetTEduBoardLogFileDir(const char* logDir = nullptr);


    EDUSDK_API void SetTEduBoardCacheFileDir(const char* cacheDir = nullptr);


    EDUSDK_API bool EnableTEduBoardOffscreenRender(uint32_t maxFps = 30);


    EDUSDK_API bool EnableTEduBoardCrashReport();


    EDUSDK_API void* GetTEduBoardRenderProcessHandler();


#if defined(WIN32)


    EDUSDK_API void LoadTEduBoardResource(const char* fileUrl, int expireTime = 259200, PFNOnProgress pFNOnProgress = nullptr);

#endif


    EDUSDK_API void SetTEduBoardResourceConfig(unsigned int sdkAppId, const char* userId);


#if defined(WIN32)


    EDUSDK_API void LoadCustomResource(const char* fileUrl, int resourceType, int expireTime = 259200, PFNOnProgress pFNOnProgress = nullptr);

#endif


#ifdef __cplusplus

}

#endif


enum TEduBoardErrorCode {

    TEDU_BOARD_ERROR_INIT = 1,

    TEDU_BOARD_ERROR_AUTH = 2,

    TEDU_BOARD_ERROR_LOAD = 3,

    TEDU_BOARD_ERROR_TIM_INVALID = 5,

    TEDU_BOARD_ERROR_HISTORYDATA = 6,

    TEDU_BOARD_ERROR_RUNTIME = 7,

    TEDU_BOARD_ERROR_AUTH_TIMEOUT = 8,

    TEDU_BOARD_ERROR_DATA_TOO_LARGE = 9,

    TEDU_BOARD_ERROR_MAX_BOARD_LIMITED = 10,

    TEDU_BOARD_ERROR_SIGNATURE_EXPIRED = 11,

    TEDU_BOARD_ERROR_OOM = 101,

    TEDU_BOARD_ERROR_PATH_INVALID = 102,

    TEDU_BOARD_ERROR_WRITE_ERROR = 103,

};


enum TEduBoardWarningCode {

    TEDU_BOARD_WARNING_SYNC_DATA_PARSE_FAILED = 1,

    TEDU_BOARD_WARNING_TIM_SEND_MSG_FAILED = 2,

    TEDU_BOARD_WARNING_H5PPT_ALREADY_EXISTS = 3,

    TEDU_BOARD_WARNING_AUTO_RELOAD = 4,

    TEDU_BOARD_WARNING_ILLEGAL_OPERATION = 5,

    TEDU_BOARD_WARNING_H5FILE_ALREADY_EXISTS = 6,

    TEDU_BOARD_WARNING_VIDEO_ALREADY_EXISTS = 7,

    TEDU_BOARD_WARNING_IMAGESFILE_ALREADY_EXISTS = 8,

    TEDU_BOARD_WARNING_GRAFFITI_LOST = 9,

    TEDU_BOARD_WARNING_CUSTOM_GRAPH_URL_NON_EXISTS = 10,

    TEDU_BOARD_WARNING_IMAGESFILE_TOO_LARGE = 11,

    TEDU_BOARD_WARNING_IMAGE_COURSEWARE_ALREADY_EXISTS = 12,

    TEDU_BOARD_WARNING_IMAGE_MEDIA_BITRATE_TOO_LARGE = 13,

    TEDU_BOARD_WARNING_IMAGE_WATERMARK_ALREADY_EXISTS = 14,

    TEDU_BOARD_WARNING_FORMULA_LIB_NOT_LOADED = 15,

    TEDU_BOARD_WARNING_ILLEGAL_FORMULA_EXPRESSION = 16,

    TEDU_BOARD_WARNING_TEXT_WATERMARK_ALREADY_EXISTS = 17,

    TEDU_BOARD_WARNING_EXPORTIMPORT_FILTERRULE_ILLEGAL = 18,

    TEDU_BOARD_WARNING_ELEMENTTYPE_NOT_EXISTS = 19,

    TEDU_BOARD_WARNING_ELEMENTID_NOT_EXISTS = 20,

    TEDU_BOARD_WARNING_ELEMENT_IS_LOCKED = 21,

    TEDU_BOARD_WARNING_AUDIO_PLAY_FAILED = 101,

    TEDU_BOARD_WARNING_TRTC_INVALID = 102,

};


enum TEduBoardToolType {

    TEDU_BOARD_TOOL_TYPE_MOUSE = 0,

    TEDU_BOARD_TOOL_TYPE_PEN = 1,

    TEDU_BOARD_TOOL_TYPE_ERASER = 2,

    TEDU_BOARD_TOOL_TYPE_LASER = 3,

    TEDU_BOARD_TOOL_TYPE_LINE = 4,

    TEDU_BOARD_TOOL_TYPE_OVAL = 5,

    TEDU_BOARD_TOOL_TYPE_RECT = 6,

    TEDU_BOARD_TOOL_TYPE_OVAL_SOLID = 7,

    TEDU_BOARD_TOOL_TYPE_RECT_SOLID = 8,

    TEDU_BOARD_TOOL_TYPE_POINT_SELECT = 9,

    TEDU_BOARD_TOOL_TYPE_RECT_SELECT = 10,

    TEDU_BOARD_TOOL_TYPE_TEXT = 11,

    TEDU_BOARD_TOOL_TYPE_ZOOM_DRAG = 12,

    TEDU_BOARD_TOOL_TYPE_SQUARE = 13,

    TEDU_BOARD_TOOL_TYPE_SQUARE_SOLID = 14,

    TEDU_BOARD_TOOL_TYPE_CIRCLE = 15,

    TEDU_BOARD_TOOL_TYPE_CIRCLE_SOLID = 16,

    TEDU_BOARD_TOOL_TYPE_BOARD_CUSTOM_GRAPH = 17,

    TEDU_BOARD_TOOL_TYPE_ARC = 18,

    TEDU_BOARD_TOOL_TYPE_HIGHLIGHTER = 19,

    TEDU_BOARD_TOOL_TYPE_RIGHT_TRIANGLE = 20,

    TEDU_BOARD_TOOL_TYPE_ISOSCELES_TRIANGLE = 21,

    TEDU_BOARD_TOOL_TYPE_PARALLELOGRAM = 22,

    TEDU_BOARD_TOOL_TYPE_CUBE = 23,

    TEDU_BOARD_TOOL_TYPE_CYLINDER = 24,

    TEDU_BOARD_TOOL_TYPE_CONE = 25,

    TEDU_BOARD_TOOL_TYPE_COORDINATE = 26,

};


enum TEduBoardElementType {

    TEDU_BOARD_ELEMENT_IMAGE                    = 1,

    TEDU_BOARD_ELEMENT_H5                       = 2,

    TEDU_BOARD_ELEMENT_CUSTOM_GRAPH             = 3,

    TEDU_BOARD_ELEMENT_AUDIO                    = 4,

    TEDU_BOARD_ELEMENT_GLOBAL_AUDIO             = 5,

    TEDU_BOARD_ELEMENT_MATH_BOARD               = 6,

    TEDU_BOARD_ELEMENT_MATH_GRAPH               = 7,

    TEDU_BOARD_ELEMENT_TEXT                     =9,

    TEDU_BOARD_ELEMENT_MAGIC_LINE               = 10,

    TEDU_BOARD_ELEMENT_FORMULA                  = 11,

    TEDU_BOARD_ELEMENT_WATERMARK = 100,

    TEDU_BOARD_ELEMENT_GRAFFITI_LINE = 801,

    TEDU_BOARD_ELEMENT_GRAFFITI_GRAPH_LINE = 802,

    TEDU_BOARD_ELEMENT_GRAFFITI_GRAPH_RECT = 803,

    TEDU_BOARD_ELEMENT_GRAFFITI_GRAPH_OVAL = 804,

    TEDU_BOARD_ELEMENT_GRAFFITI_GRAPH_ARC = 805,

    TEDU_BOARD_ELEMENT_GRAFFITI_GRAPH_RIGHT_TRIANGLE = 806,

    TEDU_BOARD_ELEMENT_GRAFFITI_GRAPH_ISOSCELES_TRIANGLE = 807,

    TEDU_BOARD_ELEMENT_GRAFFITI_GRAPH_PARALLELOGRAM = 808,

    TEDU_BOARD_ELEMENT_GRAFFITI_GRAPH_CUBE = 809,

    TEDU_BOARD_ELEMENT_GRAFFITI_GRAPH_CYLINDER = 810,

    TEDU_BOARD_ELEMENT_GRAFFITI_GRAPH_CONE = 811,

    TEDU_BOARD_ELEMENT_GRAFFITI_GRAPH_HIGHLIGHTER = 812,

};


enum TEduBoardErasableElementType {

    TEDU_BOARD_ERASABLE_ELEMENT_LINE = 0,

    TEDU_BOARD_ERASABLE_ELEMENT_GRAPH = 1,

    TEDU_BOARD_ERASABLE_ELEMENT_TEXT = 2,

    TEDU_BOARD_ERASABLE_ELEMENT_IMAGE = 3,

    TEDU_BOARD_ERASABLE_ELEMENT_ELEMENT = 4,

};


enum TEduBoardImageFitMode {

    TEDU_BOARD_IMAGE_FIT_MODE_CENTER = 0,

    TEDU_BOARD_IMAGE_FIT_MODE_LEFT = 4,

    TEDU_BOARD_IMAGE_FIT_MODE_TOP = 5,

    TEDU_BOARD_IMAGE_FIT_MODE_RIGHT = 6,

    TEDU_BOARD_IMAGE_FIT_MODE_BOTTOM = 7,

};


enum TEduBoardImageStatus {

    TEDU_BOARD_IMAGE_STATUS_LOADING = 1,

    TEDU_BOARD_IMAGE_STATUS_LOAD_DONE = 2,

    TEDU_BOARD_IMAGE_STATUS_LOAD_ABORT = 3,

    TEDU_BOARD_IMAGE_STATUS_LOAD_ERROR = 4,

    TEDU_BOARD_IMAGE_STATUS_LOAD_TIMEOUT = 5,

    TEDU_BOARD_IMAGE_STATUS_LOAD_CANCEL = 6,

    TEDU_BOARD_IMAGE_STATUS_READ_ERROR = 7,

};


enum TEduBoardPosition {

    TEDU_BOARD_POSITION_LEFT_TOP = 0,

    TEDU_BOARD_POSITION_RIGHT_TOP = 1,

    TEDU_BOARD_POSITION_RIGHT_BOTTOM = 2,

    TEDU_BOARD_POSITION_LEFT_BOTTOM = 3,

};


enum TEduBoardPositionChangeStatus {

    TEDU_BOARD_POSITION_CHANGE_START = 0,

    TEDU_BOARD_POSITION_CHANGING = 1,

    TEDU_BOARD_POSITION_CHANGE_END = 2,

};


enum TEduBoardTextStyle {

    TEDU_BOARD_TEXT_STYLE_NORMAL = 0,

    TEDU_BOARD_TEXT_STYLE_BOLD = 1,

    TEDU_BOARD_TEXT_STYLE_ITALIC = 2,

    TEDU_BOARD_TEXT_STYLE_BOLD_ITALIC = 3,

};


enum TEduBoardUploadStatus {

    TEDU_BOARD_UPLOAD_STATUS_SUCCEED = 1,

    TEDU_BOARD_UPLOAD_STATUS_FAILED = 2,

};


enum TEduBoardBackgroundH5Status {

    TEDU_BOARD_BACKGROUND_H5_STATUS_LOADING = 1,

    TEDU_BOARD_BACKGROUND_H5_STATUS_LOAD_FINISH = 2,

};


enum TEduBoardContentFitMode {

    TEDU_BOARD_CONTENT_FIT_MODE_NONE = 0,

    TEDU_BOARD_CONTENT_FIT_MODE_CENTER_INSIDE = 1,

    TEDU_BOARD_CONTENT_FIT_MODE_CENTER_COVER = 2,

};


enum TEduBoardLineType {

    TEDU_BOARD_LINE_TYPE_SOLID = 1,

    TEDU_BOARD_LINE_TYPE_DOTTED = 2,

};


enum TEduBoardArrowType {

    TEDU_BOARD_ARROW_TYPE_NONE = 1,

    TEDU_BOARD_ARROW_TYPE_NORMAL = 2,

    TEDU_BOARD_ARROW_TYPE_SOLID = 3,

};


enum TEduBoardFillType {

    TEDU_BOARD_FILL_NONE = 1,

    TEDU_BOARD_FILL_SOLID = 2,

};


enum TEduBoardOvalDrawMode {

    TEDU_BOARD_OVAL_DRAW_MODE_FIX_START = 1,

    TEDU_BOARD_OVAL_DRAW_MODE_FIX_CENTER = 2,

};


enum TEduBoardFileTranscodeStatus {

    TEDU_BOARD_FILE_TRANSCODE_ERROR = 1,

    TEDU_BOARD_FILE_TRANSCODE_UPLOADING = 2,

    TEDU_BOARD_FILE_TRANSCODE_CREATED = 3,

    TEDU_BOARD_FILE_TRANSCODE_QUEUED = 4,

    TEDU_BOARD_FILE_TRANSCODE_PROCESSING = 5,

    TEDU_BOARD_FILE_TRANSCODE_FINISHED = 6,

};


enum TEduBoardH5FileStatus {

    TEDU_BOARD_H5_FILE_STATUS_LOADING = 1,

    TEDU_BOARD_H5_FILE_STATUS_LOADED = 2,

};


enum TEduBoardH5PPTStatus {

    TEDU_BOARD_H5_PPT_STATUS_LOADING = 1,

    TEDU_BOARD_H5_PPT_STATUS_LOADED = 2,

    TEDU_BOARD_H5_PPT_STATUS_CANCEL = 3,

    TEDU_BOARD_H5_PPT_STATUS_TIMEOUT = 4,

    TEDU_BOARD_H5_PPT_STATUS_RESOURCES_LOADING_ERROR = 5,

    TEDU_BOARD_H5_PPT_STATUS_RUNTIME_ERROR = 6,

};


enum TEduBoardH5PPTMediaStatus {

    TEDU_BOARD_H5_PPT_MEDIA_STATUS_PLAY = 1,

    TEDU_BOARD_H5_PPT_MEDIA_STATUS_PAUSE = 2,

};


enum TEduBoardVideoStatus {

    TEDU_BOARD_VIDEO_STATUS_ERROR = 1,

    TEDU_BOARD_VIDEO_STATUS_LOADING = 2,

    TEDU_BOARD_VIDEO_STATUS_LOADED = 3,

    TEDU_BOARD_VIDEO_STATUS_PLAYED = 4,

    TEDU_BOARD_VIDEO_STATUS_TIMEUPDATE = 5,

    TEDU_BOARD_VIDEO_STATUS_PAUSED = 6,

    TEDU_BOARD_VIDEO_STATUS_SEEKED = 7,

    TEDU_BOARD_VIDEO_STATUS_ENDED = 8,

    TEDU_BOARD_VIDEO_STATUS_WAITING = 9,

    TEDU_BOARD_VIDEO_STATUS_PLAYING = 10,

};


enum TEduBoardAudioStatus {

    TEDU_BOARD_AUDIO_STATUS_ERROR = 1,

    TEDU_BOARD_AUDIO_STATUS_LOADING = 2,

    TEDU_BOARD_AUDIO_STATUS_LOADED = 3,

    TEDU_BOARD_AUDIO_STATUS_PLAYED = 4,

    TEDU_BOARD_AUDIO_STATUS_TIMEUPDATE = 5,

    TEDU_BOARD_AUDIO_STATUS_PAUSED = 6,

    TEDU_BOARD_AUDIO_STATUS_SEEKED = 7,

    TEDU_BOARD_AUDIO_STATUS_ENDED = 8,

    TEDU_BOARD_AUDIO_STATUS_WAITING = 9,

    TEDU_BOARD_AUDIO_STATUS_PLAYING = 10,

};


enum TEduBoardKeyEventType {

    TEDU_BOARD_KEYEVENT_RAWKEYDOWN = 0,

    TEDU_BOARD_KEYEVENT_KEYDOWN,

    TEDU_BOARD_KEYEVENT_KEYUP,

    TEDU_BOARD_KEYEVENT_CHAR

};


enum TEduBoardMouseButtonType {

    TEDU_BOARD_MOUSEBUTTON_LEFT = 0,

    TEDU_BOARD_MOUSEBUTTON_MIDDLE,

    TEDU_BOARD_MOUSEBUTTON_RIGHT,

};


enum TEduBoardTouchEventType {

    TEDU_BOARD_TOUCHEVENT_RELEASED = 0,

    TEDU_BOARD_TOUCHEVENT_PRESSED,

    TEDU_BOARD_TOUCHEVENT_MOVED,

    TEDU_BOARD_TOUCHEVENT_CANCELLED

};


enum TEduBoardPointType {

    TEDU_BOARD_POINTER_TYPE_TOUCH = 0,

    TEDU_BOARD_POINTER_TYPE_MOUSE,

    TEDU_BOARD_POINTER_TYPE_PEN,

    TEDU_BOARD_POINTER_TYPE_ERASER,

    TEDU_BOARD_POINTER_TYPE_UNKNOWN

};


enum TEduBoardEventFlag {

    TEDU_BOARD_EVENTFLAG_NONE = 0,

    TEDU_BOARD_EVENTFLAG_CAPS_LOCK_ON = 1 << 0,

    TEDU_BOARD_EVENTFLAG_SHIFT_DOWN = 1 << 1,

    TEDU_BOARD_EVENTFLAG_CONTROL_DOWN = 1 << 2,

    TEDU_BOARD_EVENTFLAG_ALT_DOWN = 1 << 3,

    TEDU_BOARD_EVENTFLAG_LEFT_MOUSE_BUTTON = 1 << 4,

    TEDU_BOARD_EVENTFLAG_MIDDLE_MOUSE_BUTTON = 1 << 5,

    TEDU_BOARD_EVENTFLAG_RIGHT_MOUSE_BUTTON = 1 << 6,

    TEDU_BOARD_EVENTFLAG_COMMAND_DOWN = 1 << 7,

    TEDU_BOARD_EVENTFLAG_NUM_LOCK_ON = 1 << 8,

    TEDU_BOARD_EVENTFLAG_IS_KEY_PAD = 1 << 9,

    TEDU_BOARD_EVENTFLAG_IS_LEFT = 1 << 10,

    TEDU_BOARD_EVENTFLAG_IS_RIGHT = 1 << 11,

};


enum TEduBoardAccessibleOperation {

    TEDU_BOARD_OPERATION_ALL = 0,

    TEDU_BOARD_OPERATION_MOVE = 1,

    TEDU_BOARD_OPERATION_DELETE = 2,

    TEDU_BOARD_OPERATION_SCALE = 3,

    TEDU_BOARD_OPERATION_ROTATE = 4,

    TEDU_BOARD_OPERATION_SELECTED = 5,

    TEDU_BOARD_OPERATION_ADD = 6,

};


enum TEduBoardTextComponentStatus {

    TEDU_BOARD_TEXT_COMPONENT_STATUS_INSUFFICIENT_SPACE = 1,

    TEDU_BOARD_TEXT_COMPONENT_STATUS_WORD_LIMIT = 2,

    TEDU_BOARD_TEXT_COMPONENT_CANNOT_USE_EMOJI = 3,

};


enum TEduBoardMathGraphCode {

    MATH_EXPRESSION_PARSE_ERROR = -1,

};


enum TEduBoardPenFittingMode {

    NONE = 0,

    AUTO = 1,

    RECTANGLE = 2,

    POLYGON = 3,

    CIRCLE = 4,

    ELLIPSE = 5,

};


enum TEduBoardBackgroundType {

    TEDU_BOARD_BACKGROUND_IMAGE = 1,

    TEDU_BOARD_BACKGROUND_H5 = 2,

};


enum TEduBoardMathGraphType {

    TEDU_BOARD_MATHGRAPH_NONE = 0,

    TEDU_BOARD_MATHGRAPH_POINT = 1,

    TEDU_BOARD_MATHGRAPH_LINE = 2,

    TEDU_BOARD_MATHGRAPH_LINE_SEGMENT = 3,

    TEDU_BOARD_MATHGRAPH_RAY = 4,

    TEDU_BOARD_MATHGRAPH_CIRCLE = 5,

    TEDU_BOARD_MATHGRAPH_ANGLE = 6,

    TEDU_BOARD_MATHGRAPH_POLYGON = 7,

    TEDU_BOARD_MATHGRAPH_VECTOR = 8,

    TEDU_BOARD_MATHGRAPH_ELLIPSE = 9,

    TEDU_BOARD_MATHGRAPH_CUBE = 101,

    TEDU_BOARD_MATHGRAPH_CYLINDER = 102,

    TEDU_BOARD_MATHGRAPH_CIRCULAR_CONE = 103,

};


enum TEduBoardClassGroupOperationType {

    TEDU_BOARD_GOT_SET_ENABLE = 0,

    TEDU_BOARD_GOT_UPDATE = 1,

    TEDU_BOARD_GOT_DELETE = 2,

    TEDU_BOARD_GOT_RESET = 3,

    TEDU_BOARD_GOT_ERROR = 4,

};


enum TEduBoardLogLevel {

    TEDU_BOARD_LOG_LEVEL_ALL = 0,

    TEDU_BOARD_LOG_LEVEL_INFO = 1,

    TEDU_BOARD_LOG_LEVEL_WARNING = 2,

    TEDU_BOARD_LOG_LEVEL_ERROR = 3,

    TEDU_BOARD_LOG_LEVEL_OFF = 4,

};


enum TEduBoardFileType {

    TEDU_FT_WHITEBOARD = 1,

    TEDU_FT_H5_COURSEWARE = 2,

    TEDU_FT_IMAGE_COURSEWARE = 3,

    TEDU_FT_VIDEO_FILE = 4,

    TEDU_FT_H5_FILE = 5,

    TEDU_FT_IMAGES_FILE = 6,

};


enum TEduBoardRemoteCursorActionType {

    TEDU_RECUR_MOVING = 0,

    TEDU_RECUR_DRAWING = 1,

};


enum TEduBoardMathToolType {

    TEDU_MATHTOOL_RULER = 1,

    TEDU_MATHTOOL_TRIANGLE = 2,

    TEDU_MATHTOOL_ISOSCELES_TRIANGLE = 3,

    TEDU_MATHTOOL_PROTRACTOR = 4,

    TEDU_MATHTOOL_COMPASSES = 5,

};


enum TEduElementOperatorType {

    TEDU_EOP_BOARDER_COLOR = 1,

    TEDU_EOP_BOARDER_WIDTH = 2,

    TEDU_EOP_BOARDER_LINE_TYPE = 3,

    TEDU_EOP_EL_DELETE = 4,

    TEDU_EOP_CHANGE_POSITION = 5,

    TEDU_EOP_CHANGE_TEXT_SIZE = 6,

    TEDU_EOP_CONTENT = 8,

    TEDU_EOP_OPACITY = 9,

};


enum TEduPermissionType {

    TEDU_PERMISSION_FILE = 1,

    TEDU_PERMISSION_ELEMENT = 2,

    TEDU_PERMISSION_BOARD = 3,

    TEDU_PERMISSION_BACKGROUND = 4,

};


enum TEduPermissionFileSubType {

    TEDU_PERMISSION_FILE_ADD = 1,

    TEDU_PERMISSION_FILE_DELETE = 2,

};


enum TEduPermissionElementSubType {

    TEDU_PERMISSION_ELEMENT_ADD = 1,

    TEDU_PERMISSION_ELEMENT_DELETE = 2,

    TEDU_PERMISSION_ELEMENT_MOVE = 3,

    TEDU_PERMISSION_ELEMENT_SELECT = 4,

    TEDU_PERMISSION_ELEMENT_UPDATE = 5,

    TEDU_PERMISSION_ELEMENT_SCALE = 6,

    TEDU_PERMISSION_ELEMENT_ROTATE = 7,

};


enum TEduPermissionElementAttrType {

    TEDU_PERMISSION_ELEMENT_ADD_CUSTOMGRAPH = 1,

    TEDU_PERMISSION_ELEMENT_ADD_GRAPH = 2,

    TEDU_PERMISSION_ELEMENT_ADD_HIGHLIGHTER = 3,

    TEDU_PERMISSION_ELEMENT_ADD_LASER = 4,

    TEDU_PERMISSION_ELEMENT_ADD_PEN = 5,

    TEDU_PERMISSION_ELEMENT_ADD_TEXT = 6,

    TEDU_PERMISSION_ELEMENT_ADD_MATHTOOL = 7,

    TEDU_PERMISSION_ELEMENT_ADD_ALL = 8,

};


enum TEduPermissionBoardSubType {

    TEDU_PERMISSION_BOARD_ADD = 1,

    TEDU_PERMISSION_BOARD_DELETE = 2,

    TEDU_PERMISSION_BOARD_SWITCH = 3,

};


enum TEduPermissionBoardAttrType {

    TEDU_PERMISSION_BOARD_SWITCH_STEP = 1,

    TEDU_PERMISSION_BOARD_SWITCH_PAGE = 2,

    TEDU_PERMISSION_BOARD_SWITCH_ALL = 3,

};


enum TEduPermissionBackgroundSubType {

    TEDU_PERMISSION_BACKGROUND_UPDATE = 1,

};


enum TEduPermissionBackgroundAttrType {

    TEDU_PERMISSION_BACKGROUND_UPDATE_COLOR = 1,

    TEDU_PERMISSION_BACKGROUND_UPDATE_FRAME = 2,

    TEDU_PERMISSION_BACKGROUND_UPDATE_IMAGE = 3,

};


struct TEduBoardPermissionParam {

    int     modeType;

    TEduPermissionType perFirstType;


    TEduPermissionBoardSubType boardSecondType;

    TEduPermissionFileSubType fileSecondType;

    TEduPermissionElementSubType elementSecondType;

    TEduPermissionBackgroundSubType backgroundSecondType;


    TEduPermissionElementAttrType elementThirdType;

    TEduPermissionBoardAttrType boardThirdType;


    const char* permissionSource;


    TEduBoardPermissionParam()

        : modeType(0),

        perFirstType(TEDU_PERMISSION_FILE),

        boardSecondType(TEDU_PERMISSION_BOARD_ADD),

        elementSecondType(TEDU_PERMISSION_ELEMENT_ADD),

        backgroundSecondType(TEDU_PERMISSION_BACKGROUND_UPDATE),

        elementThirdType(TEDU_PERMISSION_ELEMENT_ADD_ALL),

        boardThirdType(TEDU_PERMISSION_BOARD_SWITCH_ALL),

        permissionSource(nullptr)

    {


    }

};


struct TEduBoardAuthParam {

    uint32_t sdkAppId;

    const char* userId;

    const char* userSig;


    TEduBoardAuthParam()

        : sdkAppId(0), userId(nullptr), userSig(nullptr) {


    }


    TEduBoardAuthParam(uint32_t sdkAppId, const char* userId, const char* userSig)

        : sdkAppId(sdkAppId), userId(userId), userSig(userSig) {


    }

};


struct TEduBoardColor {

    uint8_t red = 0;

    uint8_t green = 0;

    uint8_t blue = 0;

    uint8_t alpha = 0;


    TEduBoardColor()

        : red(0), green(0), blue(0), alpha(0) {


    }


    TEduBoardColor(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha)

        : red(red), green(green), blue(blue), alpha(alpha) {


    }

};


struct TEduRoutineConfig {

    const char* proxyServer;

    const char* ratio;

    const char* progressBarUrl;


    uint32_t preloadDepth;

    uint32_t scale;

    uint32_t syncFps;

    uint32_t scaleRangeBegin;

    uint32_t scaleRangeEnd;

    uint32_t offlineWarningTimeout;

    uint32_t imageTimeout;

    uint32_t h5PPTLoadTimeout;

    uint32_t h5PPTResourceTimeout;


    TEduBoardToolType toolType;

    TEduBoardContentFitMode boardContentFitMode;


    TEduRoutineConfig()

        : proxyServer(nullptr),

        ratio("16:9"),

        progressBarUrl(nullptr),

        preloadDepth(5),

        scale(100),

        syncFps(5),

        scaleRangeBegin(100),

        scaleRangeEnd(1600),

        offlineWarningTimeout(180),

        imageTimeout(10),

        h5PPTLoadTimeout(10),

        h5PPTResourceTimeout(10),

        toolType(TEDU_BOARD_TOOL_TYPE_PEN),

        boardContentFitMode(TEDU_BOARD_CONTENT_FIT_MODE_NONE) {

    }


};


struct TEduUserConfig {

    const char* nickname;


    TEduUserConfig()

        :nickname(nullptr) {

    }

};


struct TEduBackgroundImage {

    TEduBoardImageFitMode mode;

    int type;

    const char* url;

    float angle;


    TEduBackgroundImage()

        :mode(TEDU_BOARD_IMAGE_FIT_MODE_CENTER),

        type(0),

        url(nullptr),

        angle(0) {


    }

};


struct TEduStyleConfig {

    TEduBoardColor textColor;

    TEduBoardColor brushColor;

    TEduBoardColor globalBackgroundColor;

    TEduBoardColor selectBoxColor;

    TEduBoardColor windowBackgroundColor;


    TEduBoardTextStyle  textStyle;


    uint32_t textSize;

    uint32_t  brushThin;


    TEduBackgroundImage globalBackgroundImage;


    TEduStyleConfig()

        : textColor(0, 0, 0, 255),

        brushColor(255, 0, 0, 255),

        globalBackgroundColor(255, 255, 255, 255),

        selectBoxColor(255, 0, 0, 255),

        windowBackgroundColor(0, 0, 0, 0),

        textStyle(TEDU_BOARD_TEXT_STYLE_NORMAL),

        textSize(320),

        brushThin(100) {

    }

};


struct TEduElementOperationAuthority {

    bool enableThisConfig;

    bool disableRotate;

    bool disableMove;

    bool disableProportionScale;

    bool disableArbitraryScale;

    bool disableUseEmoji;


    TEduElementOperationAuthority()

        : enableThisConfig(false),

        disableRotate(false),

        disableMove(false),

        disableProportionScale(false),

        disableArbitraryScale(false),

        disableUseEmoji(false) {


    }

};


struct TEduMouseToolBehavior {

    bool whiteBoard;

    bool h5PPT;

    bool imgPPT;

    bool imgFile;


    TEduMouseToolBehavior()

        : whiteBoard(true),

        h5PPT(true),

        imgPPT(true),

        imgFile(true) {

    }

};


struct TEduRemoteCursorVisible {

    bool drawing;

    bool moving;


    TEduRemoteCursorVisible()

        : drawing(true),

        moving(true){

    }

};


struct TEduAuthConfig {

    bool drawEnable;

    bool dataSyncEnable;

    bool progressEnable;

    bool systemCursorEnable;

    bool enableScaleTool;

    bool isAutoHideRemoteCursor;

    bool showRemoteSelectBox;

    bool showLocalOperator;

    bool showRemoteOperator;

    bool mathGraphEnable;

    bool formulaEnable;

    bool customCursorIcon;


    TEduRemoteCursorVisible remoteCursorVisible;

    TEduElementOperationAuthority line;

    TEduElementOperationAuthority graph;

    TEduElementOperationAuthority text;

    TEduElementOperationAuthority formula;

    TEduElementOperationAuthority watermark;

    TEduElementOperationAuthority customGraph;

    TEduElementOperationAuthority image;

    TEduElementOperationAuthority h5;

    TEduElementOperationAuthority mathTool;

    TEduElementOperationAuthority audio;

    TEduElementOperationAuthority mathBoard;

    TEduElementOperationAuthority magicLine;

    TEduMouseToolBehavior turnPage;


    TEduAuthConfig()

        :drawEnable(true),

        dataSyncEnable(true),

        progressEnable(false),

        systemCursorEnable(false),

        enableScaleTool(true),

        isAutoHideRemoteCursor(false),

        showRemoteSelectBox(false),

        showLocalOperator(false),

        showRemoteOperator(false),

        mathGraphEnable(false),

        formulaEnable(false),

        customCursorIcon(false){


    }

};


struct TEduCustomServerConfig {

  const char *serverHost;

  const char *serverPath;

  const char *resourceHost;

  const char *token;


  TEduCustomServerConfig()

      : serverHost(nullptr),

        serverPath(nullptr),

        resourceHost(nullptr),

        token(nullptr)

      {

  }

};


struct TEduBoardInitParam {

    const char* userId;

    const char* userSig;

    const char* id;

    const char* experimental;


    bool timSync;

    bool trtcSync;

    uint32_t imageTimeout;


    uint32_t            classId;

    uint32_t           sdkAppId;


    TEduRoutineConfig config;

    TEduUserConfig userConfig;

    TEduStyleConfig styleConfig;

    TEduAuthConfig authConfig;

    TEduCustomServerConfig customServerConfig;


    bool audioCallback;


    TEduBoardInitParam()

        : userId(nullptr),

          userSig(nullptr),

          id("board"),

          experimental(nullptr),

          timSync(true),

          trtcSync(false),

          imageTimeout(10),

          classId(0),

          sdkAppId(0),

          config(),

          userConfig(),

          styleConfig(),

          authConfig(),

          customServerConfig(),

          audioCallback(false){


    }

};


struct TEduBoardLineStyle {

    TEduBoardLineType lineType;

    TEduBoardArrowType startArrowType;

    TEduBoardArrowType endArrowType;


    TEduBoardLineStyle()

        : lineType(TEDU_BOARD_LINE_TYPE_SOLID), startArrowType(TEDU_BOARD_ARROW_TYPE_NONE), endArrowType(TEDU_BOARD_ARROW_TYPE_NONE) {


    }

};


struct TEduBoardCursorIcon {

    const char* cursor;

    const char* url;

    uint32_t offsetX;

    uint32_t offsetY;


    TEduBoardCursorIcon()

        : cursor("none"), url(nullptr), offsetX(0), offsetY(0) {


    }

};


struct TEduBoardToolTypeTitleStyle {

    TEduBoardPosition position;

    TEduBoardColor color;

    uint32_t size;

    TEduBoardTextStyle style;


    TEduBoardToolTypeTitleStyle()

        : position(TEDU_BOARD_POSITION_RIGHT_TOP), color(), size(100), style(TEDU_BOARD_TEXT_STYLE_NORMAL) {


    }

};


struct TEduBoardElementOptions {

    bool erasable;

    const char* left;

    const char* top;

    const char* title;


    TEduBoardElementOptions()

        : erasable(true),

        left(nullptr),

        top(nullptr),

        title(nullptr){


    }

};


struct TEduBoardSnapshotInfo {

    const char* path;

    bool full;


    TEduBoardSnapshotInfo()

        : path(nullptr),

          full(false) {


    }

};


struct TEduBoardTranscodeConfig {

    const char* minResolution;

    bool isStaticPPT;

    const char* thumbnailResolution;


    TEduBoardTranscodeConfig()

        : minResolution(nullptr), isStaticPPT(false), thumbnailResolution(nullptr) {

    }

};


struct TEduBoardTranscodeFileResult {

    char taskId[32];

    TEduBoardFileTranscodeStatus status;

    double progress;

    char title[256];

    char resolution[32];

    uint32_t pages;

    char url[1024];

    char thumbnailResolution[32];

    char thumbnailUrl[1024];


    TEduBoardTranscodeFileResult()

        : taskId(), status(TEDU_BOARD_FILE_TRANSCODE_CREATED), progress(0), title(), resolution(), pages(0), url(), thumbnailResolution(), thumbnailUrl() {

    }

};


struct TEduBoardInfo {

    const char* boardId;

    const char* backgroundUrl;

    TEduBoardColor backgroundColor;


    TEduBoardInfo()

        : boardId(nullptr), backgroundUrl(nullptr) {


    }


    TEduBoardInfo(const char* boardId, const char* backgroundUrl, TEduBoardColor backgroundColor)

        : boardId(boardId), backgroundUrl(backgroundUrl), backgroundColor(backgroundColor) {


    }

};


struct TEduAddBoardBase {

    TEduAddBoardBase(){


    }

};


struct TEduAddBoardElementUrl:public TEduAddBoardBase {

    const char* strUrl;

    TEduAddBoardElementUrl():strUrl(nullptr){


    }

};


struct TEduAddBoardElementMathGraph :public TEduAddBoardBase {

    const char* mathBoardId;                // 数学函数画板的元素id

    const char* expression;                 // 数学函数表达式

    TEduBoardColor  color;                  // 数学函数图像颜色

    TEduBoardColor  selectedColor;          // 数学函数图像选中时的颜色


    TEduAddBoardElementMathGraph()

        :mathBoardId(nullptr),

        expression(nullptr),

        color(255, 255, 255, 255),

        selectedColor(255, 255, 0, 255) {

    }

};


struct TEduAddBoardElementMathBoard :public TEduAddBoardBase {

    bool showControl;

    bool enableZoom;

    bool enablePan;

    bool axis;

    bool grid;


    int leftX;

    int leftY;

    int rightX;

    int rightY;


    const char* width;

    const char* height;


    TEduBoardColor axisColor;


    TEduAddBoardElementMathBoard()

        :showControl(true),

        enableZoom(false),

        enablePan(false),

        axis(true),

        grid(true),

        leftX(0),

        leftY(0),

        rightX(0),

        rightY(0),

        width(nullptr),

        height(nullptr),

        axisColor(255,255,255,255){


    }

};


struct TEduAddBoardElementWaterMark :public TEduAddBoardBase {

    const char* content;

    const char* left;

    const char* top;

    const char* width;

    const char* height;

    TEduBoardColor color;

    const char* textSize;

    double opacity;

    double deg;

    uint32_t interval;

    bool fix;


    TEduAddBoardElementWaterMark()

        :content(nullptr),

        left(nullptr),

        top(nullptr),

        width(nullptr),

        height(nullptr),

        color(255, 0, 0, 255),

        textSize(nullptr),

        opacity(0),

        deg(0),

        interval(0),

        fix(true){

    }

};


struct TEduScrollPosition {

    double scrollLeft;

    double scrollTop;

    TEduScrollPosition() :scrollLeft(0), scrollTop(0){


    }

};


struct TEduAddBoardElementFormula :public TEduAddBoardBase {

    const char* expression;

    TEduBoardColor fontColor;

    uint32_t fontSize;

    TEduAddBoardElementFormula()

        :expression(nullptr),

        fontColor(255, 255, 255, 255),

        fontSize(200) {


    }

};


struct TEduAddBoardElementText :public TEduAddBoardBase {

    const char* textContent;

    const char* fontFace;

    TEduBoardTextStyle fontStyle;

    TEduBoardColor fontColor;

    uint32_t fontSize;


    TEduAddBoardElementText()

        :textContent(nullptr),

        fontFace(nullptr),

        fontStyle(TEDU_BOARD_TEXT_STYLE_NORMAL),

        fontColor(255, 255, 255, 255),

        fontSize(200){


    }

};


class TEduBoardInfoList {

protected:

    virtual ~TEduBoardInfoList() {};


public:

    virtual uint32_t GetCount() const = 0;


    virtual TEduBoardInfo GetBoardInfo(uint32_t index) const = 0;

};


struct TEduBoardSelectedElementInfo {

public:

    const char *elementId;

    const char *title;

    TEduBoardElementType type;

    int left;

    int top;

    int width;

    int height;

    double  rotate;

    bool locked;

    int boundingBoxLeft;

    int boundingBoxTop;

    int boundingBoxWidth;

    int boundingBoxHeight;


    TEduBoardSelectedElementInfo()

        : elementId(nullptr),

          title(nullptr),

          type(TEDU_BOARD_ELEMENT_IMAGE),

          left(0),

          top(0),

          width(0),

          height(0),

          rotate(0.0),

          locked(false),

          boundingBoxLeft(0),

          boundingBoxTop(0),

          boundingBoxWidth(0),

          boundingBoxHeight(0) {

    }

};


class TEduBoardSelectedElementInfoList {

protected:

    virtual ~TEduBoardSelectedElementInfoList() {};


public:

    virtual uint32_t GetCount() const = 0;


    virtual TEduBoardSelectedElementInfo GetBoardSelectedElementInfo(uint32_t index) const = 0;


    virtual void Release() = 0;

};


struct TEduBoardElementInfo {

    const char* boardId;

    const char* elementId;

    TEduBoardElementType type;

    const char* url;

    bool show;


    TEduBoardElementInfo()

        : boardId(nullptr), elementId(nullptr), type(TEDU_BOARD_ELEMENT_IMAGE), url(nullptr), show(false) {


    }


    TEduBoardElementInfo(const char* boardId, const char* elementId, TEduBoardElementType type, const char* url, bool show)

        : boardId(boardId), elementId(elementId), type(type), url(url), show(show) {


    }

};


class TEduBoardElementInfoList {

protected:

    virtual ~TEduBoardElementInfoList() {};


public:

    virtual uint32_t GetCount() const = 0;


    virtual TEduBoardElementInfo GetElementInfo(uint32_t index) const = 0;


    virtual void Release() = 0;

};


struct TEduBoardFileInfo {

    const char* fileId;

    const char* title;

    const char* downloadUrl;

    uint32_t pageIndex;

    uint32_t pageCount;

    TEduBoardFileType fileType;

    const TEduBoardInfoList* boardInfoList;


    TEduBoardFileInfo()

        : fileId(nullptr), title(nullptr), downloadUrl(nullptr), pageIndex(0), pageCount(0), fileType(TEDU_FT_WHITEBOARD), boardInfoList(nullptr) {


    }


    TEduBoardFileInfo(const char* fileId, const char* title, const char* downloadUrl, uint32_t pageIndex, uint32_t pageCount, TEduBoardFileType fileType, TEduBoardInfoList* boardInfoList)

        : fileId(fileId), title(title), downloadUrl(downloadUrl), pageIndex(pageIndex), pageCount(pageCount), fileType(fileType), boardInfoList(boardInfoList) {


    }

};


struct TEduBoardKeyEvent {

    TEduBoardKeyEventType type;

    uint32_t modifiers;

    int windowsKeyCode;

    int nativeKeyCode;

    int isSystemKey;

    wchar_t character;

    wchar_t unmodifiedCharacter;

    int focusOnEditableField;


    TEduBoardKeyEvent()

        : type(TEDU_BOARD_KEYEVENT_RAWKEYDOWN), modifiers(0), windowsKeyCode(0), nativeKeyCode(0), isSystemKey(0), character(' '), unmodifiedCharacter(' '), focusOnEditableField(0) {


    }

};


struct TEduBoardMouseEvent {

    int x;

    int y;

    uint32_t modifiers;


    TEduBoardMouseEvent()

        : x(0), y(0), modifiers(0) {


    }

};


struct TEduBoardTouchEvent {

    int id;

    float x;

    float y;

    float radiusX;

    float radiusY;

    float rotationAngle;

    float pressure;

    TEduBoardTouchEventType

        type;

    uint32_t modifiers;

    TEduBoardPointType pointerType;


    TEduBoardTouchEvent()

        : id(-1), x(0), y(0), radiusX(0), radiusY(0), rotationAngle(0), pressure(0), type(TEDU_BOARD_TOUCHEVENT_CANCELLED), modifiers(0), pointerType(TEDU_BOARD_POINTER_TYPE_UNKNOWN) {


    }

};


struct TEduBoardRect {

    int32_t x;

    int32_t y;

    int32_t width;

    int32_t height;

};


struct TEduUserInfo {

    const char* nickname;

    TEduUserInfo() :nickname(nullptr) {


    }

};


class TEduBoardFileInfoList {

protected:

    virtual ~TEduBoardFileInfoList() {};


public:

    virtual uint32_t GetCount() const = 0;


    virtual TEduBoardFileInfo GetFileInfo(uint32_t index) const = 0;


    virtual void Release() = 0;

};


class TEduBoardStringList {

protected:

    virtual ~TEduBoardStringList() {};


public:

    virtual uint32_t GetCount() const = 0;


    virtual const char* GetString(uint32_t index) const = 0;


    virtual void Release() = 0;

};


struct TEduBoardRemarkInfo {

    const char* boardId;

    const char* remark;


    TEduBoardRemarkInfo()

        : boardId(nullptr), remark(nullptr) {


    }


    TEduBoardRemarkInfo(const char* boardId, const char* remark)

        : boardId(boardId), remark(remark) {


    }

};


class TEduBoardRemarkInfoList {

protected:

    virtual ~TEduBoardRemarkInfoList() {};


public:

    virtual uint32_t GetCount() const = 0;


    virtual TEduBoardRemarkInfo GetBoardRemarkInfo(uint32_t index) const = 0;


    virtual void Release() = 0;

};


struct TEduPPtRemarkInfo {

    int pageIndex;

    const char* remark;


    TEduPPtRemarkInfo()

        : pageIndex(0), remark(nullptr) {


    }


    TEduPPtRemarkInfo(const int pageIndex, const char* remark)

        : pageIndex(pageIndex), remark(remark) {


    }

};


class TEduPPtRemarkInfoList {

protected:

    virtual ~TEduPPtRemarkInfoList() {};


public:

    virtual uint32_t GetCount() const = 0;


    virtual TEduPPtRemarkInfo GetPPtRemarkInfo(uint32_t index) const = 0;


    virtual void Release() = 0;

};


struct TEduBoardClassGroupInfo {

    const char* classGroupId;

    const char* currentBoardId;

    const char* title;

    const TEduBoardStringList* boardIdList;

    const TEduBoardStringList* userIdList;


    TEduBoardClassGroupInfo()

        : classGroupId(nullptr),

        currentBoardId(nullptr),

        title(nullptr),

        boardIdList(nullptr),

        userIdList(nullptr){


    }


    TEduBoardClassGroupInfo(const char* classGroupId, const char* currentBoardId, const char* title, TEduBoardStringList* boardIdList, TEduBoardStringList* userIdList)

        : classGroupId(classGroupId), currentBoardId(currentBoardId), title(title), boardIdList(boardIdList), userIdList(userIdList) {


    }

};


struct TEduBoardStyleObject {

    TEduElementOperatorType operatorType;

    int sizeValueType;

    const char* styleStrValue;

    int styleIntValue;

    float styleFloatValue;

    TEduBoardColor colorValue;

    int offsetX;

    int offsetY;


    TEduBoardStyleObject()

        : operatorType(TEDU_EOP_BOARDER_COLOR),

        sizeValueType(0),

        styleStrValue(nullptr),

        styleIntValue(0),

        styleFloatValue(0),

        colorValue(),

        offsetX(0),

        offsetY(0){


    }


    TEduBoardStyleObject(TEduElementOperatorType operatorType, const char* styleStrValue, int styleIntValue,TEduBoardColor colorValue, int offsetX, int offsetY)

        : operatorType(operatorType), styleStrValue(styleStrValue), styleIntValue(styleIntValue), colorValue(colorValue), offsetX(offsetX), offsetY(offsetY){


    }

};


struct TEduBoardGraphStyle {

    TEduBoardLineType eLineType;

    TEduBoardFillType eFillType;

    TEduBoardArrowType eStartArrow;

    TEduBoardArrowType eEndArrow;


    TEduBoardGraphStyle()

        : eLineType(TEDU_BOARD_LINE_TYPE_SOLID),

        eFillType(TEDU_BOARD_FILL_NONE),

        eStartArrow(TEDU_BOARD_ARROW_TYPE_NONE),

        eEndArrow(TEDU_BOARD_ARROW_TYPE_NONE) {


    }


    TEduBoardGraphStyle(TEduBoardLineType eLineType, TEduBoardFillType eFillType, TEduBoardArrowType eStartArrow, TEduBoardArrowType eEndArrow)

        : eLineType(eLineType), eFillType(eFillType), eStartArrow(eStartArrow), eEndArrow(eEndArrow) {


    }

};


struct TEduBoardCallback {


    virtual void onTEBError(TEduBoardErrorCode code, const char* msg) = 0;


    virtual void onTEBWarning(TEduBoardWarningCode code, const char* msg) = 0;


    virtual void onTEBInit() = 0;


    virtual void onTEBHistroyDataSyncCompleted() {};


    virtual void onTEBSyncData(const char* data) {};


    virtual void onTEBUndoStatusChanged(bool canUndo) {};


    virtual void onTEBRedoStatusChanged(bool canRedo) {};


    virtual void onTEBRectSelected() {};


    virtual void onTEBRefresh() {};


    virtual void onTEBOffscreenPaint(const void* buffer, uint32_t width, uint32_t height, const TEduBoardRect* dirtyRects, uint32_t dirtyRectCount) {};


#ifdef AUDIO_HANDLER_SUPPORT


    virtual void onTEBAudioCallbackStarted(uint32_t channels, uint32_t channelSize, uint32_t sampleRate) {};


    virtual void onTEBAudioCallbackPacket(const float** buffer, int64_t pts) {};


    virtual void onTEBAudioCallbackStopped() {};

#endif


    virtual void onTEBImageStatusChanged(const char* boardId, const char* url, TEduBoardImageStatus status) {};


    virtual void onTEBSetBackgroundImage(const char* url) {};


    virtual void onTEBAddImageElement(const char* url) {};


    virtual void onTEBAddElement(const char* elementId, const char* url,const TEduBoardElementType type) {};


    virtual void onTEBRemoveElement(const TEduBoardStringList* elementIds) {}


    virtual void onTEBElementLockedChanged(const TEduBoardStringList* elementIds, bool locked) {}


    virtual void onTEBBackgroundH5StatusChanged(const char* boardId, const char* url, TEduBoardBackgroundH5Status status) {};


    virtual void onTEBAddBoard(const TEduBoardStringList* boardList, const char* fileId) {};


    virtual void onTEBDeleteBoard(const TEduBoardStringList* boardList, const char* fileId) {};


    virtual void onTEBGotoBoard(const char* boardId, const char* fileId, const char *userId) {};


    virtual void onTEBGotoStep(uint32_t currentStep, uint32_t totalStep) {};


    virtual void onTEBSnapshot(const char* path) {};


    virtual void onTEBImportInLocalModeCompleted() {};


    virtual void onTEBFileTranscodeProgress(const char* path, const char* errorCode, const char* errorMsg, const TEduBoardTranscodeFileResult& result) {};


    virtual void onTEBAddTranscodeFile(const char* fileId) {};


    virtual void onTEBAddImagesFile(const char* fileId) {};


    virtual void onTEBVideoStatusChanged(const char* fileId, TEduBoardVideoStatus status, double progress, double duration) {};


    virtual void onTEBAudioStatusChanged(const char* elementId, TEduBoardAudioStatus status, double progress, double duration) {};


    virtual void onTEBH5FileStatusChanged(const char* fileId, TEduBoardH5FileStatus status) {};


    virtual void onTEBH5PPTStatusChanged(const char* fileId, TEduBoardH5PPTStatus status, const char* message) {};


    virtual void onTEBH5PPTMediaStatusChanged(const char* fileId, const char* mediaId, TEduBoardH5PPTMediaStatus status) {};


    virtual void onTEBDeleteFile(const char* fileId) {};


    virtual void onTEBSwitchFile(const char* fileId) {};


    virtual void onTEBFileUploadProgress(const char* path, int currentBytes, int totalBytes, int uploadSpeed, double percent) {};


    virtual void onTEBFileUploadStatus(const char* path, TEduBoardUploadStatus status, int errorCode, const char* errorMsg) {};


    virtual void onTEBOfflineWarning(int count) {};


    // version 2.6.1

    virtual void onTEBTextElementStatusChanged(const char* status, const char* id, const char* value, double left, double top) {};


    virtual void onTEBImageElementStatusChanged(const char* boardId, const char* url, const char* elementId, TEduBoardImageStatus status) {};


    virtual void onTEBTextElementWarning(const char* message, TEduBoardTextComponentStatus code) {};


    virtual void onTEBSelectedElements(const TEduBoardSelectedElementInfoList &selElementList) {};


    virtual void onTEBMathGraphEvent(const char* boardId, const char* graphId, const char* message, TEduBoardMathGraphCode code) {};


    virtual void onTEBZoomDragStatus(const char* fid, int32_t scale, int32_t xOffset, int32_t yOffset) {};


    virtual void onTEBGroupStatusChanged(bool enable, const char* classGroupId, TEduBoardClassGroupOperationType operationType, const char* message) {};


    virtual void onTEBBoardScrollChanged(const char* boardId, int trigger, double scrollLeft, double scrollTop, int scale) {};


    virtual void onTEBBoardCursorPosition(int x, int y) {};


    virtual void onTEBBoardFirstFrameRendered() {};


    virtual void onTEBElementsPositionChange(const TEduBoardSelectedElementInfoList &positionChangeElementList, TEduBoardPositionChangeStatus status) {};


    virtual void onTEBPermissionChange(const TEduBoardStringList &permissionList, const TEduBoardStringList &operatorList, const TEduBoardStringList &creatorList) {};


    virtual void onTEBPermissionDeinedData(const char* data) {};


};


class TEduBoardController {

protected:

    virtual ~TEduBoardController() = default;;


public:


    virtual void AddCallback(TEduBoardCallback* callback) = 0;


    virtual void RemoveCallback(TEduBoardCallback* callback) = 0;


    virtual void Init(const TEduBoardInitParam& initParam = TEduBoardInitParam()) = 0;


    virtual WINDOW_HANDLE GetBoardRenderView() = 0;


    virtual void Refresh() = 0;


    virtual void SyncAndReload() = 0;


    virtual void AddSyncData(const char* data) = 0;


    virtual void SetDataSyncEnable(bool enable) = 0;


    virtual bool IsDataSyncEnable() = 0;


    virtual void Reset() = 0;


    virtual const char* ExportInLocalMode(const char *filter = nullptr) = 0;


    virtual void ImportInLocalMode(const char* data, const char *filter = nullptr) = 0;


    virtual void SetBoardRenderViewPos(int32_t x, int32_t y, uint32_t width, uint32_t height) = 0;


    virtual uint64_t GetSyncTime() = 0;


    virtual void SyncRemoteTime(const char* userId, uint64_t timestamp) = 0;


    virtual void SetSystemCursorEnable(bool enable) = 0;


    virtual void AddBackupDomain(const char* domain, const char* backup, uint32_t priority = 0) = 0;


    virtual void RemoveBackupDomain(const char* domain, const char* backup) = 0;


    virtual void SetProxyServer(const char* settingStr) = 0;


    virtual const char* CallExperimentalAPI(const char* apiExp) = 0;


    virtual void SendKeyEvent(const TEduBoardKeyEvent& event) = 0;


    virtual void SendMouseClickEvent(const TEduBoardMouseEvent& event, TEduBoardMouseButtonType type, bool mouseUp, int clickCount) = 0;


    virtual void SendMouseMoveEvent(const TEduBoardMouseEvent& event, bool mouseLeave) = 0;


    virtual void SendMouseWheelEvent(const TEduBoardMouseEvent& event, int deltaX, int deltaY) = 0;


    virtual void SendTouchEvent(const TEduBoardTouchEvent& event) = 0;


    virtual void SetDrawEnable(bool enable) = 0;


    virtual bool IsDrawEnable() = 0;


    virtual void SetHandwritingEnable(bool enable) = 0;


    virtual bool IsHandwritingEnable() = 0;


    virtual void SetEraseLayerLimit(uint32_t limit = 0) = 0;


    virtual void SetEraseLayerType(const TEduBoardErasableElementType* typeArr = nullptr, uint32_t typeArrCount = 0) = 0;


    virtual void SetAccessibleUsers(char** users, uint32_t userCount, TEduBoardAccessibleOperation* operatorType, uint32_t typeCount) = 0;


    virtual void SetGlobalBackgroundColor(const TEduBoardColor& color) = 0;


    virtual TEduBoardColor GetGlobalBackgroundColor() = 0;


    virtual void SetBackgroundColor(const TEduBoardColor& color) = 0;


    virtual TEduBoardColor GetBackgroundColor() = 0;


    virtual void SetToolType(TEduBoardToolType type) = 0;


    virtual TEduBoardToolType GetToolType() = 0;


    virtual void SetToolTypeTitle(const char* title, const TEduBoardToolTypeTitleStyle* style, TEduBoardToolType type) = 0;


    virtual void SetCursorIcon(TEduBoardToolType type, const TEduBoardCursorIcon& icon) = 0;


    virtual void SetBrushColor(const TEduBoardColor& color) = 0;


    virtual TEduBoardColor GetBrushColor() = 0;


    virtual void SetBrushThin(uint32_t thin) = 0;


    virtual uint32_t GetBrushThin() = 0;


    virtual void SetTextColor(const TEduBoardColor& color) = 0;


    virtual TEduBoardColor GetTextColor() = 0;


    virtual void SetTextSize(uint32_t size) = 0;


    virtual uint32_t GetTextSize() = 0;


    virtual void SetTextStyle(TEduBoardTextStyle style) = 0;


    virtual TEduBoardTextStyle GetTextStyle() = 0;


    virtual void SetLineStyle(const TEduBoardLineStyle& style) = 0;


    virtual TEduBoardLineStyle GetLineStyle() = 0;


    virtual void SetOvalDrawMode(TEduBoardOvalDrawMode drawMode) = 0;


    virtual TEduBoardOvalDrawMode GetOvalDrawMode() = 0;


    virtual void Clear(bool clearBackground = false, bool clearSelectedOnly = false) = 0;


    virtual void SetBackgroundImage(const char* url, TEduBoardImageFitMode mode) = 0;


    virtual TEduBackgroundImage GetBackgroundImage(const char* boardId = nullptr) = 0;


    virtual void SetBackgroundImageAngle(float angle) = 0;


    virtual void SetBackgroundH5(const char* url) = 0;


    virtual void Undo() = 0;


    virtual void Redo() = 0;


    virtual const char* AddBoard(const char* url = nullptr, const TEduBoardImageFitMode mode = TEDU_BOARD_IMAGE_FIT_MODE_CENTER, const TEduBoardBackgroundType type= TEDU_BOARD_BACKGROUND_IMAGE, bool needSwitch = true) = 0;


    virtual void AddImageElement(const char* url) = 0;


    virtual const char* AddElement(TEduBoardElementType type, TEduAddBoardBase* pTag, const TEduBoardElementOptions& options = TEduBoardElementOptions()) = 0;


    virtual bool RemoveElement(const char* elementId) = 0;


    virtual void LockElements(const char** elementIds, uint32_t idsCount, bool locked) = 0;


    virtual TEduBoardElementInfoList* GetBoardElementList(const char* boardId = nullptr, bool includeHideElement = false) = 0;


    virtual void SetElementsDisplay(TEduBoardElementType *types, uint32_t typesCount, const char **ids, uint32_t idsCount, bool visible) = 0;


    virtual void DeleteBoard(const char* boardId = nullptr) = 0;


    virtual void PrevStep() = 0;


    virtual void NextStep() = 0;


    virtual void PrevBoard(bool resetStep = false) = 0;


    virtual void NextBoard(bool resetStep = false) = 0;


    virtual void GotoBoard(const char* boardId, bool resetStep = false) = 0;


    virtual const char* GetCurrentBoard() = 0;


    virtual TEduBoardStringList* GetBoardList() = 0;


    virtual void SetBoardRatio(const char* ratio) = 0;


    virtual const char* GetBoardRatio() = 0;


    virtual void SetBoardScale(uint32_t scale) = 0;


    virtual uint32_t GetBoardScale() = 0;


    virtual void SetFileScale(const char* fileId, uint32_t scale) = 0;


    virtual uint32_t GetFileScale(const char* fileId) = 0;


    virtual void SetScaleToolRatio(uint32_t scale) = 0;


    virtual void SetScaleAnchor(double xRatio, double yRation) = 0;


    virtual void SetBoardContentFitMode(TEduBoardContentFitMode mode) = 0;


    virtual TEduBoardContentFitMode GetBoardContentFitMode() = 0;


    virtual void Snapshot(const TEduBoardSnapshotInfo& info) = 0;


    virtual void SetNextTextInput(const char* input, bool focus) = 0;


    virtual void SetZoomCursorIcon(const TEduBoardCursorIcon& zoomIn, const TEduBoardCursorIcon& zoomOut) = 0;


    virtual void SetRemoteCursorVisible(bool visible, TEduBoardRemoteCursorActionType mode) = 0;


    virtual void ApplyFileTranscode(const char* path, const TEduBoardTranscodeConfig& config = TEduBoardTranscodeConfig()) = 0;


    virtual void GetFileTranscodeProgress(const char* taskId) = 0;


    virtual const char* AddTranscodeFile(const TEduBoardTranscodeFileResult& result, bool needSwitch = true) = 0;


    virtual const char* AddImagesFile(const char** urls, uint32_t urlCount, const char* title = nullptr, bool needSwitch = true) = 0;


    virtual const char* AddVideoFile(const char* url, const char* title = nullptr, bool needSwitch = true) = 0;


    virtual void ShowVideoControl(bool show) = 0;


    virtual void PlayVideo() = 0;


    virtual void PauseVideo() = 0;


    virtual void SeekVideo(double time) = 0;


    virtual void SetSyncVideoStatusEnable(bool enable) = 0;


    virtual void StartSyncVideoStatus(uint32_t interval) = 0;


    virtual void StopSyncVideoStatus() = 0;


    virtual void EnableAudioControl(bool enable) = 0;


    virtual void PlayAudio(const char* elementId) = 0;


    virtual void PauseAudio(const char* elementId) = 0;


    virtual void SeekAudio(const char* elementId, double time) = 0;


    virtual void SetAudioVolume(const char* elementId, double volume) = 0;


    virtual double GetAudioVolume(const char* elementId) = 0;


    virtual const char* AddH5File(const char* url, const char* title = nullptr, bool needSwitch = true) = 0;


    virtual void DeleteFile(const char* fileId) = 0;


    virtual void SwitchFile(const char* fileId, const char* boardId = nullptr, int32_t stepIndex = -1) = 0;


    virtual const char* GetCurrentFile() = 0;


    virtual TEduBoardFileInfo GetFileInfo(const char* fileId) = 0;


    virtual TEduBoardFileInfoList* GetFileInfoList() = 0;


    virtual TEduBoardStringList* GetFileBoardList(const char* fileId) = 0;


    virtual TEduBoardStringList* GetThumbnailImages(const char* fileId) = 0;


    virtual void ClearFileDraws(const char* fileId) = 0;


    virtual void SetUserInfo(const TEduUserInfo& userInfo) = 0;


    virtual void SetPenAutoFittingMode(const TEduBoardPenFittingMode& penMode) = 0;


    virtual void AddSnapshotMark() = 0;


    virtual void SetMouseToolBehavior(const TEduMouseToolBehavior& turnPage) = 0;


    virtual void SetMathGraphType(const TEduBoardMathGraphType &graphType, bool setMouseToolopt = true) = 0;


    virtual void SetBoardRemark(const char* boardId, const char* remark) = 0;


    virtual TEduBoardRemarkInfoList* GetBoardRemark(const char* boardId = nullptr) = 0;


    virtual void SetClassGroupEnable(bool enable) = 0;


    virtual bool GetClassGroupEnable() = 0;


    virtual void SetClassGroup(const char* groudId, char** boards, uint32_t boardCount, char** users, uint32_t userCount, const char* titleId, const char* currentBoardId = nullptr) = 0;


    virtual void ResetClassGroup() = 0;


    virtual void RemoveClassGroup(const char* groudId) = 0;


    virtual TEduBoardClassGroupInfo GetClassGroupInfoByGroupId(const char* groupId) = 0;


    virtual TEduBoardStringList* GetClassGroupIdByUserId(const char* userId) = 0;


    virtual void RemoveUserInClassGroup(const char* group, const char* userId) = 0;


    virtual void RemoveBoardInClassGroup(const char* group, const char* boardId) = 0;


    virtual void GotoClassGroupBoard(const char* boardId) = 0;


    virtual void SetClassGroupTitle(const char* groupId, const char* title) = 0;


    virtual void AddBoardToClassGroup(const char* groupId, const char* boardId) = 0;


    virtual void AddUserToClassGroup(const char* groupId, const char* userId) = 0;


    virtual TEduBoardStringList* GetAllClassGroupIds() = 0;


    virtual void SetLogLevel(const TEduBoardLogLevel& logLevel) = 0;


    virtual void SetScrollBarVisible(bool enable) = 0;


    virtual void SetTextFontFamily(const char* fontFace) = 0;


    virtual void AddTextFontFamily(const char* fontFace, const char* fontUrl) = 0;


    virtual const char* GetTextFontFamily() = 0;


    virtual void GotoStep(const char* boardId, uint32_t step) = 0;


    virtual TEduScrollPosition GetBoardScroll() = 0;


    virtual void SetPiecewiseErasureEnable(bool enable) = 0;


    virtual bool IsPiecewiseErasureEnable() = 0;


    virtual void SetEraserSize(uint32_t radius) = 0;


    virtual uint32_t GetEraserSize() = 0;


    virtual void SetGlobalBackgroundImage(const char* url, const TEduBoardImageFitMode mode, int type) = 0;


    virtual TEduBackgroundImage GetGlobalBackgroundImage() = 0;


    virtual void SoundMuteForPPT(bool mute) = 0;


    virtual void SetOwnerNickNameVisible(bool enable) = 0;


    virtual TEduPPtRemarkInfoList* GetPPtRemark(const char* fid, const int pageIndex = -1) = 0;


    virtual void UseMathTool(const TEduBoardMathToolType mathType) = 0;


    virtual TEduBoardSelectedElementInfo GetElementById(const char* elementID) = 0;


    virtual void UpdateElementById(const char* elementID, TEduBoardStyleObject &styleObj) = 0;


    virtual void SetGraphStyle(TEduBoardGraphStyle &graphStyle) = 0;


    virtual TEduBoardGraphStyle GetGraphStyle() = 0;


    virtual void EnablePenAutoFit(bool enable, int delay = 2000) = 0;


    virtual void SetHighlighterColor(const TEduBoardColor& color) = 0;


    virtual TEduBoardColor GetHighlighterColor() = 0;


    virtual void EnableMultiTouch(bool enable) = 0;


    virtual void SetSyncFps(const int iFps) = 0;


    virtual void EnableShowGraffiti(bool enable) = 0;


    virtual void EnablePermissionChecker(char** permissions, int permissionCount, char** operatorUsers, int operatorCount, char** creatorUsers, int creatorCount) = 0;


    // virtual void disablePermissionChecker(TEduBoardPermissionParam** permissionParamList, int permissionCount) = 0;

    virtual void DisablePermissionChecker(char** permissions, int permissionCount) = 0;


    virtual void ResetPermissionChecker() = 0;


    virtual void DisablePointerEventResponding(bool disable) = 0;

};