/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#include "DrawCommandDispatch.hxx"
#include <ChartController.hxx>
#include <DrawViewWrapper.hxx>
#include <chartview/DrawModelWrapper.hxx>
 
#include <com/sun/star/frame/CommandGroup.hpp>
#include <o3tl/unsafe_downcast.hxx>
#include <o3tl/string_view.hxx>
#include <vcl/svapp.hxx>
#include <editeng/eeitem.hxx>
#include <svx/strings.hrc>
#include <svx/dialmgr.hxx>
#include <svx/fmmodel.hxx>
#include <svx/gallery.hxx>
#include <svx/svdoashp.hxx>
#include <svx/svdocapt.hxx>
#include <svx/svdopath.hxx>
#include <svx/svdpage.hxx>
#include <svx/unoapi.hxx>
#include <svx/xlnedit.hxx>
#include <svx/xlnedwit.hxx>
#include <svx/xlnwtit.hxx>
#include <svx/xtable.hxx>
#include <svx/sdtagitm.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
 
using namespace ::com::sun::star;
using namespace ::com::sun::star::frame;
 
using ::com::sun::star::uno::Reference;
using ::com::sun::star::uno::Sequence;
 
 
namespace chart
{
 
DrawCommandDispatch::DrawCommandDispatch( const Reference< uno::XComponentContext >& rxContext,
    ChartController* pController )
    :FeatureCommandDispatchBase( rxContext )
    ,m_pChartController( pController )
{
}
 
DrawCommandDispatch::~DrawCommandDispatch()
{
}
 
bool DrawCommandDispatch::isFeatureSupported( const OUString& rCommandURL )
{
    ChartCommandID nFeatureId = ChartCommandID::NONE;
    OUString aBaseCommand;
    OUString aCustomShapeType;
    return parseCommandURL( rCommandURL, &nFeatureId, &aBaseCommand, &aCustomShapeType );
}
 
static ::basegfx::B2DPolyPolygon getPolygon(TranslateId pResId, const SdrModel& rModel)
{
    ::basegfx::B2DPolyPolygon aReturn;
    XLineEndListRef pLineEndList = rModel.GetLineEndList();
    if ( pLineEndList.is() )
    {
        OUString aName(SvxResId(pResId));
        tools::Long nCount = pLineEndList->Count();
        for ( tools::Long nIndex = 0; nIndex < nCount; ++nIndex )
        {
            const XLineEndEntry* pEntry = pLineEndList->GetLineEnd(nIndex);
            if ( pEntry->GetName() == aName )
            {
                aReturn = pEntry->GetLineEnd();
                break;
            }
        }
    }
    return aReturn;
}
 
void DrawCommandDispatch::setAttributes( SdrObject* pObj )
{
    if ( !m_pChartController )
        return;
 
    DrawModelWrapper* pDrawModelWrapper = m_pChartController->GetDrawModelWrapper();
    DrawViewWrapper* pDrawViewWrapper = m_pChartController->GetDrawViewWrapper();
    if ( !(pDrawModelWrapper && pDrawViewWrapper && pDrawViewWrapper->GetCurrentObjIdentifier() == SdrObjKind::CustomShape) )
        return;
 
    bool bAttributesAppliedFromGallery = false;
    if ( GalleryExplorer::GetSdrObjCount( GALLERY_THEME_POWERPOINT ) )
    {
        std::vector< OUString > aObjList;
        if ( GalleryExplorer::FillObjListTitle( GALLERY_THEME_POWERPOINT, aObjList ) )
        {
            for ( size_t i = 0; i < aObjList.size(); ++i )
            {
                if ( aObjList[ i ].equalsIgnoreAsciiCase( m_aCustomShapeType ) )
                {
                    FmFormModel aModel;
 
                    if ( GalleryExplorer::GetSdrObj( GALLERY_THEME_POWERPOINT, i, &aModel ) )
                    {
                        const SdrObject* pSourceObj = aModel.GetPage( 0 )->GetObj( 0 );
                        if ( pSourceObj )
                        {
                            const SfxItemSet& rSource = pSourceObj->GetMergedItemSet();
                            SfxItemSetFixed<
                                    // Ranges from SdrAttrObj:
                                    SDRATTR_START, SDRATTR_SHADOW_LAST,
                                    SDRATTR_MISC_FIRST,
                                        SDRATTR_MISC_LAST,
                                    SDRATTR_TEXTDIRECTION,
                                        SDRATTR_TEXTDIRECTION,
                                    // Graphic attributes, 3D
                                    // properties, CustomShape
                                    // properties:
                                    SDRATTR_GRAF_FIRST,
                                        SDRATTR_CUSTOMSHAPE_LAST,
                                    // Range from SdrTextObj:
                                    EE_ITEMS_START, EE_ITEMS_END>
                                aDest(pObj->getSdrModelFromSdrObject().GetItemPool());
                            aDest.Set( rSource );
                            pObj->SetMergedItemSet( aDest );
                            Degree100 nAngle = pSourceObj->GetRotateAngle();
                            if ( nAngle )
                                pObj->NbcRotate( pObj->GetSnapRect().Center(), nAngle );
                            bAttributesAppliedFromGallery = true;
                        }
                    }
                    break;
                }
            }
        }
    }
    if ( !bAttributesAppliedFromGallery )
    {
        pObj->SetMergedItem( SdrTextVertAdjustItem( SDRTEXTVERTADJUST_CENTER ) );
        pObj->SetMergedItem( SdrTextHorzAdjustItem( SDRTEXTHORZADJUST_BLOCK ) );
        pObj->SetMergedItem( makeSdrTextAutoGrowHeightItem( false ) );
 
        o3tl::unsafe_downcast< SdrObjCustomShape* >( pObj )->MergeDefaultAttributes( &m_aCustomShapeType );
    }
}
 
void DrawCommandDispatch::setLineEnds( SfxItemSet& rAttr )
{
    if ( !(m_nFeatureId == ChartCommandID::DrawLineArrowEnd && m_pChartController) )
        return;
 
    DrawModelWrapper* pDrawModelWrapper = m_pChartController->GetDrawModelWrapper();
    DrawViewWrapper* pDrawViewWrapper = m_pChartController->GetDrawViewWrapper();
    if ( !(pDrawModelWrapper && pDrawViewWrapper) )
        return;
 
    ::basegfx::B2DPolyPolygon aArrow( getPolygon( RID_SVXSTR_ARROW, pDrawModelWrapper->getSdrModel() ) );
    if ( !aArrow.count() )
    {
        ::basegfx::B2DPolygon aNewArrow;
        aNewArrow.append( ::basegfx::B2DPoint( 10.0, 0.0 ) );
        aNewArrow.append( ::basegfx::B2DPoint( 0.0, 30.0) );
        aNewArrow.append( ::basegfx::B2DPoint( 20.0, 30.0 ) );
        aNewArrow.setClosed( true );
        aArrow.append( aNewArrow );
    }
 
    SfxItemSet aSet(pDrawViewWrapper->GetModel().GetItemPool());
    pDrawViewWrapper->GetAttributes( aSet );
 
    tools::Long nWidth = 300; // (1/100th mm)
    if ( aSet.GetItemState( XATTR_LINEWIDTH ) != SfxItemState::INVALID )
    {
        tools::Long nValue = aSet.Get( XATTR_LINEWIDTH ).GetValue();
        if ( nValue > 0 )
        {
            nWidth = nValue * 3;
        }
    }
 
    rAttr.Put( XLineEndItem( SvxResId( RID_SVXSTR_ARROW ), std::move(aArrow) ) );
    rAttr.Put( XLineEndWidthItem( nWidth ) );
}
 
// WeakComponentImplHelperBase
void DrawCommandDispatch::disposing(std::unique_lock<std::mutex>& /*rGuard*/)
{
}
 
// XEventListener
void DrawCommandDispatch::disposing( const lang::EventObject& /* Source */ )
{
}
 
FeatureState DrawCommandDispatch::getState( const OUString& rCommand )
{
    FeatureState aReturn;
    aReturn.bEnabled = false;
    aReturn.aState <<= false;
 
    ChartCommandID nFeatureId = ChartCommandID::NONE;
    OUString aBaseCommand;
    OUString aCustomShapeType;
    if ( parseCommandURL( rCommand, &nFeatureId, &aBaseCommand, &aCustomShapeType ) )
    {
        switch ( nFeatureId )
        {
            case ChartCommandID::DrawObjectSelect:
            case ChartCommandID::DrawLine:
            case ChartCommandID::DrawLineArrowEnd:
            case ChartCommandID::DrawRect:
            case ChartCommandID::DrawEllipse:
            case ChartCommandID::DrawFreelineNoFill:
            case ChartCommandID::DrawText:
            case ChartCommandID::DrawCaption:
            case ChartCommandID::DrawToolboxCsBasic:
            case ChartCommandID::DrawToolboxCsSymbol:
            case ChartCommandID::DrawToolboxCsArrow:
            case ChartCommandID::DrawToolboxCsFlowchart:
            case ChartCommandID::DrawToolboxCsCallout:
            case ChartCommandID::DrawToolboxCsStar:
                {
                    aReturn.bEnabled = true;
                    aReturn.aState <<= false;
                }
                break;
            default:
                {
                    aReturn.bEnabled = false;
                    aReturn.aState <<= false;
                }
                break;
        }
    }
 
    return aReturn;
}
 
void DrawCommandDispatch::execute( const OUString& rCommand, const Sequence< beans::PropertyValue>& rArgs )
{
    ChartDrawMode eDrawMode = CHARTDRAW_SELECT;
    SdrObjKind eKind = SdrObjKind::NONE;
 
    ChartCommandID nFeatureId = ChartCommandID::NONE;
    OUString aBaseCommand;
    OUString aCustomShapeType;
    if ( !parseCommandURL( rCommand, &nFeatureId, &aBaseCommand, &aCustomShapeType ) )
        return;
 
    bool bCreate = false;
    m_nFeatureId = nFeatureId;
    m_aCustomShapeType = aCustomShapeType;
 
    switch ( nFeatureId )
    {
        case ChartCommandID::DrawObjectSelect:
            {
                eDrawMode = CHARTDRAW_SELECT;
                eKind = SdrObjKind::NONE;
            }
            break;
        case ChartCommandID::DrawLine:
        case ChartCommandID::DrawLineArrowEnd:
            {
                eDrawMode = CHARTDRAW_INSERT;
                eKind = SdrObjKind::Line;
            }
            break;
        case ChartCommandID::DrawRect:
            {
                eDrawMode = CHARTDRAW_INSERT;
                eKind = SdrObjKind::Rectangle;
            }
            break;
        case ChartCommandID::DrawEllipse:
            {
                eDrawMode = CHARTDRAW_INSERT;
                eKind = SdrObjKind::CircleOrEllipse;
            }
            break;
        case ChartCommandID::DrawFreelineNoFill:
            {
                eDrawMode = CHARTDRAW_INSERT;
                eKind = SdrObjKind::FreehandLine;
            }
            break;
        case ChartCommandID::DrawText:
            {
                eDrawMode = CHARTDRAW_INSERT;
                eKind = SdrObjKind::Text;
                bCreate = true;
            }
            break;
        case ChartCommandID::DrawCaption:
            {
                eDrawMode = CHARTDRAW_INSERT;
                eKind = SdrObjKind::Caption;
            }
            break;
        case ChartCommandID::DrawToolboxCsBasic:
        case ChartCommandID::DrawToolboxCsSymbol:
        case ChartCommandID::DrawToolboxCsArrow:
        case ChartCommandID::DrawToolboxCsFlowchart:
        case ChartCommandID::DrawToolboxCsCallout:
        case ChartCommandID::DrawToolboxCsStar:
            {
                eDrawMode = CHARTDRAW_INSERT;
                eKind = SdrObjKind::CustomShape;
            }
            break;
        default:
            {
                eDrawMode = CHARTDRAW_SELECT;
                eKind = SdrObjKind::NONE;
            }
            break;
    }
 
    if ( !m_pChartController )
        return;
 
    DrawViewWrapper* pDrawViewWrapper = m_pChartController->GetDrawViewWrapper();
    if ( !pDrawViewWrapper )
        return;
 
    SolarMutexGuard aGuard;
    m_pChartController->setDrawMode( eDrawMode );
    setInsertObj(eKind);
    if ( bCreate )
    {
        pDrawViewWrapper->SetCreateMode();
    }
 
    const beans::PropertyValue* pKeyModifier = std::find_if(rArgs.begin(), rArgs.end(),
                                                    [](const beans::PropertyValue& lhs)
                                                    {return lhs.Name == "KeyModifier";} );
    sal_Int16 nKeyModifier = 0;
    if ( !(pKeyModifier != rArgs.end() && ( pKeyModifier->Value >>= nKeyModifier ) && nKeyModifier == KEY_MOD1) )
        return;
 
    if ( eDrawMode != CHARTDRAW_INSERT )
        return;
 
    rtl::Reference<SdrObject> pObj = createDefaultObject( nFeatureId );
    if ( pObj )
    {
        SdrPageView* pPageView = pDrawViewWrapper->GetSdrPageView();
        if (pDrawViewWrapper->InsertObjectAtView(pObj.get(), *pPageView))
            m_pChartController->SetAndApplySelection(Reference<drawing::XShape>(pObj->getUnoShape(), uno::UNO_QUERY));
        if ( nFeatureId == ChartCommandID::DrawText )
        {
            m_pChartController->StartTextEdit();
        }
    }
}
 
void DrawCommandDispatch::describeSupportedFeatures()
{
    implDescribeSupportedFeature( ".uno:SelectObject",      ChartCommandID::DrawObjectSelect,           CommandGroup::INSERT );
    implDescribeSupportedFeature( ".uno:Line",              ChartCommandID::DrawLine,               CommandGroup::INSERT );
    implDescribeSupportedFeature( ".uno:LineArrowEnd",      ChartCommandID::DrawLineArrowEnd,          CommandGroup::INSERT );
    implDescribeSupportedFeature( ".uno:Rect",              ChartCommandID::DrawRect,               CommandGroup::INSERT );
    implDescribeSupportedFeature( ".uno:Ellipse",           ChartCommandID::DrawEllipse,            CommandGroup::INSERT );
    implDescribeSupportedFeature( ".uno:Freeline_Unfilled", ChartCommandID::DrawFreelineNoFill,    CommandGroup::INSERT );
    implDescribeSupportedFeature( ".uno:DrawText",          ChartCommandID::DrawText,               CommandGroup::INSERT );
    implDescribeSupportedFeature( ".uno:DrawCaption",       ChartCommandID::DrawCaption,            CommandGroup::INSERT );
    implDescribeSupportedFeature( ".uno:BasicShapes",       ChartCommandID::DrawToolboxCsBasic,        CommandGroup::INSERT );
    implDescribeSupportedFeature( ".uno:SymbolShapes",      ChartCommandID::DrawToolboxCsSymbol,       CommandGroup::INSERT );
    implDescribeSupportedFeature( ".uno:ArrowShapes",       ChartCommandID::DrawToolboxCsArrow,        CommandGroup::INSERT );
    implDescribeSupportedFeature( ".uno:FlowChartShapes",   ChartCommandID::DrawToolboxCsFlowchart,    CommandGroup::INSERT );
    implDescribeSupportedFeature( ".uno:CalloutShapes",     ChartCommandID::DrawToolboxCsCallout,      CommandGroup::INSERT );
    implDescribeSupportedFeature( ".uno:StarShapes",        ChartCommandID::DrawToolboxCsStar,         CommandGroup::INSERT );
}
 
void DrawCommandDispatch::setInsertObj(SdrObjKind eObj)
{
    DrawViewWrapper* pDrawViewWrapper = ( m_pChartController ? m_pChartController->GetDrawViewWrapper() : nullptr );
    if ( pDrawViewWrapper )
    {
        pDrawViewWrapper->SetCurrentObj( eObj /*, Inventor */);
    }
}
 
rtl::Reference<SdrObject> DrawCommandDispatch::createDefaultObject( const ChartCommandID nID )
{
    rtl::Reference<SdrObject> pObj;
    DrawViewWrapper* pDrawViewWrapper = ( m_pChartController ? m_pChartController->GetDrawViewWrapper() : nullptr );
    DrawModelWrapper* pDrawModelWrapper = ( m_pChartController ? m_pChartController->GetDrawModelWrapper() : nullptr );
 
    if ( pDrawViewWrapper && pDrawModelWrapper )
    {
        Reference< drawing::XDrawPage > xDrawPage( pDrawModelWrapper->getMainDrawPage() );
        SdrPage* pPage = GetSdrPageFromXDrawPage( xDrawPage );
        if ( pPage )
        {
            SolarMutexGuard aGuard;
 
            pObj = SdrObjFactory::MakeNewObject(
                pDrawModelWrapper->getSdrModel(),
                pDrawViewWrapper->GetCurrentObjInventor(),
                pDrawViewWrapper->GetCurrentObjIdentifier());
 
            if ( pObj )
            {
                Size aObjectSize( 4000, 2500 );
                tools::Rectangle aPageRect( tools::Rectangle( Point( 0, 0 ), pPage->GetSize() ) );
                Point aObjectPos = aPageRect.Center();
                aObjectPos.AdjustX( -(aObjectSize.Width() / 2) );
                aObjectPos.AdjustY( -(aObjectSize.Height() / 2) );
                tools::Rectangle aRect( aObjectPos, aObjectSize );
 
                switch ( nID )
                {
                    case ChartCommandID::DrawLine:
                    case ChartCommandID::DrawLineArrowEnd:
                        {
                            if ( auto const pathObj = dynamic_cast<SdrPathObj*>( pObj.get()) )
                            {
                                Point aStart = aRect.TopLeft();
                                Point aEnd = aRect.BottomRight();
                                sal_Int32 nYMiddle( ( aRect.Top() + aRect.Bottom() ) / 2 );
                                basegfx::B2DPolygon aPoly;
                                aPoly.append( basegfx::B2DPoint( aStart.X(), nYMiddle ) );
                                aPoly.append( basegfx::B2DPoint( aEnd.X(), nYMiddle ) );
                                pathObj->SetPathPoly(basegfx::B2DPolyPolygon(aPoly));
                                SfxItemSet aSet( pDrawModelWrapper->GetItemPool() );
                                setLineEnds( aSet );
                                pObj->SetMergedItemSet( aSet );
                            }
                        }
                        break;
                    case ChartCommandID::DrawFreelineNoFill:
                        {
                            if ( auto const pathObj = dynamic_cast<SdrPathObj*>( pObj.get()) )
                            {
                                basegfx::B2DPolygon aInnerPoly;
                                aInnerPoly.append( basegfx::B2DPoint( aRect.Left(), aRect.Bottom() ) );
                                aInnerPoly.appendBezierSegment(
                                    basegfx::B2DPoint( aRect.Left(), aRect.Top() ),
                                    basegfx::B2DPoint( aRect.Center().X(), aRect.Top() ),
                                    basegfx::B2DPoint( aRect.Center().X(), aRect.Center().Y() ) );
                                aInnerPoly.appendBezierSegment(
                                    basegfx::B2DPoint( aRect.Center().X(), aRect.Bottom() ),
                                    basegfx::B2DPoint( aRect.Right(), aRect.Bottom() ),
                                    basegfx::B2DPoint( aRect.Right(), aRect.Top() ) );
                                basegfx::B2DPolyPolygon aPoly;
                                aPoly.append( aInnerPoly );
                                pathObj->SetPathPoly(aPoly);
                            }
                        }
                        break;
                    case ChartCommandID::DrawText:
                    case ChartCommandID::DrawTextVertical:
                        {
                            if ( SdrTextObj* pTextObj = DynCastSdrTextObj( pObj.get()) )
                            {
                                pTextObj->SetLogicRect( aRect );
                                bool bVertical = ( nID == ChartCommandID::DrawTextVertical );
                                pTextObj->SetVerticalWriting( bVertical );
                                if ( bVertical )
                                {
                                    SfxItemSet aSet( pDrawModelWrapper->GetItemPool() );
                                    aSet.Put( makeSdrTextAutoGrowWidthItem( true ) );
                                    aSet.Put( makeSdrTextAutoGrowHeightItem( false ) );
                                    aSet.Put( SdrTextVertAdjustItem( SDRTEXTVERTADJUST_TOP ) );
                                    aSet.Put( SdrTextHorzAdjustItem( SDRTEXTHORZADJUST_RIGHT ) );
                                    pTextObj->SetMergedItemSet( aSet );
                                }
                            }
                        }
                        break;
                    case ChartCommandID::DrawCaption:
                    case ChartCommandID::DrawCaptionVertical:
                        {
                            if ( SdrCaptionObj* pCaptionObj = dynamic_cast<SdrCaptionObj*>( pObj.get()) )
                            {
                                bool bIsVertical( nID == ChartCommandID::DrawCaptionVertical );
                                pCaptionObj->SetVerticalWriting( bIsVertical );
                                if ( bIsVertical )
                                {
                                    SfxItemSet aSet( pObj->GetMergedItemSet() );
                                    aSet.Put( SdrTextVertAdjustItem( SDRTEXTVERTADJUST_CENTER ) );
                                    aSet.Put( SdrTextHorzAdjustItem( SDRTEXTHORZADJUST_RIGHT ) );
                                    pObj->SetMergedItemSet( aSet );
                                }
                                pCaptionObj->SetLogicRect( aRect );
                                pCaptionObj->SetTailPos(
                                    aRect.TopLeft() - Point( aRect.GetWidth() / 2, aRect.GetHeight() / 2 ) );
                            }
                        }
                        break;
                    default:
                        {
                            pObj->SetLogicRect( aRect );
                            SfxItemSet aSet( pDrawModelWrapper->GetItemPool() );
                            setAttributes( pObj.get() );
                            pObj->SetMergedItemSet( aSet );
                        }
                        break;
                }
            }
        }
    }
 
    return pObj;
}
 
bool DrawCommandDispatch::parseCommandURL( const OUString& rCommandURL, ChartCommandID* pnFeatureId,
    OUString* pBaseCommand, OUString* pCustomShapeType )
{
    bool bFound = true;
    ChartCommandID nFeatureId = ChartCommandID::NONE;
    OUString aBaseCommand;
    OUString aType;
 
    sal_Int32 nIndex = std::min(sal_Int32(1), rCommandURL.getLength());
    std::u16string_view aToken = o3tl::getToken(rCommandURL, 0, '.', nIndex );
    if ( nIndex == -1 || aToken.empty() )
    {
        aBaseCommand = rCommandURL;
        SupportedFeatures::const_iterator aIter = m_aSupportedFeatures.find( aBaseCommand );
        if ( aIter != m_aSupportedFeatures.end() )
        {
            nFeatureId = aIter->second.nFeatureId;
 
            switch ( nFeatureId )
            {
                case ChartCommandID::DrawToolboxCsBasic:
                    {
                        aType = "diamond";
                    }
                    break;
                case ChartCommandID::DrawToolboxCsSymbol:
                    {
                        aType = "smiley";
                    }
                    break;
                case ChartCommandID::DrawToolboxCsArrow:
                    {
                        aType = "left-right-arrow";
                    }
                    break;
                case ChartCommandID::DrawToolboxCsFlowchart:
                    {
                        aType = "flowchart-internal-storage";
                    }
                    break;
                case ChartCommandID::DrawToolboxCsCallout:
                    {
                        aType = "round-rectangular-callout";
                    }
                    break;
                case ChartCommandID::DrawToolboxCsStar:
                    {
                        aType = "star5";
                    }
                    break;
                default:
                    {
                    }
                    break;
            }
        }
        else
        {
            bFound = false;
        }
    }
    else
    {
        aBaseCommand = rCommandURL.copy( 0, nIndex - 1 );
        SupportedFeatures::const_iterator aIter = m_aSupportedFeatures.find( aBaseCommand );
        if ( aIter != m_aSupportedFeatures.end() )
        {
            nFeatureId = aIter->second.nFeatureId;
            aType = rCommandURL.getToken( 0, '.', nIndex );
        }
        else
        {
            bFound = false;
        }
    }
 
    *pnFeatureId = nFeatureId;
    *pBaseCommand = aBaseCommand;
    *pCustomShapeType = aType;
 
    return bFound;
}
 
} //  namespace chart
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */