diff --git a/frameworks/core/components_ng/pattern/menu/menu_layout_algorithm.cpp b/frameworks/core/components_ng/pattern/menu/menu_layout_algorithm.cpp
index 678a57a32741762cff6044b7db3b481c6b2a31d6..641ee36ce52aac1c3169aa4d835282f572f38c29 100644
--- a/frameworks/core/components_ng/pattern/menu/menu_layout_algorithm.cpp
+++ b/frameworks/core/components_ng/pattern/menu/menu_layout_algorithm.cpp
@@ -672,6 +672,27 @@ void MenuLayoutAlgorithm::CalculateIdealSize(LayoutWrapper* layoutWrapper,
     geometryNode->SetFrameSize(idealSize);
 }
 
+void MenuLayoutAlgorithm::GetPreviewNodeTargetHoverImageChild(const RefPtr<LayoutWrapper>& child,
+    RefPtr<FrameNode>& hostNode, RefPtr<GeometryNode>& geometryNode, bool isShowHoverImage)
+{
+    CHECK_NULL_VOID(isShowHoverImage);
+    bool isColNode = hostNode->GetTag() == V2::COLUMN_ETS_TAG;
+    CHECK_NULL_VOID(isColNode);
+    // column -> stack -> image index 0 , preview index 1 when hoverScale api in use
+    auto childNode = child->GetChildByIndex(0)->GetChildByIndex(1);
+    CHECK_NULL_VOID(childNode);
+
+    auto hostChild = childNode->GetHostNode();
+    CHECK_NULL_VOID(hostChild);
+    CHECK_NULL_VOID(hostChild->GetTag() == V2::MENU_PREVIEW_ETS_TAG || hostChild->GetTag() == V2::IMAGE_ETS_TAG);
+
+    auto childGeometryNode = childNode->GetGeometryNode();
+    CHECK_NULL_VOID(childGeometryNode);
+
+    hostNode = hostChild;
+    geometryNode = childGeometryNode;
+}
+
 void MenuLayoutAlgorithm::GetPreviewNodeTotalSize(const RefPtr<LayoutWrapper>& child, const Rect& windowGlobalRect,
     RefPtr<LayoutWrapper>& previewLayoutWrapper, SizeF& size, bool isShowHoverImage)
 {
@@ -680,6 +701,8 @@ void MenuLayoutAlgorithm::GetPreviewNodeTotalSize(const RefPtr<LayoutWrapper>& c
     if (!hostNode || !geometryNode) {
         return;
     }
+    GetPreviewNodeTargetHoverImageChild(child, hostNode, geometryNode, isShowHoverImage);
+
     bool isImageNode = hostNode->GetTag() == V2::IMAGE_ETS_TAG;
     if (hostNode->GetTag() != V2::MENU_PREVIEW_ETS_TAG && !isImageNode) {
         return;
diff --git a/frameworks/core/components_ng/pattern/menu/menu_layout_algorithm.h b/frameworks/core/components_ng/pattern/menu/menu_layout_algorithm.h
index abfdecf7053676c9b7b4fd29b2ec2c132fb0b3e9..b6b9b07bd1def44f40c8dd33fe00e5a5e53794b3 100644
--- a/frameworks/core/components_ng/pattern/menu/menu_layout_algorithm.h
+++ b/frameworks/core/components_ng/pattern/menu/menu_layout_algorithm.h
@@ -174,6 +174,8 @@ private:
     void ModifyNormalPreviewMenuPortraitPlacement(LayoutWrapper* layoutWrapper);
     void GetPreviewNodeTotalSize(const RefPtr<LayoutWrapper>& child, const Rect& windowGlobalRect,
         RefPtr<LayoutWrapper>& previewLayoutWrapper, SizeF& size, bool isShowHoverImage);
+    void GetPreviewNodeTargetHoverImageChild(const RefPtr<LayoutWrapper>& child,
+        RefPtr<FrameNode>& hostNode, RefPtr<GeometryNode>& geometryNode, bool isShowHoverImage);
     SizeF GetPreviewNodeAndMenuNodeTotalSize(const RefPtr<FrameNode>& frameNode,
         RefPtr<LayoutWrapper>& previewLayoutWrapper, RefPtr<LayoutWrapper>& menuLayoutWrapper);
 
diff --git a/frameworks/core/components_ng/pattern/menu/menu_pattern.cpp b/frameworks/core/components_ng/pattern/menu/menu_pattern.cpp
index 742ad695df7733e2829ce32701045e2843383505..95b20d09bec4887fe75d90ede701d8b21106d95f 100644
--- a/frameworks/core/components_ng/pattern/menu/menu_pattern.cpp
+++ b/frameworks/core/components_ng/pattern/menu/menu_pattern.cpp
@@ -42,6 +42,7 @@
 #include "core/components_ng/pattern/option/option_view.h"
 #include "core/components_ng/pattern/scroll/scroll_pattern.h"
 #include "core/components_ng/pattern/text/text_layout_property.h"
+#include "core/components_ng/pattern/stack/stack_pattern.h"
 #include "core/components_ng/property/border_property.h"
 #include "core/components_v2/inspector/inspector_constants.h"
 #include "core/event/touch_event.h"
@@ -66,6 +67,8 @@ const RefPtr<InterpolatingSpring> MENU_ANIMATION_CURVE =
     AceType::MakeRefPtr<InterpolatingSpring>(VELOCITY, MASS, STIFFNESS, DAMPING);
 const RefPtr<InterpolatingSpring> STACK_MENU_CURVE =
     AceType::MakeRefPtr<InterpolatingSpring>(VELOCITY, MASS, STIFFNESS, STACK_MENU_DAMPING);
+const RefPtr<Curve> CUSTOM_PREVIEW_ANIMATION_CURVE =
+    AceType::MakeRefPtr<InterpolatingSpring>(0.0f, 1.0f, 280.0f, 30.0f);
 
 constexpr double MOUNT_MENU_FINAL_SCALE = 0.95f;
 constexpr double SEMI_CIRCLE_ANGEL = 90.0f;
@@ -1042,8 +1045,10 @@ void MenuPattern::ShowPreviewMenuScaleAnimation()
     CHECK_NULL_VOID(menuWrapper);
     auto menuWrapperPattern = menuWrapper->GetPattern<MenuWrapperPattern>();
     CHECK_NULL_VOID(menuWrapperPattern);
-    auto preview = menuWrapperPattern->GetPreview();
+
+    auto preview = isShowHoverImage_ ? menuWrapperPattern->GetHoverImageColNode() : menuWrapperPattern->GetPreview();
     CHECK_NULL_VOID(preview);
+    bool isHoverImageTarget = isShowHoverImage_ && preview->GetTag() == V2::COLUMN_ETS_TAG;
     auto previewRenderContext = preview->GetRenderContext();
     CHECK_NULL_VOID(previewRenderContext);
     auto previewGeometryNode = preview->GetGeometryNode();
@@ -1057,20 +1062,22 @@ void MenuPattern::ShowPreviewMenuScaleAnimation()
     CHECK_NULL_VOID(menuTheme);
     auto springMotionResponse = menuTheme->GetSpringMotionResponse();
     auto springMotionDampingFraction = menuTheme->GetSpringMotionDampingFraction();
-    auto delay = isShowHoverImage_ && preview->GetTag() == V2::MENU_PREVIEW_ETS_TAG ?
-        menuTheme->GetHoverImageDelayDuration() : 0;
+    auto delay = isHoverImageTarget ? menuTheme->GetHoverImageDelayDuration() : 0;
 
     previewRenderContext->UpdatePosition(
         OffsetT<Dimension>(Dimension(previewOriginPosition.GetX()), Dimension(previewOriginPosition.GetY())));
     AnimationOption scaleOption = AnimationOption();
     auto motion = AceType::MakeRefPtr<ResponsiveSpringMotion>(springMotionResponse, springMotionDampingFraction);
-    scaleOption.SetCurve(motion);
+    if (isHoverImageTarget) {
+        scaleOption.SetCurve(CUSTOM_PREVIEW_ANIMATION_CURVE);
+    } else {
+        scaleOption.SetCurve(motion);
+    }
     scaleOption.SetDelay(delay);
     AnimationUtils::Animate(scaleOption, [previewRenderContext, previewPosition]() {
-        if (previewRenderContext) {
-            previewRenderContext->UpdatePosition(
-                OffsetT<Dimension>(Dimension(previewPosition.GetX()), Dimension(previewPosition.GetY())));
-        }
+        CHECK_NULL_VOID(previewRenderContext);
+        previewRenderContext->UpdatePosition(
+            OffsetT<Dimension>(Dimension(previewPosition.GetX()), Dimension(previewPosition.GetY())));
     });
 }
 
diff --git a/frameworks/core/components_ng/pattern/menu/menu_view.cpp b/frameworks/core/components_ng/pattern/menu/menu_view.cpp
index 20ee5a2e230d7a7032983ca336b51486974bae6d..a045746e37188e89b7bf2fb53645944d07738fb4 100644
--- a/frameworks/core/components_ng/pattern/menu/menu_view.cpp
+++ b/frameworks/core/components_ng/pattern/menu/menu_view.cpp
@@ -37,6 +37,7 @@
 #include "core/components_ng/pattern/overlay/overlay_manager.h"
 #include "core/components_ng/pattern/scroll/scroll_pattern.h"
 #include "core/components_ng/pattern/text/text_pattern.h"
+#include "core/components_ng/pattern/stack/stack_pattern.h"
 #include "core/components_v2/inspector/inspector_constants.h"
 
 namespace OHOS::Ace::NG {
@@ -53,7 +54,8 @@ namespace OHOS::Ace::NG {
 
 namespace {
 constexpr float PAN_MAX_VELOCITY = 2000.0f;
-constexpr float HALF_DIVIDER_VALUE = 2.0f;
+const RefPtr<Curve> CUSTOM_PREVIEW_ANIMATION_CURVE =
+    AceType::MakeRefPtr<InterpolatingSpring>(0.0f, 1.0f, 280.0f, 30.0f);
 
 void SetSelfAndChildDraggableFalse(const RefPtr<UINode>& customNode)
 {
@@ -258,6 +260,16 @@ RefPtr<MenuPattern> GetMenuPattern(const RefPtr<FrameNode>& menuNode)
     return menuHostNode->GetPattern<MenuPattern>();
 }
 
+void UpdateContainerMaxSizeConstraint(const RefPtr<FrameNode>& node, const CalcSize& maxSize)
+{
+    CHECK_NULL_VOID(node);
+    MeasureProperty layoutConstraint;
+    layoutConstraint.maxSize = maxSize;
+    auto nodeLayoutProperty = node->GetLayoutProperty<LayoutProperty>();
+    CHECK_NULL_VOID(nodeLayoutProperty);
+    nodeLayoutProperty->UpdateCalcLayoutProperty(layoutConstraint);
+}
+
 void ShowBorderRadiusAndShadowAnimation(const RefPtr<MenuTheme>& menuTheme, const RefPtr<RenderContext>& imageContext,
     bool isShowHoverImage)
 {
@@ -287,10 +299,9 @@ void ShowBorderRadiusAndShadowAnimation(const RefPtr<MenuTheme>& menuTheme, cons
         option.GetOnFinishEvent());
 }
 
-void SetHoverImageFinishEvent(const RefPtr<RenderContext>& imageContext, const RefPtr<MenuTheme>& menuTheme,
-    bool isShow, bool isScaleNearEqual = true)
+void UpdateOpacityInFinishEvent(const RefPtr<FrameNode>& previewNode, const RefPtr<RenderContext>& imageContext,
+    const RefPtr<MenuTheme>& menuTheme, bool isScaleNearEqual = true)
 {
-    CHECK_NULL_VOID(isShow);
     CHECK_NULL_VOID(imageContext && menuTheme);
     // hover image disappear opacity animation
     AnimationOption option;
@@ -302,67 +313,158 @@ void SetHoverImageFinishEvent(const RefPtr<RenderContext>& imageContext, const R
         option.SetDuration(menuTheme->GetHoverImageSwitchToPreviewOpacityDuration());
         option.SetCurve(Curves::FRICTION);
     }
+
+    CHECK_NULL_VOID(previewNode);
+    auto previewContext = previewNode->GetRenderContext();
+    CHECK_NULL_VOID(previewContext);
+    
     imageContext->UpdateOpacity(1.0);
+    previewContext->UpdateOpacity(0.0);
     AnimationUtils::Animate(
-        option, [imageContext]() {
-            if (imageContext) {
-                imageContext->UpdateOpacity(0.0);
-            }
-        },
-        option.GetOnFinishEvent());
+        option, [imageContext, previewContext]() {
+            CHECK_NULL_VOID(imageContext);
+            imageContext->UpdateOpacity(0.0);
+            
+            CHECK_NULL_VOID(previewContext);
+            previewContext->UpdateOpacity(1.0);
+        });
 }
 
-void ShowPixelMapScaleAnimationProc(const RefPtr<MenuTheme>& menuTheme, const RefPtr<RenderContext>& imageContext,
-    const RefPtr<MenuPattern>& menuPattern, const MenuParam& menuParam)
+void SetHoverImageStackBorderRadius(const RefPtr<FrameNode>& hoverImageStackNode, const RefPtr<MenuTheme>& menuTheme)
 {
-    auto scaleBefore = menuParam.isShowHoverImage ? menuParam.hoverImageAnimationOptions.scaleFrom :
-        menuPattern->GetPreviewBeforeAnimationScale();
-    auto scaleAfter = menuParam.isShowHoverImage ? menuParam.hoverImageAnimationOptions.scaleTo :
-        menuPattern->GetPreviewAfterAnimationScale();
-    DragEventActuator::ExecutePreDragAction(PreDragStatus::PREVIEW_LIFT_STARTED);
-    auto previewBeforeAnimationScale =
+    CHECK_NULL_VOID(hoverImageStackNode);
+    auto stackContext = hoverImageStackNode->GetRenderContext();
+    CHECK_NULL_VOID(stackContext);
+
+    auto stackLayoutProps = hoverImageStackNode->GetLayoutProperty<StackLayoutProperty>();
+    CHECK_NULL_VOID(stackLayoutProps);
+    BorderWidthProperty widthProp;
+    widthProp.SetBorderWidth(Dimension(0.0f));
+    stackLayoutProps->UpdateBorderWidth(widthProp);
+    stackContext->UpdateBorderWidth(widthProp);
+    
+    AnimationOption option;
+    option.SetCurve(CUSTOM_PREVIEW_ANIMATION_CURVE);
+    auto previewBorderRadius = menuTheme->GetPreviewBorderRadius();
+    AnimationUtils::Animate(
+        option, [stackContext, previewBorderRadius]() {
+            CHECK_NULL_VOID(stackContext);
+            BorderRadiusProperty borderRadius;
+            borderRadius.SetRadius(previewBorderRadius);
+            stackContext->UpdateBorderRadius(borderRadius);
+        });
+}
+
+void SetHoverImageFinishEvent(const RefPtr<FrameNode>& hoverImageStackNode, const RefPtr<FrameNode>& previewNode,
+    const RefPtr<RenderContext>& imageContext, const RefPtr<MenuTheme>& menuTheme, bool isScaleNearEqual = true)
+{
+    UpdateOpacityInFinishEvent(previewNode, imageContext, menuTheme, isScaleNearEqual);
+
+    CHECK_NULL_VOID(hoverImageStackNode && previewNode);
+    auto stackContext = hoverImageStackNode->GetRenderContext();
+    CHECK_NULL_VOID(stackContext);
+    auto previewPattern = previewNode->GetPattern<MenuPreviewPattern>();
+    CHECK_NULL_VOID(previewPattern);
+
+    auto scaleBefore = previewPattern->GetCustomPreviewScaleFrom();
+    auto scaleFrom =
         LessNotEqual(scaleBefore, 0.0) ? menuTheme->GetPreviewBeforeAnimationScale() : scaleBefore;
-    auto previewAfterAnimationScale =
+    stackContext->UpdateTransformScale(VectorF(scaleFrom, scaleFrom));
+
+    auto scaleAfter = previewPattern->GetCustomPreviewScaleTo();
+    auto scaleTo =
         LessNotEqual(scaleAfter, 0.0) ? menuTheme->GetPreviewAfterAnimationScale() : scaleAfter;
+    
+    AnimationOption scaleOption = AnimationOption();
+    scaleOption.SetCurve(CUSTOM_PREVIEW_ANIMATION_CURVE);
+    AnimationUtils::Animate(
+        scaleOption, [stackContext, scaleTo]() {
+            CHECK_NULL_VOID(stackContext);
+            stackContext->UpdateTransformScale(VectorF(scaleTo, scaleTo));
+        },
+        scaleOption.GetOnFinishEvent());
+    
+    SetHoverImageStackBorderRadius(hoverImageStackNode, menuTheme);
+}
 
-    imageContext->UpdateTransformScale(VectorF(previewBeforeAnimationScale, previewBeforeAnimationScale));
+void ShowHoverImageAnimationProc(const RefPtr<FrameNode>& hoverImageStackNode, const RefPtr<FrameNode>& previewNode,
+    const RefPtr<RenderContext>& imageContext, const RefPtr<MenuPattern>& menuPattern, const MenuParam& menuParam)
+{
+    CHECK_NULL_VOID(menuParam.isShowHoverImage);
+    CHECK_NULL_VOID(hoverImageStackNode && previewNode);
+    auto stackContext = hoverImageStackNode->GetRenderContext();
+    CHECK_NULL_VOID(stackContext);
+    stackContext->UpdateClipEdge(true);
+    auto previewPattern = previewNode->GetPattern<MenuPreviewPattern>();
+    CHECK_NULL_VOID(previewPattern);
 
-    AnimationOption scaleOption = AnimationOption();
-    if (menuParam.isShowHoverImage) {
-        scaleOption.SetDuration(menuTheme->GetHoverImageDelayDuration());
-        scaleOption.SetCurve(Curves::SHARP);
-    } else {
-        auto motion = AceType::MakeRefPtr<ResponsiveSpringMotion>(
-            menuTheme->GetSpringMotionResponse(), menuTheme->GetSpringMotionDampingFraction());
-        scaleOption.SetCurve(motion);
-    }
+    auto pipeline = PipelineBase::GetCurrentContext();
+    CHECK_NULL_VOID(pipeline);
+    auto menuTheme = pipeline->GetTheme<NG::MenuTheme>();
+    CHECK_NULL_VOID(menuTheme);
+
+    DragEventActuator::ExecutePreDragAction(PreDragStatus::PREVIEW_LIFT_STARTED);
+    auto scaleBefore = previewPattern->GetHoverImageScaleFrom();
+    auto scaleFrom =
+        LessNotEqual(scaleBefore, 0.0) ? menuTheme->GetPreviewBeforeAnimationScale() : scaleBefore;
+    stackContext->UpdateTransformScale(VectorF(scaleFrom, scaleFrom));
+
+    auto scaleAfter = previewPattern->GetCustomPreviewScaleFrom();
+    auto scaleTo =
+        LessNotEqual(scaleAfter, 0.0) ? menuTheme->GetPreviewAfterAnimationScale() : scaleAfter;
 
     // when the scaling start and end sizes are the same, the end callback method should not be relied on
-    bool isScaleNearEqual = NearEqual(previewBeforeAnimationScale, previewAfterAnimationScale);
+    bool isScaleNearEqual = NearEqual(scaleFrom, scaleTo);
+    AnimationOption scaleOption = AnimationOption();
     if (isScaleNearEqual) {
-        SetHoverImageFinishEvent(imageContext, menuTheme, menuParam.isShowHoverImage);
-        scaleOption.SetOnFinishEvent([]() {
-            DragEventActuator::ExecutePreDragAction(PreDragStatus::PREVIEW_LIFT_FINISHED);
-            });
+        SetHoverImageFinishEvent(hoverImageStackNode, previewNode, imageContext, menuTheme);
+        scaleOption.SetOnFinishEvent(
+            []() { DragEventActuator::ExecutePreDragAction(PreDragStatus::PREVIEW_LIFT_FINISHED); });
     } else {
         scaleOption.SetOnFinishEvent(
-            [imageContext, menuTheme, isShow = menuParam.isShowHoverImage, isScaleNearEqual]() {
+            [hoverImageStackNode, previewNode, imageContext, menuTheme, isScaleNearEqual]() {
                 DragEventActuator::ExecutePreDragAction(PreDragStatus::PREVIEW_LIFT_FINISHED);
-                SetHoverImageFinishEvent(imageContext, menuTheme, isShow, isScaleNearEqual);
+                SetHoverImageFinishEvent(hoverImageStackNode, previewNode, imageContext, menuTheme, isScaleNearEqual);
             });
     }
+    scaleOption.SetDuration(menuTheme->GetHoverImageDelayDuration());
+    scaleOption.SetCurve(Curves::SHARP);
     AnimationUtils::Animate(
-        scaleOption,
-        [imageContext, previewAfterAnimationScale]() {
-            if (imageContext) {
-                imageContext->UpdateTransformScale(VectorF(previewAfterAnimationScale, previewAfterAnimationScale));
-            }
+        scaleOption, [stackContext, scaleTo]() {
+            CHECK_NULL_VOID(stackContext);
+            stackContext->UpdateTransformScale(VectorF(scaleTo, scaleTo));
+        },
+        scaleOption.GetOnFinishEvent());
+}
+
+void ShowPixelMapScaleAnimationProc(const RefPtr<MenuTheme>& menuTheme, const RefPtr<RenderContext>& imageContext,
+    const RefPtr<MenuPattern>& menuPattern)
+{
+    auto scaleBefore = menuPattern->GetPreviewBeforeAnimationScale();
+    auto scaleAfter = menuPattern->GetPreviewAfterAnimationScale();
+    DragEventActuator::ExecutePreDragAction(PreDragStatus::PREVIEW_LIFT_STARTED);
+    auto previewBeforeAnimationScale =
+        LessNotEqual(scaleBefore, 0.0) ? menuTheme->GetPreviewBeforeAnimationScale() : scaleBefore;
+    auto previewAfterAnimationScale =
+        LessNotEqual(scaleAfter, 0.0) ? menuTheme->GetPreviewAfterAnimationScale() : scaleAfter;
+    imageContext->UpdateTransformScale(VectorF(previewBeforeAnimationScale, previewBeforeAnimationScale));
+
+    AnimationOption scaleOption = AnimationOption();
+    auto motion = AceType::MakeRefPtr<ResponsiveSpringMotion>(
+        menuTheme->GetSpringMotionResponse(), menuTheme->GetSpringMotionDampingFraction());
+    scaleOption.SetCurve(motion);
+    scaleOption.SetOnFinishEvent(
+        []() { DragEventActuator::ExecutePreDragAction(PreDragStatus::PREVIEW_LIFT_FINISHED); });
+    AnimationUtils::Animate(
+        scaleOption, [imageContext, previewAfterAnimationScale]() {
+            CHECK_NULL_VOID(imageContext);
+            imageContext->UpdateTransformScale(VectorF(previewAfterAnimationScale, previewAfterAnimationScale));
         },
         scaleOption.GetOnFinishEvent());
 }
 
 void ShowPixelMapAnimation(const RefPtr<FrameNode>& imageNode, const RefPtr<FrameNode>& wrapperNode,
-    const RefPtr<FrameNode>& previewNode, const MenuParam& menuParam)
+    const RefPtr<FrameNode>& hoverImageStackNode, const RefPtr<FrameNode>& previewNode, const MenuParam& menuParam)
 {
     auto menuPattern = GetMenuPattern(wrapperNode);
     CHECK_NULL_VOID(menuPattern);
@@ -379,9 +481,12 @@ void ShowPixelMapAnimation(const RefPtr<FrameNode>& imageNode, const RefPtr<Fram
         auto layoutProperty = imageNode->GetLayoutProperty();
         layoutProperty->UpdateVisibility(VisibleType::VISIBLE, true);
     } else {
-        ShowPixelMapScaleAnimationProc(menuTheme, imageContext, menuPattern, menuParam);
+        if (menuParam.isShowHoverImage) {
+            ShowHoverImageAnimationProc(hoverImageStackNode, previewNode, imageContext, menuPattern, menuParam);
+        } else {
+            ShowPixelMapScaleAnimationProc(menuTheme, imageContext, menuPattern);
+        }
     }
-
     ShowBorderRadiusAndShadowAnimation(menuTheme, imageContext, menuParam.isShowHoverImage);
 }
 
@@ -494,8 +599,10 @@ void SetHoverImageCustomPreviewInfo(const RefPtr<FrameNode>& previewNode, const
     auto previewHeight = previewPattern->GetCustomPreviewHeight();
     auto scale = GetHoverImageCustomPreviewBaseScaleInfo(menuParam, width, height, previewWidth, previewHeight);
     CHECK_NULL_VOID(scale);
+    previewPattern->SetHoverImageScaleFrom(scale);
+
     auto hoverImageScaleTo = menuParam.hoverImageAnimationOptions.scaleTo;
-    hoverImageScaleTo = LessOrEqual(hoverImageScaleTo, 0.0) ? hoverImageScaleTo : 1.0f;
+    hoverImageScaleTo = LessOrEqual(hoverImageScaleTo, 0.0) ? 1.0f : hoverImageScaleTo;
     auto previewScaleFrom = LessOrEqual(menuParam.previewAnimationOptions.scaleFrom, 0.0) ? scale * hoverImageScaleTo :
         menuParam.previewAnimationOptions.scaleFrom;
     previewPattern->SetCustomPreviewScaleFrom(previewScaleFrom);
@@ -509,15 +616,10 @@ void SetHoverImageCustomPreviewInfo(const RefPtr<FrameNode>& previewNode, const
     previewScaleTo = LessOrEqual(previewScaleTo, 0.0) ? menuTheme->GetPreviewAfterAnimationScale() : previewScaleTo;
     previewPattern->SetCustomPreviewScaleTo(previewScaleTo);
     previewPattern->SetHoverImageDisAppearScaleTo(previewScaleTo / scale);
-
-    auto previewPositionXDist = (previewWidth - width) / HALF_DIVIDER_VALUE;
-    auto previewPositionYDist = (previewHeight - height) / HALF_DIVIDER_VALUE;
-    previewPattern->SetCustomPreviewPositionXDist(previewPositionXDist);
-    previewPattern->SetCustomPreviewPositionYDist(previewPositionYDist);
 }
 
 void SetPixelMap(const RefPtr<FrameNode>& target, const RefPtr<FrameNode>& wrapperNode,
-    const RefPtr<FrameNode>& previewNode, const MenuParam& menuParam)
+    const RefPtr<FrameNode>& hoverImageStackNode, const RefPtr<FrameNode>& previewNode, const MenuParam& menuParam)
 {
     CHECK_NULL_VOID(target);
     auto eventHub = target->GetEventHub<NG::EventHub>();
@@ -537,29 +639,38 @@ void SetPixelMap(const RefPtr<FrameNode>& target, const RefPtr<FrameNode>& wrapp
     auto props = imageNode->GetLayoutProperty<ImageLayoutProperty>();
     props->UpdateAutoResize(false);
     props->UpdateImageSourceInfo(ImageSourceInfo(pixelMap));
-    auto targetSize = CalcSize(NG::CalcLength(width), NG::CalcLength(height));
-    props->UpdateUserDefinedIdealSize(targetSize);
-    props->UpdateImageFit(ImageFit::FILL);
+
     auto hub = imageNode->GetEventHub<EventHub>();
     CHECK_NULL_VOID(hub);
     auto imageGestureHub = hub->GetOrCreateGestureEventHub();
     CHECK_NULL_VOID(imageGestureHub);
     InitPanEvent(gestureHub, imageGestureHub, wrapperNode);
 
-    if (!menuParam.isShowHoverImage) {
+    if (menuParam.isShowHoverImage) {
+        props->UpdateImageFit(ImageFit::CONTAIN);
+
+        imageNode->GetLayoutProperty()->UpdateMeasureType(MeasureType::MATCH_PARENT);
+        imageNode->MarkModifyDone();
+        imageNode->MountToParent(hoverImageStackNode);
+    } else {
+        auto targetSize = CalcSize(NG::CalcLength(width), NG::CalcLength(height));
+        props->UpdateUserDefinedIdealSize(targetSize);
+        props->UpdateImageFit(ImageFit::FILL);
+
         ShowGatherAnimation(target, wrapperNode);
+        auto imageContext = imageNode->GetRenderContext();
+        CHECK_NULL_VOID(imageContext);
+        imageContext->UpdatePosition(OffsetT<Dimension>(Dimension(imageOffset.GetX()), Dimension(imageOffset.GetY())));
+        imageNode->MarkModifyDone();
+        imageNode->MountToParent(wrapperNode);
     }
-    auto imageContext = imageNode->GetRenderContext();
-    CHECK_NULL_VOID(imageContext);
-    imageContext->UpdatePosition(OffsetT<Dimension>(Dimension(imageOffset.GetX()), Dimension(imageOffset.GetY())));
-    imageNode->MarkModifyDone();
-    imageNode->MountToParent(wrapperNode);
+    
     auto geometryNode = imageNode->GetGeometryNode();
     CHECK_NULL_VOID(geometryNode);
     geometryNode->SetFrameOffset(imageOffset);
     auto menuWrapperPattern = wrapperNode->GetPattern<MenuWrapperPattern>();
     CHECK_NULL_VOID(menuWrapperPattern);
-    ShowPixelMapAnimation(imageNode, wrapperNode, previewNode, menuParam);
+    ShowPixelMapAnimation(imageNode, wrapperNode, hoverImageStackNode, previewNode, menuParam);
 }
 
 void SetFilter(const RefPtr<FrameNode>& targetNode, const RefPtr<FrameNode>& menuWrapperNode)
@@ -614,9 +725,8 @@ void SetFilter(const RefPtr<FrameNode>& targetNode, const RefPtr<FrameNode>& men
 }
 
 void SetPreviewInfoToMenu(const RefPtr<FrameNode>& targetNode, const RefPtr<FrameNode>& wrapperNode,
-    const RefPtr<FrameNode>& previewNode, const RefPtr<FrameNode>& menuNode, const MenuParam& menuParam)
+    const RefPtr<FrameNode>& hoverImageStackNode, const RefPtr<FrameNode>& previewNode, const MenuParam& menuParam)
 {
-    CHECK_NULL_VOID(menuNode);
     CHECK_NULL_VOID(targetNode);
     auto eventHub = targetNode->GetEventHub<EventHub>();
     CHECK_NULL_VOID(eventHub);
@@ -628,7 +738,7 @@ void SetPreviewInfoToMenu(const RefPtr<FrameNode>& targetNode, const RefPtr<Fram
     }
     if (menuParam.previewMode == MenuPreviewMode::IMAGE || menuParam.previewMode == MenuPreviewMode::NONE ||
         menuParam.isShowHoverImage) {
-        SetPixelMap(targetNode, wrapperNode, previewNode, menuParam);
+        SetPixelMap(targetNode, wrapperNode, hoverImageStackNode, previewNode, menuParam);
     }
     if (menuParam.previewMode == MenuPreviewMode::NONE && isAllowedDrag) {
         auto pixelMapNode = AceType::DynamicCast<FrameNode>(wrapperNode->GetLastChild());
@@ -755,18 +865,63 @@ void SetPreviewScaleAndHoverImageScale(const RefPtr<FrameNode>& menuNode, const
     pattern->SetHoverImageAfterAnimationScale(menuParam.hoverImageAnimationOptions.scaleTo);
 }
 
-void SetCustomPreviewOpacityWhenHoverImage(const RefPtr<FrameNode>& menuWrapperNode, const MenuParam& menuParam)
+void MenuView::CustomPreviewParentNodeCreate(const RefPtr<FrameNode>& stackNode, const RefPtr<FrameNode>& colNode,
+    const RefPtr<FrameNode>& wrapperNode, const RefPtr<FrameNode>& previewNode)
 {
-    CHECK_NULL_VOID(menuParam.isShowHoverImage);
-    CHECK_NULL_VOID(menuWrapperNode);
-    auto menuWrapperPattern = menuWrapperNode->GetPattern<MenuWrapperPattern>();
-    CHECK_NULL_VOID(menuWrapperPattern);
-    menuWrapperPattern->SetIsShowHoverImage(menuParam.isShowHoverImage);
-    auto preview = menuWrapperPattern->GetPreview();
-    CHECK_NULL_VOID(preview);
-    auto previewRenderContext = preview->GetRenderContext();
-    CHECK_NULL_VOID(previewRenderContext);
-    previewRenderContext->UpdateOpacity(0.0);
+    CHECK_NULL_VOID(previewNode);
+    auto previewPattern = previewNode->GetPattern<MenuPreviewPattern>();
+    CHECK_NULL_VOID(previewPattern);
+    auto previewWidth = previewPattern->GetCustomPreviewWidth();
+    auto previewHeight = previewPattern->GetCustomPreviewHeight();
+    CHECK_NULL_VOID(stackNode);
+    CalcSize maxSize = { CalcLength(previewWidth), CalcLength(previewHeight) };
+    UpdateContainerMaxSizeConstraint(stackNode, maxSize);
+
+    CHECK_NULL_VOID(colNode);
+    UpdateContainerMaxSizeConstraint(colNode, maxSize);
+    auto props = colNode->GetLayoutProperty<LinearLayoutProperty>();
+    CHECK_NULL_VOID(props);
+    props->UpdateMainAxisAlign(FlexAlign::CENTER);
+
+    stackNode->MountToParent(colNode);
+    stackNode->MarkModifyDone();
+    CHECK_NULL_VOID(wrapperNode);
+    colNode->MountToParent(wrapperNode);
+    colNode->MarkModifyDone();
+}
+
+// contextmenu mount info proc
+void MenuView::ContextMenuChildMountProc(const RefPtr<FrameNode>& targetNode, const RefPtr<FrameNode>& wrapperNode,
+    const RefPtr<FrameNode>& previewNode, const RefPtr<FrameNode>& menuNode, const MenuParam& menuParam)
+{
+    // stack to put image and custom preview when hoverImage api is using
+    auto hoverImageStackNode = FrameNode::GetOrCreateFrameNode(V2::STACK_ETS_TAG,
+        ElementRegister::GetInstance()->MakeUniqueId(), []() { return AceType::MakeRefPtr<StackPattern>(); });
+    CHECK_NULL_VOID(hoverImageStackNode);
+
+    // column to control visible area
+    auto hoverImageColNode = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG,
+        ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<LinearLayoutPattern>(true));
+    CHECK_NULL_VOID(hoverImageColNode);
+    if (menuParam.isShowHoverImage) {
+        CustomPreviewParentNodeCreate(hoverImageStackNode, hoverImageColNode, wrapperNode, previewNode);
+        CHECK_NULL_VOID(wrapperNode);
+        auto menuWrapperPattern = wrapperNode->GetPattern<MenuWrapperPattern>();
+        CHECK_NULL_VOID(menuWrapperPattern);
+        menuWrapperPattern->SetIsShowHoverImage(menuParam.isShowHoverImage);
+        auto previewRenderContext = previewNode->GetRenderContext();
+        CHECK_NULL_VOID(previewRenderContext);
+        previewRenderContext->UpdateOpacity(0.0);
+    }
+    
+    if (menuNode) {
+        SetPreviewInfoToMenu(targetNode, wrapperNode, hoverImageStackNode, previewNode, menuParam);
+    }
+    
+    if (menuParam.previewMode == MenuPreviewMode::CUSTOM) {
+        previewNode->MountToParent(menuParam.isShowHoverImage ? hoverImageStackNode : wrapperNode);
+        previewNode->MarkModifyDone();
+    }
 }
 
 // create menu with custom node from a builder
@@ -813,14 +968,9 @@ RefPtr<FrameNode> MenuView::Create(const RefPtr<UINode>& customNode, int32_t tar
     }
     if (type == MenuType::CONTEXT_MENU) {
         auto targetNode = FrameNode::GetFrameNode(targetTag, targetId);
-        SetPreviewInfoToMenu(targetNode, wrapperNode, previewNode, menuNode, menuParam);
-        if (menuParam.previewMode == MenuPreviewMode::CUSTOM) {
-            previewNode->MountToParent(wrapperNode);
-            previewNode->MarkModifyDone();
-            SetSelfAndChildDraggableFalse(previewCustomNode);
-            MountTextNode(wrapperNode, previewCustomNode);
-            SetCustomPreviewOpacityWhenHoverImage(wrapperNode, menuParam);
-        }
+        ContextMenuChildMountProc(targetNode, wrapperNode, previewNode, menuNode, menuParam);
+        SetSelfAndChildDraggableFalse(previewCustomNode);
+        MountTextNode(wrapperNode, previewCustomNode);
     }
     return wrapperNode;
 }
diff --git a/frameworks/core/components_ng/pattern/menu/menu_view.h b/frameworks/core/components_ng/pattern/menu/menu_view.h
index 0d33f43dbdcd54fefbea631f6b9dbc05d2fb9896..eb6b23353af64949cc44e5eedd9df77fe62a40c2 100644
--- a/frameworks/core/components_ng/pattern/menu/menu_view.h
+++ b/frameworks/core/components_ng/pattern/menu/menu_view.h
@@ -52,6 +52,10 @@ private:
     static void UpdateMenuBorderEffect(const RefPtr<FrameNode>& menuNode);
     static void UpdateMenuBackgroundStyle(const RefPtr<FrameNode>& menuNode, const MenuParam& menuParam);
     static void NeedAgingUpdateNode(const RefPtr<FrameNode>& optionNode);
+    static void ContextMenuChildMountProc(const RefPtr<FrameNode>& targetNode, const RefPtr<FrameNode>& wrapperNode,
+        const RefPtr<FrameNode>& previewNode, const RefPtr<FrameNode>& menuNode, const MenuParam& menuParam);
+    static void CustomPreviewParentNodeCreate(const RefPtr<FrameNode>& stackNode, const RefPtr<FrameNode>& colNode,
+        const RefPtr<FrameNode>& wrapperNode, const RefPtr<FrameNode>& previewNode);
 };
 } // namespace OHOS::Ace::NG
 
diff --git a/frameworks/core/components_ng/pattern/menu/preview/menu_preview_pattern.cpp b/frameworks/core/components_ng/pattern/menu/preview/menu_preview_pattern.cpp
index f236ae3bca0b75ea10eaad0b173e639793ff5e8c..f398287c1971308f6cedb16f7e6efe3c16a04be5 100644
--- a/frameworks/core/components_ng/pattern/menu/preview/menu_preview_pattern.cpp
+++ b/frameworks/core/components_ng/pattern/menu/preview/menu_preview_pattern.cpp
@@ -40,57 +40,15 @@ RefPtr<MenuPattern> GetMenuPattern(const RefPtr<FrameNode>& menuWrapper)
     return menuNode->GetPattern<MenuPattern>();
 }
 
-bool ShowPreviewAnimationAfterHoverImage(const RefPtr<RenderContext>& context, const RefPtr<MenuTheme>& menuTheme,
-    const RefPtr<MenuPattern>& menuPattern, float scaleFrom, float scaleTo)
-{
-    CHECK_NULL_RETURN(menuPattern, false);
-    if (!menuPattern->GetIsShowHoverImage()) {
-        return false;
-    }
-    CHECK_NULL_RETURN(context, false);
-    CHECK_NULL_RETURN(menuTheme, false);
-    context->UpdateOpacity(0.0);
-    // custom preview update opacity
-    AnimationOption option;
-    option.SetDuration(menuTheme->GetHoverImageSwitchToPreviewOpacityDuration());
-    option.SetDelay(menuTheme->GetHoverImageDelayDuration());
-    option.SetCurve(Curves::FRICTION);
-    AnimationUtils::Animate(
-        option, [context]() {
-            CHECK_NULL_VOID(context);
-            context->UpdateOpacity(1.0);
-        },
-        option.GetOnFinishEvent());
-
-    // custom preview update scale from hover image size to final scale
-    auto scaleBefore = LessNotEqual(scaleFrom, 0.0) ? menuTheme->GetPreviewBeforeAnimationScale() : scaleFrom;
-    auto scaleAfter = LessNotEqual(scaleTo, 0.0) ? menuTheme->GetPreviewAfterAnimationScale() : scaleTo;
-    context->UpdateTransformScale(VectorF(scaleBefore, scaleBefore));
-
-    AnimationOption scaleOption = AnimationOption();
-    scaleOption.SetCurve(CUSTOM_PREVIEW_ANIMATION_CURVE);
-    scaleOption.SetDelay(menuTheme->GetHoverImageDelayDuration());
-    AnimationUtils::Animate(
-        scaleOption,
-        [context, scaleAfter]() {
-            CHECK_NULL_VOID(context);
-            context->UpdateTransformScale(VectorF(scaleAfter, scaleAfter));
-        },
-        scaleOption.GetOnFinishEvent());
-    return true;
-}
-
 void ShowScaleAnimation(const RefPtr<RenderContext>& context, const RefPtr<MenuTheme>& menuTheme,
-    const RefPtr<MenuPattern>& menuPattern, float scaleFrom, float scaleTo)
+    const RefPtr<MenuPattern>& menuPattern)
 {
-    if (ShowPreviewAnimationAfterHoverImage(context, menuTheme, menuPattern, scaleFrom, scaleTo)) {
-        return;
-    }
     CHECK_NULL_VOID(context);
     CHECK_NULL_VOID(menuTheme);
     auto scaleBefore { -1.0f };
     auto scaleAfter { -1.0f };
     if (menuPattern != nullptr) {
+        CHECK_NULL_VOID(!menuPattern->GetIsShowHoverImage());
         scaleBefore = menuPattern->GetPreviewBeforeAnimationScale();
         scaleAfter = menuPattern->GetPreviewAfterAnimationScale();
     }
@@ -205,7 +163,7 @@ bool MenuPreviewPattern::OnDirtyLayoutWrapperSwap(const RefPtr<LayoutWrapper>& d
         auto menuWrapper = GetMenuWrapper();
         auto menuPattern = GetMenuPattern(menuWrapper);
         ShowGatherAnimation(host, menuWrapper);
-        ShowScaleAnimation(context, menuTheme, menuPattern, customPreviewScaleFrom_, customPreviewScaleTo_);
+        ShowScaleAnimation(context, menuTheme, menuPattern);
     }
     isFirstShow_ = false;
     return false;
@@ -274,42 +232,4 @@ void MenuPreviewPattern::HandleDragEnd(float offsetX, float offsetY, float veloc
     CHECK_NULL_VOID(wrapperPattern);
     wrapperPattern->HideMenu();
 }
-
-void MenuPreviewPattern::ShowHoverImagePreviewDisAppearAnimation(const RefPtr<RenderContext>& context,
-    float scaleFrom, float scaleTo, int32_t duration)
-{
-    CHECK_NULL_VOID(isShowHoverImage_);
-    CHECK_NULL_VOID(context);
-
-    // custom preview update disappear opacity
-    context->UpdateOpacity(1.0);
-    AnimationOption option;
-    option.SetDuration(duration);
-    option.SetCurve(Curves::FRICTION);
-    AnimationUtils::Animate(
-        option, [context]() {
-            CHECK_NULL_VOID(context);
-            context->UpdateOpacity(0.0);
-        },
-        option.GetOnFinishEvent());
-
-    // custom preview update scale from final scale to hover image size
-    auto pipeline = PipelineBase::GetCurrentContext();
-    CHECK_NULL_VOID(pipeline);
-    auto menuTheme = pipeline->GetTheme<NG::MenuTheme>();
-    CHECK_NULL_VOID(menuTheme);
-    auto scaleBefore = LessNotEqual(scaleFrom, 0.0) ? menuTheme->GetPreviewAfterAnimationScale() : scaleFrom;
-    auto scaleAfter = LessNotEqual(scaleTo, 0.0) ? menuTheme->GetPreviewBeforeAnimationScale() : scaleTo;
-    context->UpdateTransformScale(VectorF(scaleBefore, scaleBefore));
-
-    AnimationOption scaleOption = AnimationOption();
-    scaleOption.SetCurve(CUSTOM_PREVIEW_ANIMATION_CURVE);
-    AnimationUtils::Animate(
-        scaleOption,
-        [context, scaleAfter]() {
-            CHECK_NULL_VOID(context);
-            context->UpdateTransformScale(VectorF(scaleAfter, scaleAfter));
-        },
-        scaleOption.GetOnFinishEvent());
-}
 } // namespace OHOS::Ace::NG
diff --git a/frameworks/core/components_ng/pattern/menu/preview/menu_preview_pattern.h b/frameworks/core/components_ng/pattern/menu/preview/menu_preview_pattern.h
index 698f62638164dd9841aa6d71f5aa376a7d567eac..c89ec35aa809cf9870f7390e848cd1359a19a041 100644
--- a/frameworks/core/components_ng/pattern/menu/preview/menu_preview_pattern.h
+++ b/frameworks/core/components_ng/pattern/menu/preview/menu_preview_pattern.h
@@ -80,6 +80,16 @@ public:
         return customPreviewHeight_;
     }
 
+    void SetHoverImageScaleFrom(float scaleFrom)
+    {
+        hoverImageScaleFrom_ = scaleFrom;
+    }
+
+    float GetHoverImageScaleFrom() const
+    {
+        return hoverImageScaleFrom_;
+    }
+
     void SetCustomPreviewScaleFrom(float scaleFrom)
     {
         customPreviewScaleFrom_ = scaleFrom;
@@ -146,6 +156,7 @@ private:
     bool isShowHoverImage_ = false;
     float customPreviewWidth_ = 0.0f;
     float customPreviewHeight_ = 0.0f;
+    float hoverImageScaleFrom_ = 1.0f;
     float customPreviewScaleFrom_ = 1.0f;
     float customPreviewScaleTo_ = 1.0f;
     float hoverImageDisAppearScale_ = 1.0f;
diff --git a/frameworks/core/components_ng/pattern/menu/wrapper/menu_wrapper_pattern.h b/frameworks/core/components_ng/pattern/menu/wrapper/menu_wrapper_pattern.h
index df72a27b3e3d41cb53661f6cadd9df15b814ba92..ee0a10d0e17efaf0f15f63f85cae66f67812591a 100644
--- a/frameworks/core/components_ng/pattern/menu/wrapper/menu_wrapper_pattern.h
+++ b/frameworks/core/components_ng/pattern/menu/wrapper/menu_wrapper_pattern.h
@@ -121,28 +121,58 @@ public:
         return menu;
     }
 
-    RefPtr<FrameNode> GetPreview() const
+    RefPtr<FrameNode> GetHoverImageColNode() const
     {
         auto host = GetHost();
         CHECK_NULL_RETURN(host, nullptr);
-        auto preview = AceType::DynamicCast<FrameNode>(host->GetChildAtIndex(1));
-        CHECK_NULL_RETURN(preview, nullptr);
-        auto hoverImageCustomPreview = AceType::DynamicCast<FrameNode>(host->GetChildAtIndex(2));
-        CHECK_NULL_RETURN(hoverImageCustomPreview, preview);
-        if (hoverImageCustomPreview->GetTag() == V2::MENU_PREVIEW_ETS_TAG) {
-            return hoverImageCustomPreview;
+        auto node = AceType::DynamicCast<FrameNode>(host->GetChildAtIndex(1));
+        CHECK_NULL_RETURN(node, nullptr);
+        if (node->GetTag() != V2::COLUMN_ETS_TAG) {
+            return nullptr;
         }
-        return preview;
+        return node;
+    }
+
+    RefPtr<FrameNode> GetHoverImageStackNode() const
+    {
+        auto node = AceType::DynamicCast<FrameNode>(GetHoverImageColNode()->GetChildAtIndex(0));
+        CHECK_NULL_RETURN(node, nullptr);
+        if (node->GetTag() != V2::STACK_ETS_TAG) {
+            return nullptr;
+        }
+        return node;
     }
 
     RefPtr<FrameNode> GetHoverImagePreview() const
+    {
+        auto node = AceType::DynamicCast<FrameNode>(GetHoverImageStackNode()->GetChildAtIndex(0));
+        CHECK_NULL_RETURN(node, nullptr);
+        if (node->GetTag() != V2::IMAGE_ETS_TAG) {
+            return nullptr;
+        }
+        return node;
+    }
+
+    RefPtr<FrameNode> GetHoverImageCustomPreview() const
+    {
+        auto node = AceType::DynamicCast<FrameNode>(GetHoverImageStackNode()->GetChildAtIndex(1));
+        CHECK_NULL_RETURN(node, nullptr);
+        if (node->GetTag() != V2::MENU_PREVIEW_ETS_TAG) {
+            return nullptr;
+        }
+        return node;
+    }
+
+    RefPtr<FrameNode> GetPreview() const
     {
         auto host = GetHost();
         CHECK_NULL_RETURN(host, nullptr);
         auto preview = AceType::DynamicCast<FrameNode>(host->GetChildAtIndex(1));
         CHECK_NULL_RETURN(preview, nullptr);
-        if (preview->GetTag() != V2::IMAGE_ETS_TAG) {
-            return nullptr;
+        if (preview->GetTag() == V2::COLUMN_ETS_TAG) {
+            auto hoverImageCustomPreview = GetHoverImageCustomPreview();
+            CHECK_NULL_RETURN(hoverImageCustomPreview, preview);
+            return hoverImageCustomPreview;
         }
         return preview;
     }
@@ -154,10 +184,6 @@ public:
         CHECK_NULL_RETURN(host, nullptr);
         auto badgeNode = AceType::DynamicCast<FrameNode>(host->GetChildAtIndex(2));
         CHECK_NULL_RETURN(badgeNode, nullptr);
-        if (badgeNode->GetTag() == V2::MENU_PREVIEW_ETS_TAG) {
-            auto badgeNode = AceType::DynamicCast<FrameNode>(host->GetChildAtIndex(3));
-            CHECK_NULL_RETURN(badgeNode, nullptr);
-        }
         if (badgeNode->GetTag() != V2::TEXT_ETS_TAG) {
             return nullptr;
         }
diff --git a/frameworks/core/components_ng/pattern/overlay/overlay_manager.cpp b/frameworks/core/components_ng/pattern/overlay/overlay_manager.cpp
index 98fc8f3ffb65993c22cf376659f405589b82faa0..72f710012864255f9005bfa9e92acb9d9dd21535 100644
--- a/frameworks/core/components_ng/pattern/overlay/overlay_manager.cpp
+++ b/frameworks/core/components_ng/pattern/overlay/overlay_manager.cpp
@@ -128,6 +128,9 @@ const RefPtr<Curve> HIDE_CUSTOM_KEYBOARD_ANIMATION_CURVE =
 
 const RefPtr<InterpolatingSpring> MENU_ANIMATION_CURVE =
     AceType::MakeRefPtr<InterpolatingSpring>(0.0f, 1.0f, 228.0f, 22.0f);
+
+const RefPtr<Curve> CUSTOM_PREVIEW_ANIMATION_CURVE =
+    AceType::MakeRefPtr<InterpolatingSpring>(0.0f, 1.0f, 280.0f, 30.0f);
 constexpr double MENU_ORIGINAL_SCALE = 0.6f;
 constexpr int32_t DUMP_LOG_DEPTH_1 = 1;
 constexpr int32_t DUMP_LOG_DEPTH_2 = 2;
@@ -168,7 +171,7 @@ void ShowPreviewBgDisappearAnimationProc(const RefPtr<RenderContext>& previewRen
     });
 }
 
-void ShowHoverImagePreviewDisappearAnimation(const RefPtr<MenuTheme>& menuTheme,
+void UpdateHoverImagePreviewOpacityAnimation(const RefPtr<MenuTheme>& menuTheme,
     const RefPtr<MenuPattern>& menuPattern, RefPtr<FrameNode>& previewChild)
 {
     CHECK_NULL_VOID(menuPattern);
@@ -178,34 +181,26 @@ void ShowHoverImagePreviewDisappearAnimation(const RefPtr<MenuTheme>& menuTheme,
     auto previewRenderContext = previewChild->GetRenderContext();
     CHECK_NULL_VOID(previewRenderContext);
 
-    auto duration = menuTheme->GetHoverImageDisAppearDuration();
-    if (previewChild->GetTag() == V2::MENU_PREVIEW_ETS_TAG) {
-        auto previewPattern = previewChild->GetPattern<MenuPreviewPattern>();
-        CHECK_NULL_VOID(previewPattern);
-        // reverse scale
-        auto disappearScaleFrom = previewPattern->GetCustomPreviewScaleTo();
-        auto disappearScaleTo = previewPattern->GetCustomPreviewScaleFrom();
-        duration = menuTheme->GetHoverImagePreviewDisAppearDuration();
-        previewPattern->ShowHoverImagePreviewDisAppearAnimation(previewRenderContext,
-            disappearScaleFrom, disappearScaleTo, duration);
-        // not proc next
-        return;
-    }
+    bool isCustomPreview = previewChild->GetTag() == V2::MENU_PREVIEW_ETS_TAG;
+    auto duration = isCustomPreview ? menuTheme->GetHoverImagePreviewDisAppearDuration() :
+        menuTheme->GetHoverImageDisAppearDuration();
+    auto opacityStart = isCustomPreview ? 1.0f : 0.0f;
+    auto opacityEnd = isCustomPreview ? 0.0f : 1.0f;
 
-    // hover image update opacity
-    previewRenderContext->UpdateOpacity(0.0);
+    // update image or custom preview opacity
+    previewRenderContext->UpdateOpacity(opacityStart);
     AnimationOption option;
     option.SetDuration(duration);
     option.SetCurve(Curves::FRICTION);
     AnimationUtils::Animate(
-        option, [previewRenderContext]() {
+        option, [previewRenderContext, opacityEnd]() {
             CHECK_NULL_VOID(previewRenderContext);
-            previewRenderContext->UpdateOpacity(1.0);
+            previewRenderContext->UpdateOpacity(opacityEnd);
         });
 }
 
 void ShowPreviewDisappearAnimationProc(const RefPtr<MenuWrapperPattern>& menuWrapperPattern,
-    RefPtr<FrameNode>& previewChild, float xDist = 0.0f, float yDist = 0.0f)
+    RefPtr<FrameNode>& previewChild)
 {
     CHECK_NULL_VOID(menuWrapperPattern);
     CHECK_NULL_VOID(previewChild);
@@ -227,17 +222,15 @@ void ShowPreviewDisappearAnimationProc(const RefPtr<MenuWrapperPattern>& menuWra
     CHECK_NULL_VOID(pipelineContext);
     auto menuTheme = pipelineContext->GetTheme<MenuTheme>();
     CHECK_NULL_VOID(menuTheme);
-    ShowHoverImagePreviewDisappearAnimation(menuTheme, menuPattern, previewChild);
+    UpdateHoverImagePreviewOpacityAnimation(menuTheme, menuPattern, previewChild);
 
     auto springMotionResponse = menuTheme->GetPreviewDisappearSpringMotionResponse();
     auto springMotionDampingFraction = menuTheme->GetPreviewDisappearSpringMotionDampingFraction();
     AnimationOption scaleOption;
     auto motion = AceType::MakeRefPtr<ResponsiveSpringMotion>(springMotionResponse, springMotionDampingFraction);
     scaleOption.SetCurve(motion);
-    bool isImagePreview = menuPattern->GetPreviewMode() == MenuPreviewMode::IMAGE ||
-        (menuPattern->GetIsShowHoverImage() && previewChild->GetTag() == V2::IMAGE_ETS_TAG);
     float previewScale = 1.0f;
-    if (isImagePreview) {
+    if (menuPattern->GetPreviewMode() == MenuPreviewMode::IMAGE) {
         auto previewGeometryNode = previewChild->GetGeometryNode();
         CHECK_NULL_VOID(previewGeometryNode);
         auto preivewSize = previewGeometryNode->GetFrameSize();
@@ -245,18 +238,65 @@ void ShowPreviewDisappearAnimationProc(const RefPtr<MenuWrapperPattern>& menuWra
             previewScale = menuPattern->GetTargetSize().Width() / preivewSize.Width();
         }
     }
+    ShowPreviewBgDisappearAnimationProc(previewRenderContext, menuTheme);
 
-    auto xPosition = previewPosition.GetX() + xDist;
-    auto yPosition = previewPosition.GetY() + yDist;
+    CHECK_NULL_VOID(!menuPattern->GetIsShowHoverImage());
     AnimationUtils::Animate(scaleOption,
-        [previewRenderContext, xPosition, yPosition, previewScale, isImagePreview]() {
+        [previewRenderContext, previewPosition, previewScale]() {
         CHECK_NULL_VOID(previewRenderContext);
         previewRenderContext->UpdatePosition(
-            OffsetT<Dimension>(Dimension(xPosition), Dimension(yPosition)));
-        CHECK_NULL_VOID(isImagePreview);
+            OffsetT<Dimension>(Dimension(previewPosition.GetX()), Dimension(previewPosition.GetY())));
         previewRenderContext->UpdateTransformScale(VectorF(previewScale, previewScale));
     });
-    ShowPreviewBgDisappearAnimationProc(previewRenderContext, menuTheme);
+}
+
+void UpdateHoverImageDisappearScaleAndPosition(const RefPtr<MenuWrapperPattern>& menuWrapperPattern,
+    const RefPtr<MenuPreviewPattern>& previewPattern)
+{
+    CHECK_NULL_VOID(menuWrapperPattern);
+    CHECK_NULL_VOID(menuWrapperPattern->GetIsShowHoverImage());
+
+    CHECK_NULL_VOID(previewPattern);
+    // reverse scale
+    auto scaleFrom = previewPattern->GetCustomPreviewScaleTo();
+    auto scaleTo = previewPattern->GetHoverImageScaleFrom();
+    auto pipelineContext = PipelineContext::GetCurrentContext();
+    CHECK_NULL_VOID(pipelineContext);
+    auto menuTheme = pipelineContext->GetTheme<MenuTheme>();
+    CHECK_NULL_VOID(menuTheme);
+    auto scaleBefore = LessNotEqual(scaleFrom, 0.0) ? menuTheme->GetPreviewAfterAnimationScale() : scaleFrom;
+    auto scaleAfter = LessNotEqual(scaleTo, 0.0) ? menuTheme->GetPreviewBeforeAnimationScale() : scaleTo;
+
+    auto stackNode = menuWrapperPattern->GetHoverImageStackNode();
+    CHECK_NULL_VOID(stackNode);
+    auto stackContext = stackNode->GetRenderContext();
+    CHECK_NULL_VOID(stackContext);
+    stackContext->UpdateTransformScale(VectorF(scaleBefore, scaleBefore));
+
+    auto colNode = menuWrapperPattern->GetHoverImageColNode();
+    CHECK_NULL_VOID(colNode);
+    auto colContext = colNode->GetRenderContext();
+    CHECK_NULL_VOID(colContext);
+    
+    auto menuChild = menuWrapperPattern->GetMenu();
+    CHECK_NULL_VOID(menuChild);
+    auto menuPattern = menuChild->GetPattern<MenuPattern>();
+    CHECK_NULL_VOID(menuPattern);
+    auto previewPosition = menuPattern->GetPreviewOriginOffset();
+
+    AnimationOption option = AnimationOption();
+    option.SetCurve(CUSTOM_PREVIEW_ANIMATION_CURVE);
+    AnimationUtils::Animate(
+        option, [stackContext, scaleAfter, colContext, previewPosition]() {
+            CHECK_NULL_VOID(stackContext);
+            stackContext->UpdateTransformScale(VectorF(scaleAfter, scaleAfter));
+
+            CHECK_NULL_VOID(colContext);
+            colContext->UpdatePosition(
+                OffsetT<Dimension>(Dimension(previewPosition.GetX()), Dimension(previewPosition.GetY())));
+        });
+
+    ShowPreviewBgDisappearAnimationProc(stackContext, menuTheme);
 }
 
 void ShowPreviewDisappearAnimation(const RefPtr<MenuWrapperPattern>& menuWrapperPattern)
@@ -269,11 +309,11 @@ void ShowPreviewDisappearAnimation(const RefPtr<MenuWrapperPattern>& menuWrapper
     CHECK_NULL_VOID(menuWrapperPattern->GetIsShowHoverImage());
     auto hoverImagePreview = menuWrapperPattern->GetHoverImagePreview();
     CHECK_NULL_VOID(hoverImagePreview);
+    ShowPreviewDisappearAnimationProc(menuWrapperPattern, hoverImagePreview);
+
     auto previewPattern = previewChild->GetPattern<MenuPreviewPattern>();
     CHECK_NULL_VOID(previewPattern);
-    auto xDist = previewPattern->GetCustomPreviewPositionXDist();
-    auto yDist = previewPattern->GetCustomPreviewPositionYDist();
-    ShowPreviewDisappearAnimationProc(menuWrapperPattern, hoverImagePreview, xDist, yDist);
+    UpdateHoverImageDisappearScaleAndPosition(menuWrapperPattern, previewPattern);
 }
 
 void UpdateContextMenuDisappearPositionAnimation(const RefPtr<FrameNode>& menu, const NG::OffsetF& offset)