fcr-ui-scene 3.8.2 → 3.9.0-alpha

package/lib-es/modules/annotation/components/shape-picker.js

@@ -0,0 +1,193 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import "core-js/modules/es.array.includes.js";
+import "core-js/modules/es.array.map.js";
+import "core-js/modules/es.object.to-string.js";
+import { useContext, useState } from 'react';
+import { observer } from 'mobx-react';
+import classNames from 'classnames';
+import { FcrIconType } from 'agora-ui-foundation/lib/components/icon/type';
+import { useI18n } from 'agora-ui-foundation/lib/i18n';
+import { FcrIcon } from 'agora-ui-foundation/lib/components/icon';
+import { FcrToolTip } from 'agora-ui-foundation/lib/components/tooltip';
+import { ExpansionToolbarItem } from './expansion';
+import { AnnotationToolbarContext } from '../toolbar-store';
+import { FcrBoardToolType } from 'fcr-core/lib/room-control/whiteboard-control-v2/enum';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+var shapeIconMap = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, FcrBoardToolType.ARROW, FcrIconType.FCR_WHITEBOARD_SHAP_ARROW), FcrBoardToolType.ELLIPSE, FcrIconType.FCR_WHITEBOARD_SHAP_CIRCLE), FcrBoardToolType.PENTAGRAM, FcrIconType.FCR_WHITEBOARD_SHAP_STAR), FcrBoardToolType.RECTANGLE, FcrIconType.FCR_WHITEBOARD_SHAP_SQUARE), FcrBoardToolType.RHOMBUS, FcrIconType.FCR_WHITEBOARD_SHAP_REHUMBUS), FcrBoardToolType.TRIANGLE, FcrIconType.FCR_WHITEBOARD_SHAP_TRIANGLE), FcrBoardToolType.STRAIGHT, FcrIconType.FCR_WHITEBOARD_SHAP_LINE);
+export var ShapePickerItem = observer(function (_ref) {
+  var offset = _ref.offset;
+  var _useContext = useContext(AnnotationToolbarContext),
+    _useContext$observabl = _useContext.observables,
+    toolbarDockPosition = _useContext$observabl.toolbarDockPosition,
+    lastShape = _useContext$observabl.lastShape,
+    setShape = _useContext.setShape,
+    _useContext$toolbarSt = _useContext.toolbarState,
+    currentTool = _useContext$toolbarSt.currentTool,
+    strokeColor = _useContext$toolbarSt.strokeColor;
+  var transI18n = useI18n();
+  var handleShapeToolChange = function handleShapeToolChange(tool) {
+    return function () {
+      setShape(tool);
+    };
+  };
+  var isActive = !!currentTool && [FcrBoardToolType.ARROW, FcrBoardToolType.ELLIPSE, FcrBoardToolType.PENTAGRAM, FcrBoardToolType.RECTANGLE, FcrBoardToolType.RHOMBUS, FcrBoardToolType.TRIANGLE, FcrBoardToolType.STRAIGHT].includes(currentTool);
+  var icon = lastShape ? shapeIconMap[lastShape] : FcrIconType.FCR_WHITEBOARD_SHAP_CIRCLE;
+  var clickShape = lastShape ? lastShape : FcrBoardToolType.ELLIPSE;
+  return /*#__PURE__*/_jsx(ExpansionToolbarItem, {
+    isActive: isActive,
+    tooltip: transI18n('fmt_screenshare_whiteboard_button_shape'),
+    icon: icon,
+    onClick: handleShapeToolChange(clickShape),
+    tooltipPlacement: toolbarDockPosition.placement === 'left' ? 'right' : 'left',
+    popoverPlacement: toolbarDockPosition.placement === 'left' ? 'right' : 'left',
+    popoverOverlayClassName: "fcr-board-toolbar__picker__overlay",
+    popoverContent: /*#__PURE__*/_jsx(ShapePickerPanel, {}),
+    popoverOffset: offset,
+    iconProps: {
+      colors: {
+        iconPrimary: strokeColor || '#000'
+      }
+    }
+  });
+});
+var ShapePickerPanel = observer(function () {
+  var _useContext2 = useContext(AnnotationToolbarContext),
+    observables = _useContext2.observables,
+    setShape = _useContext2.setShape,
+    setStrokeWidth = _useContext2.setStrokeWidth,
+    _useContext2$toolbarS = _useContext2.toolbarState,
+    currentTool = _useContext2$toolbarS.currentTool,
+    strokeWidth = _useContext2$toolbarS.strokeWidth;
+  var t = useI18n();
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    isHover = _useState2[0],
+    setIsHover = _useState2[1];
+  var _useState3 = useState(0),
+    _useState4 = _slicedToArray(_useState3, 2),
+    hoverValue = _useState4[0],
+    setHoverValue = _useState4[1];
+  var _useState5 = useState(false),
+    _useState6 = _slicedToArray(_useState5, 2),
+    isShapeHover = _useState6[0],
+    setIsShapeHover = _useState6[1];
+  var _useState7 = useState(0),
+    _useState8 = _slicedToArray(_useState7, 2),
+    hoverShapeValue = _useState8[0],
+    setHoverShapeValue = _useState8[1];
+  var handleMouseEnter = function handleMouseEnter(value) {
+    setIsHover(true);
+    setHoverValue(value);
+  };
+  var handleMouseLeave = function handleMouseLeave() {
+    setIsHover(false);
+  };
+  var handleShapeMouseEnter = function handleShapeMouseEnter(value) {
+    setIsShapeHover(true);
+    setHoverShapeValue(value);
+  };
+  var handleShapeMouseLeave = function handleShapeMouseLeave() {
+    setIsShapeHover(false);
+  };
+  var shapes = [{
+    type: FcrBoardToolType.RECTANGLE,
+    icon: FcrIconType.FCR_WHITEBOARD_SHAP_SQUARE,
+    tip: t('fmt_whiteboard_tips_rectangle')
+  }, {
+    type: FcrBoardToolType.ELLIPSE,
+    icon: FcrIconType.FCR_WHITEBOARD_SHAP_CIRCLE,
+    tip: t('fmt_whiteboard_tips_circle')
+  }, {
+    type: FcrBoardToolType.TRIANGLE,
+    icon: FcrIconType.FCR_WHITEBOARD_SHAP_TRIANGLE,
+    tip: t('fmt_whiteboard_tips_triangle')
+  }, {
+    type: FcrBoardToolType.STRAIGHT,
+    icon: FcrIconType.FCR_WHITEBOARD_SHAP_LINE,
+    tip: t('fmt_whiteboard_tips_straight')
+  }, {
+    type: FcrBoardToolType.ARROW,
+    icon: FcrIconType.FCR_WHITEBOARD_SHAP_ARROW,
+    tip: t('fmt_whiteboard_tips_arrow')
+  }];
+  var weights = [{
+    value: 2,
+    icon: FcrIconType.FCR_PENSIZE
+  }, {
+    value: 4,
+    icon: FcrIconType.FCR_PENSIZE
+  }, {
+    value: 5,
+    icon: FcrIconType.FCR_PENSIZE
+  }, {
+    value: 6,
+    icon: FcrIconType.FCR_PENSIZE
+  }];
+  return /*#__PURE__*/_jsxs("div", {
+    className: "fcr-board-toolbar-panel fcr-board-toolbar-panel--shape",
+    children: [shapes.map(function (_ref2) {
+      var type = _ref2.type,
+        icon = _ref2.icon,
+        tip = _ref2.tip;
+      var isHoverActive = hoverValue === type && isHover;
+      var isActive = currentTool === type;
+      var cls = classNames({
+        'fcr-board-toolbar-panel--active': currentTool === type
+      });
+      var handleClick = function handleClick() {
+        setShape(type);
+      };
+      return /*#__PURE__*/_jsx(FcrToolTip, {
+        trigger: "hover",
+        content: tip,
+        placement: observables.toolbarDockPosition.placement === 'left' ? 'right' : 'left',
+        children: /*#__PURE__*/_jsx("div", {
+          className: cls,
+          onClick: handleClick,
+          onMouseEnter: function onMouseEnter() {
+            return handleMouseEnter(type);
+          },
+          onMouseLeave: handleMouseLeave,
+          children: /*#__PURE__*/_jsx(FcrIcon, {
+            type: icon,
+            size: 28,
+            colors: {
+              iconPrimary: isActive || isHoverActive ? 'var(--fcr_ui_scene_ramp_brand6)' : 'var(--fcr_ui_scene_black8)',
+              level: 2
+            }
+          })
+        })
+      }, type);
+    }), /*#__PURE__*/_jsx("div", {
+      className: "fcr-divider-vertical fcr-divider-marign-bottom"
+    }), weights.map(function (_ref3, level) {
+      var value = _ref3.value,
+        icon = _ref3.icon;
+      var isHoverActive = hoverShapeValue === value && isShapeHover;
+      var isActive = strokeWidth === value;
+      var cls = classNames({
+        'fcr-board-toolbar-panel--active': strokeWidth === value
+      });
+      var handleClick = function handleClick() {
+        setStrokeWidth(value);
+      };
+      return /*#__PURE__*/_jsx("div", {
+        className: cls,
+        onClick: handleClick,
+        onMouseEnter: function onMouseEnter() {
+          return handleShapeMouseEnter(value);
+        },
+        onMouseLeave: handleShapeMouseLeave,
+        children: /*#__PURE__*/_jsx(FcrIcon, {
+          type: icon,
+          size: 28,
+          colors: {
+            iconPrimary: isActive || isHoverActive ? 'var(--fcr_ui_scene_ramp_brand6)' : 'var(--fcr_ui_scene_black8)',
+            level: level
+          }
+        })
+      }, value);
+    })]
+  });
+});

package/lib-es/modules/annotation/hooks/index.js

@@ -0,0 +1,156 @@
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.array.map.js";
+import "core-js/modules/es.array.reverse.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.filter.js";
+import "core-js/modules/esnext.iterator.map.js";
+import { FcrIconType } from 'agora-ui-foundation/lib/components/icon/type';
+import { useI18n } from 'agora-ui-foundation/lib/i18n';
+import { FcrBoardToolType } from 'fcr-core/lib/room-control/whiteboard-control-v2/enum';
+import max from 'lodash/max';
+import min from 'lodash/min';
+import range from 'lodash/range';
+import { useContext } from 'react';
+import { ColorPickerItem } from '../components/color-picker/index';
+import { EraserPickerItem } from '../components/eraser-picker';
+import { AdditionToolPickerItem } from '../components/extra-tool-picker';
+import { RedoItem, UndoItem } from '../components/history';
+import { ToolbarItem } from '../components/item';
+import { MoveHandleItem } from '../components/move-handle';
+import { PenPickerItem } from '../components/pen-picker';
+import { ShapePickerItem } from '../components/shape-picker';
+import { AnnotationToolbarContext } from '../toolbar-store';
+import { jsx as _jsx } from "react/jsx-runtime";
+export var useAnnotationVisibleTools = function useAnnotationVisibleTools(diraction) {
+  var _useContext = useContext(AnnotationToolbarContext),
+    _useContext$observabl = _useContext.observables,
+    maxCountVisibleTools = _useContext$observabl.maxCountVisibleTools,
+    toolbarDockPosition = _useContext$observabl.toolbarDockPosition,
+    setTool = _useContext.setTool,
+    saveDraft = _useContext.saveDraft,
+    currentTool = _useContext.toolbarState.currentTool;
+  var transI18n = useI18n();
+  var handleToolChange = function handleToolChange(tool) {
+    return function () {
+      setTool(tool);
+    };
+  };
+  var annontationMainTools = [{
+    renderItem: function renderItem() {
+      return /*#__PURE__*/_jsx(ToolbarItem, {
+        tooltipPlacement: toolbarDockPosition.placement === 'left' ? 'right' : 'left',
+        tooltip: transI18n('fmt_screenshare_whiteboard_button_laserpen'),
+        icon: FcrIconType.FCR_WHITEBOARD_LASERPEN1,
+        onClick: handleToolChange(FcrBoardToolType.LASER_POINTER),
+        isActive: currentTool === FcrBoardToolType.LASER_POINTER,
+        diraction: diraction,
+        iconColor: "#FF0005"
+      });
+    }
+  }, {
+    renderItem: function renderItem() {
+      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        offset = _ref.offset;
+      return /*#__PURE__*/_jsx(PenPickerItem, {
+        offset: offset
+      });
+    }
+  }, {
+    renderItem: function renderItem() {
+      var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        offset = _ref2.offset;
+      return /*#__PURE__*/_jsx(ShapePickerItem, {
+        offset: offset
+      });
+    }
+  }, {
+    renderItem: function renderItem() {
+      var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        offset = _ref3.offset;
+      return /*#__PURE__*/_jsx(EraserPickerItem, {
+        offset: offset
+      });
+    }
+  }];
+  var baseMainTools = annontationMainTools;
+  var divider = {
+    renderItem: function renderItem() {
+      return /*#__PURE__*/_jsx("div", {
+        className: "fcr-divider-vertical"
+      });
+    }
+  };
+  var colorTool = {
+    renderItem: function renderItem() {
+      return /*#__PURE__*/_jsx(ColorPickerItem, {});
+    }
+  };
+  var fixedTools = [divider, colorTool, divider, {
+    renderItem: function renderItem() {
+      return /*#__PURE__*/_jsx(ToolbarItem, {
+        tooltipPlacement: toolbarDockPosition.placement === 'left' ? 'right' : 'left',
+        tooltip: transI18n('fmt_screenshare_whiteboard_button_savescript'),
+        icon: FcrIconType.FCR_DOWNLOAD,
+        onClick: saveDraft,
+        isActive: false,
+        diraction: diraction
+      });
+    }
+  }, divider, {
+    renderItem: function renderItem() {
+      return /*#__PURE__*/_jsx(UndoItem, {});
+    }
+  }, {
+    renderItem: function renderItem() {
+      return /*#__PURE__*/_jsx(RedoItem, {});
+    }
+  }, {
+    renderItem: function renderItem() {
+      return /*#__PURE__*/_jsx(MoveHandleItem, {});
+    }
+  }];
+  var fixedAnnotationTools = [divider, colorTool, divider, {
+    renderItem: function renderItem() {
+      return /*#__PURE__*/_jsx(UndoItem, {});
+    }
+  }, {
+    renderItem: function renderItem() {
+      return /*#__PURE__*/_jsx(RedoItem, {});
+    }
+  }, {
+    renderItem: function renderItem() {
+      return /*#__PURE__*/_jsx(MoveHandleItem, {});
+    }
+  }];
+  var additionTool = {
+    renderItem: function renderItem() {
+      return /*#__PURE__*/_jsx(AdditionToolPickerItem, {});
+    }
+  };
+
+  // whether toolbar needs to shrink in vertical direction
+  var isShinked = maxCountVisibleTools < baseMainTools.length + 1;
+  var showColorCount = isShinked ? 0 : maxCountVisibleTools - baseMainTools.length; /* addition tool */
+
+  var maxCountAvailableToDisplay = maxCountVisibleTools;
+  var resultFixedTools = fixedAnnotationTools;
+  var mainTools = isShinked && diraction !== 'horizontal' ? range(0, max([0, min([maxCountAvailableToDisplay, baseMainTools.length])])).map(function (index) {
+    return baseMainTools[index];
+  }).concat([additionTool]).concat(resultFixedTools) : baseMainTools.concat(resultFixedTools);
+  var additionToolsCount = baseMainTools.length - maxCountAvailableToDisplay;
+  var additionTools = [].concat(baseMainTools).reverse().filter(function (tool, index) {
+    if (index < additionToolsCount) {
+      return true;
+    }
+    return false;
+  });
+  additionTools = additionTools.reverse();
+  return {
+    mainTools: mainTools,
+    additionTools: additionTools,
+    showColorCount: showColorCount,
+    isShinked: isShinked
+  };
+};

package/lib-es/modules/annotation/index.js

@@ -0,0 +1,144 @@
+import "core-js/modules/es.reflect.construct.js";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import "core-js/modules/es.error.cause.js";
+import "core-js/modules/es.error.to-string.js";
+import "core-js/modules/es.array.concat.js";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import { UIModule } from '../../base';
+import { AnnotationStoreContext } from './store.base';
+import { Annotation } from './view';
+import { FcrUIObjectKeys } from '../../object-manager';
+import { AnnotationToolbar } from './standalone-toolbar/view';
+import { StandaloneAnnotationToolbarContext, StandaloneAnnotationToolbarStore } from './standalone-toolbar/store';
+import { isElectron } from 'agora-foundation/lib/utilities/env';
+import { AnnotationStore as ElectronAnnotationStore } from './store.electron';
+import { AnnotationStore as BrowserAnnotationStore } from './store.browser';
+import { AnnotationToolbarContext, AnnotationToolbarStore } from './toolbar-store';
+import { jsx as _jsx } from "react/jsx-runtime";
+export var AnnotationUIModule = /*#__PURE__*/function (_UIModule) {
+  function AnnotationUIModule() {
+    var _this;
+    _classCallCheck(this, AnnotationUIModule);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, AnnotationUIModule, [].concat(args));
+    _defineProperty(_this, "_standaloneToolbarStore", null);
+    _defineProperty(_this, "_toolbarStore", null);
+    _defineProperty(_this, "_store", null);
+    return _this;
+  }
+  _inherits(AnnotationUIModule, _UIModule);
+  return _createClass(AnnotationUIModule, [{
+    key: "store",
+    get: function get() {
+      if (!this._store) {
+        throw new Error('AnnotationStore is not initialized');
+      }
+      return this._store;
+    }
+  }, {
+    key: "toolbarStore",
+    get: function get() {
+      if (!this._toolbarStore) {
+        throw new Error('AnnotationToolbarStore is not initialized');
+      }
+      return this._toolbarStore;
+    }
+  }, {
+    key: "standaloneToolbarStore",
+    get: function get() {
+      if (!this._standaloneToolbarStore) {
+        throw new Error('AnnotationToolbarStore is not initialized');
+      }
+      return this._standaloneToolbarStore;
+    }
+  }, {
+    key: "onNodeWillActive",
+    value: function onNodeWillActive() {
+      this._standaloneToolbarStore = isElectron() ? new StandaloneAnnotationToolbarStore({
+        objectManager: this.objectManager
+      }) : null;
+      this._toolbarStore = new AnnotationToolbarStore({
+        objectManager: this.objectManager
+      });
+      this._store = isElectron() ? new ElectronAnnotationStore({
+        objectManager: this.objectManager
+      }) : new BrowserAnnotationStore({
+        objectManager: this.objectManager
+      });
+    }
+  }, {
+    key: "onNodeWillInactive",
+    value: function onNodeWillInactive() {
+      if (this._standaloneToolbarStore) {
+        this._standaloneToolbarStore.release();
+      }
+      this.toolbarStore.release();
+      this.store.release();
+    }
+
+    /**
+     * 主窗口标注
+     * @returns
+     */
+  }, {
+    key: "getComponent",
+    value: function getComponent() {
+      return /*#__PURE__*/_jsx(AnnotationStoreContext.Provider, {
+        value: this.store,
+        children: /*#__PURE__*/_jsx(AnnotationToolbarContext.Provider, {
+          value: this.toolbarStore,
+          children: /*#__PURE__*/_jsx(Annotation, {})
+        })
+      });
+    }
+
+    /**
+     * 遮罩标注
+     * @returns
+     */
+  }, {
+    key: "getBoardComponent",
+    value: function getBoardComponent() {
+      var renderer = this.objectManager.getObject(FcrUIObjectKeys.RENDERER_WRAPPER);
+      var baseUrl = renderer.getBaseUrl();
+      var url = "".concat(baseUrl, "/annotation.html");
+      return /*#__PURE__*/_jsx("div", {
+        style: {
+          width: '100%',
+          height: '100%'
+        },
+        children: /*#__PURE__*/_jsx("iframe", {
+          src: url,
+          style: {
+            width: '100%',
+            height: '100%'
+          }
+        })
+      });
+    }
+
+    /**
+     * 遮罩标注工具栏
+     * @returns
+     */
+  }, {
+    key: "getBoardToolComponent",
+    value: function getBoardToolComponent() {
+      return /*#__PURE__*/_jsx(StandaloneAnnotationToolbarContext.Provider, {
+        value: this.standaloneToolbarStore,
+        children: /*#__PURE__*/_jsx(AnnotationToolbar, {})
+      });
+    }
+  }, {
+    key: "onUiEvent",
+    value: function onUiEvent(event, payload) {}
+  }]);
+}(UIModule);

package/lib-es/{fragments/annotation/toolbar → modules/annotation/standalone-toolbar}/components/color-tool/color-panel/index.js

@@ -6,12 +6,12 @@ import { FcrIconType } from 'agora-ui-foundation/lib/components/icon/type';
 import { AnnotationToolItem } from '../../item/item';
 import { AnnotationToolPanel } from '../../panel';
 import { observer } from 'mobx-react';
-import { AnnotationToolbarContext } from '../../../store';
 import { useContext } from 'react';
+import { StandaloneAnnotationToolbarContext } from '../../../store';
 import { jsx as _jsx } from "react/jsx-runtime";
 export var AnnotationColorPanel = observer(function (props) {
   var onClick = props.onClick;
-  var _useContext = useContext(AnnotationToolbarContext),
+  var _useContext = useContext(StandaloneAnnotationToolbarContext),
     _useContext$observabl = _useContext.observables,
     colors = _useContext$observabl.colors,
     currentColor = _useContext$observabl.currentColor;

package/lib-es/{fragments/annotation/toolbar → modules/annotation/standalone-toolbar}/components/color-tool/index.js

@@ -3,24 +3,23 @@ import { FcrIconType } from 'agora-ui-foundation/lib/components/icon/type';
 import { AnnotationToolItem } from '../item/item';
 import { AnnotationColorPanel } from './color-panel';
 import { observer } from 'mobx-react';
-import { AnnotationToolbarContext } from '../../store';
-import { useContext, useEffect, useState } from 'react';
+import { useCallback, useContext, useEffect, useState } from 'react';
 import { useI18n } from 'agora-ui-foundation/lib/i18n';
-import { HotAreaContext } from '../../../../../modules/dialog/components/host-area-container';
+import { StandaloneAnnotationToolbarContext } from '../../store';
+import { BoundaryDetector } from '../../../../control-bar/components/boundary-detector';
 import { jsx as _jsx } from "react/jsx-runtime";
 export var AnnotationColorTool = observer(function () {
-  var _useContext = useContext(AnnotationToolbarContext),
+  var _useContext = useContext(StandaloneAnnotationToolbarContext),
     currentColor = _useContext.observables.currentColor,
     setStrokeColor = _useContext.setStrokeColor,
     popoverVisible = _useContext.popoverVisible,
-    setPopoverVisible = _useContext.setPopoverVisible;
+    setPopoverVisible = _useContext.setPopoverVisible,
+    setPopoverArea = _useContext.setPopoverArea;
   var t = useI18n();
   var _useState = useState(false),
     _useState2 = _slicedToArray(_useState, 2),
     visible = _useState2[0],
     setVisible = _useState2[1];
-  var _useContext2 = useContext(HotAreaContext),
-    placement = _useContext2.placement;
   var handleClick = function handleClick(color) {
     setStrokeColor(color);
     setVisible(!visible);
@@ -32,17 +31,31 @@ export var AnnotationColorTool = observer(function () {
   };
   useEffect(function () {
     !popoverVisible && setVisible(false);
+    if (!popoverVisible) {
+      setPopoverArea({
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0
+      });
+    }
   }, [popoverVisible]);
+  var handleBoundariesChanged = useCallback(function (boundaries) {
+    console.log('Annotation toolbar color tool boundaries changed');
+    setPopoverArea(boundaries);
+  }, []);
   return /*#__PURE__*/_jsx(AnnotationToolItem, {
-    placement: placement,
     iconType: FcrIconType.FCR_COLOR,
     color: currentColor,
     title: t('fmt_whiteboard_labels_colour'),
     lineColor: "transparent",
     visible: visible && popoverVisible,
     onVisibleChange: handleVisibleChange,
-    content: /*#__PURE__*/_jsx(AnnotationColorPanel, {
-      onClick: handleClick
+    content: /*#__PURE__*/_jsx(BoundaryDetector, {
+      onBoundariesChanged: handleBoundariesChanged,
+      children: /*#__PURE__*/_jsx(AnnotationColorPanel, {
+        onClick: handleClick
+      })
     })
   });
 });

package/lib-es/{fragments/annotation/toolbar → modules/annotation/standalone-toolbar}/components/graphic-tool/graphic-panel/index.js

@@ -5,19 +5,18 @@ import "core-js/modules/esnext.iterator.map.js";
 import { AnnotationToolItem } from '../../item/item';
 import { AnnotationToolPanel } from '../../panel';
 import { observer } from 'mobx-react';
-import { AnnotationToolbarContext } from '../../../store';
 import { useContext } from 'react';
 import { convertShapeToBoardToolType, lineWidths, tools } from './libs';
+import { StandaloneAnnotationToolbarContext } from '../../../store';
 import { jsx as _jsx } from "react/jsx-runtime";
 export var AnnotationGraphicPanel = observer(function (props) {
-  var _useContext = useContext(AnnotationToolbarContext),
+  var _useContext = useContext(StandaloneAnnotationToolbarContext),
     _useContext$observabl = _useContext.observables,
     currentShape = _useContext$observabl.currentShape,
     currentStrokeWidth = _useContext$observabl.currentStrokeWidth,
     setShape = _useContext.setShape,
     setTool = _useContext.setTool,
     setStrokeWidth = _useContext.setStrokeWidth;
-  var onClick = props.onClick;
   var handleShapeClick = function handleShapeClick(shape) {
     return function () {
       // onClick();

package/lib-es/{fragments/annotation/toolbar → modules/annotation/standalone-toolbar}/components/graphic-tool/index.js

@@ -8,23 +8,22 @@ import "core-js/modules/esnext.iterator.some.js";
 import { AnnotationToolItem } from '../item/item';
 import { AnnotationGraphicPanel } from './graphic-panel';
 import { observer } from 'mobx-react';
-import { AnnotationToolbarContext } from '../../store';
-import { useContext, useEffect, useState } from 'react';
+import { useCallback, useContext, useEffect, useState } from 'react';
 import { convertShapeToBoardToolType, tools } from './graphic-panel/libs';
 import { useI18n } from 'agora-ui-foundation/lib/i18n';
-import { HotAreaContext } from '../../../../../modules/dialog/components/host-area-container';
+import { StandaloneAnnotationToolbarContext } from '../../store';
+import { BoundaryDetector } from '../../../../control-bar/components/boundary-detector';
 import { jsx as _jsx } from "react/jsx-runtime";
 export var AnnotationGraphicTool = observer(function () {
-  var _useContext = useContext(AnnotationToolbarContext),
+  var _useContext = useContext(StandaloneAnnotationToolbarContext),
     _useContext$observabl = _useContext.observables,
     currentColor = _useContext$observabl.currentColor,
     currentShape = _useContext$observabl.currentShape,
     currentTool = _useContext$observabl.currentTool,
     setTool = _useContext.setTool,
     popoverVisible = _useContext.popoverVisible,
-    setPopoverVisible = _useContext.setPopoverVisible;
-  var _useContext2 = useContext(HotAreaContext),
-    placement = _useContext2.placement;
+    setPopoverVisible = _useContext.setPopoverVisible,
+    setPopoverArea = _useContext.setPopoverArea;
   var _useState = useState(false),
     _useState2 = _slicedToArray(_useState, 2),
     visible = _useState2[0],
@@ -41,9 +40,20 @@ export var AnnotationGraphicTool = observer(function () {
   };
   useEffect(function () {
     !popoverVisible && setVisible(false);
+    if (!popoverVisible) {
+      setPopoverArea({
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0
+      });
+    }
   }, [popoverVisible]);
+  var handleBoundariesChanged = useCallback(function (boundaries) {
+    console.log('Annotation toolbar graphic tool boundaries changed');
+    setPopoverArea(boundaries);
+  }, []);
   return /*#__PURE__*/_jsx(AnnotationToolItem, {
-    placement: placement,
     active: tools.some(function (tool) {
       return convertShapeToBoardToolType(tool.shape) === currentTool;
     }),
@@ -55,8 +65,11 @@ export var AnnotationGraphicTool = observer(function () {
     visible: visible && popoverVisible,
     onVisibleChange: handleVisibleChange,
     onClick: handleClick,
-    content: /*#__PURE__*/_jsx(AnnotationGraphicPanel, {
-      onClick: handleClick
+    content: /*#__PURE__*/_jsx(BoundaryDetector, {
+      onBoundariesChanged: handleBoundariesChanged,
+      children: /*#__PURE__*/_jsx(AnnotationGraphicPanel, {
+        onClick: handleClick
+      })
     })
   });
 });