//
//////////////////////////////////////////////////////////////////////////////
//
//  Copyright 2013 Autodesk, Inc.  All rights reserved.
//
//  Use of this software is subject to the terms of the Autodesk license 
//  agreement provided at the time of installation or download, or which 
//  otherwise accompanies this software in either electronic or hard copy form.   
//
//////////////////////////////////////////////////////////////////////////////
//
#ifndef __DBMLEADERSTYLE_H__
#define __DBMLEADERSTYLE_H__

#pragma once

#include "AcString.h"

////////////////////////////////////////////////////////////////////////
// class AcDbMLeader
////////////////////////////////////////////////////////////////////////

/// <summary>
/// This class is the main class used for the multiple leader style object.
/// </summary>
///
/// <remarks>
/// </remarks>
///
class AcDbMLeaderStyle : public AcDbObject
{
public:
    /// <summary>
    /// This enum is content type of mleader.
    /// </summary>
    ///
    enum ContentType {
        /// <summary>
        /// mleader has none content
        /// </summary>
        ///
        /// <value>
        /// 0
        /// </value>
        kNoneContent                = 0,
        /// <summary>
        /// mleader has block content
        /// </summary>
        ///
        /// <value>
        /// 1
        /// </value>
        kBlockContent               = 1,
        /// <summary>
        /// mleader has mtext content
        /// </summary>
        ///
        /// <value>
        /// 2
        /// </value>
        kMTextContent               = 2,
        /// <summary>
        /// mleader has tolerance content
        /// </summary>
        ///
        /// <value>
        /// 3
        /// </value>
        kToleranceContent           = 3,
    };

    /// <summary>
    /// This enum is draw mleader order type.
    /// </summary>
    ///
    enum DrawMLeaderOrderType {
        /// <summary>
        /// draw mleader content first
        /// </summary>
        ///
        /// <value>
        /// 0
        /// </value>
        kDrawContentFirst           = 0,
        /// <summary>
        /// draw mleader leaderline first
        /// </summary>
        ///
        /// <value>
        /// 1
        /// </value>
        kDrawLeaderFirst            = 1
    };

    /// <summary>
    /// This enum is draw mleaderLine order type.
    /// </summary>
    ///
    enum DrawLeaderOrderType {
        /// <summary>
        /// draw leaderline head first
        /// </summary>
        ///
        /// <value>
        /// 0
        /// </value>
        kDrawLeaderHeadFirst        = 0,
        /// <summary>
        /// draw leaderline tail first
        /// </summary>
        ///
        /// <value>
        /// 1
        /// </value>
        kDrawLeaderTailFirst        = 1
    };

    /// <summary>
    /// This enum is leader type of mleader.
    /// </summary>
    ///
    enum LeaderType {
        /// <summary>
        /// invisible leader
        /// </summary>
        ///
        /// <value>
        /// 0
        /// </value>
        kInVisibleLeader            = 0,
        /// <summary>
        /// straight line leader
        /// </summary>
        ///
        /// <value>
        /// 1
        /// </value>
        kStraightLeader             = 1,
        /// <summary>
        /// spline line leader
        /// </summary>
        ///
        /// <value>
        /// 2
        /// </value>
        kSplineLeader               = 2
    };

    /// <summary>
    /// This enum is text attachment direction of mleader text content.
    /// </summary>
    ///
    enum TextAttachmentDirection {
        /// <summary>
        /// Horizontally attach to mtext content
        /// </summary>
        ///
        /// <value>
        /// 0
        /// </value>
        kAttachmentHorizontal       = 0,
        /// <summary>
        /// Vertically attach to mtext content
        /// </summary>
        ///
        /// <value>
        /// 1
        /// </value>
        kAttachmentVertical         = 1
    };

    /// <summary>
    /// This enum is text attachment type of mleader text content.
    /// </summary>
    ///
    enum TextAttachmentType {
        /// <summary>
        /// attach to top of top text line of mtext content
        /// </summary>
        ///
        /// <value>
        /// 0
        /// </value>
        kAttachmentTopOfTop         = 0,
        /// <summary>
        /// attach to middle of top text line of mtext content
        /// </summary>
        ///
        /// <value>
        /// 1
        /// </value>
        kAttachmentMiddleOfTop      = 1,
        /// <summary>
        /// attach to middle of mtext content
        /// </summary>
        ///
        /// <value>
        /// 2
        /// </value>
        kAttachmentMiddle           = 2,
        /// <summary>
        /// attach to middle of bottom text line of mtext content
        /// </summary>
        ///
        /// <value>
        /// 3
        /// </value>
        kAttachmentMiddleOfBottom   = 3,
        /// <summary>
        /// attach to bottom of bottom text line of mtext content
        /// </summary>
        ///
        /// <value>
        /// 4
        /// </value>
        kAttachmentBottomOfBottom   = 4,
        /// <summary>
        /// attach to bottom of bottom text line of mtext content and draw a underline
        /// </summary>
        ///
        /// <value>
        /// 5
        /// </value>
        kAttachmentBottomLine       = 5,
        /// <summary>
        /// attach to bottom of top text line of mtext content and draw a underline
        /// </summary>
        ///
        /// <value>
        /// 6
        /// </value>
        kAttachmentBottomOfTopLine  = 6,
        /// <summary>
        /// attach to bottom of top text line of mtext content
        /// </summary>
        ///
        /// <value>
        /// 7
        /// </value>
        kAttachmentBottomOfTop      = 7,
        /// <summary>
        /// attach to bottom of top text line of mtext content, and draw underline to whole mtext
        /// </summary>
        ///
        /// <value>
        /// 8
        /// </value>
        kAttachmentAllLine          = 8,
        /// <summary>
        /// vertically attach to center of mtext content top/bottom
        /// </summary>
        ///
        /// <value>
        /// 0
        /// </value>
        kAttachmentCenter           = 9,
        /// <summary>
        /// vertically attach to center of mtext content top/bottom, and draw a overline/underline
        /// </summary>
        ///
        /// <value>
        /// 1
        /// </value>
        kAttachmentLinedCenter      = 10
    };

    /// <summary>
    /// This enum is text angle type of mleader text content.
    /// </summary>
    ///
    enum TextAngleType {
        /// <summary>
        /// The direction of text is according to the last leaderline segment.
        /// </summary>
        ///
        /// <value>
        /// 0
        /// </value>
        kInsertAngle                = 0,
        /// <summary>
        /// The direction of text is always horizontal.
        /// </summary>
        ///
        /// <value>
        /// 1
        /// </value>
        kHorizontalAngle            = 1,
        /// <summary>
        /// The direction of text is according to the last leaderline segment and text is always right-side up.
        /// </summary>
        ///
        /// <value>
        /// 2
        /// </value>
        kAlwaysRightReadingAngle    = 2
    };

    /// <summary>
    /// This enum is text alignment type.
    /// </summary>
    ///
    enum TextAlignmentType {
        /// <summary>
        /// Left-justifies text in the MText.
        /// </summary>
        ///
        /// <value>
        /// 0
        /// </value>
        kLeftAlignment              = 0,
        /// <summary>
        /// Centers text in MText.
        /// </summary>
        ///
        /// <value>
        /// 1
        /// </value>
        kCenterAlignment            = 1,
        /// <summary>
        /// Right-justifies text in MText.
        /// </summary>
        ///
        /// <value>
        /// 2
        /// </value>
        kRightAlignment             = 2
    };

    /// <summary>
    /// This enum is block connection type of mleader block content.
    /// </summary>
    ///
    enum BlockConnectionType {
        /// <summary>
        /// Connect to extents of block.
        /// </summary>
        ///
        /// <value>
        /// 0
        /// </value>
        kConnectExtents             = 0,
        /// <summary>
        /// Connect to block base(origin) point.
        /// </summary>
        ///
        /// <value>
        /// 1
        /// </value>
        kConnectBase                = 1
    };

    /// <summary>
    /// This enum is leader direction type.
    /// </summary>
    ///
    enum LeaderDirectionType {
        /// <summary>
        /// unkown direction leader.
        /// </summary>
        ///
        /// <value>
        /// 0
        /// </value>
        kUnknownLeader              = 0,
        /// <summary>
        /// left leader.
        /// </summary>
        ///
        /// <value>
        /// 1
        /// </value>
        kLeftLeader                 = 1,
        /// <summary>
        /// right leader.
        /// </summary>
        ///
        /// <value>
        /// 2
        /// </value>
        kRightLeader                = 2,
        /// <summary>
        /// top leader.
        /// </summary>
        ///
        /// <value>
        /// 1
        /// </value>
        kTopLeader                  = 3,
        /// <summary>
        /// bottom leader.
        /// </summary>
        ///
        /// <value>
        /// 2
        /// </value>
        kBottomLeader               = 4
    };


    /// <summary>
    /// This enum is segment angle type.
    /// </summary>
    ///
    enum SegmentAngleType {
        /// <summary>
        /// Any degrees.
        /// </summary>
        ///
        /// <value>
        /// 0
        /// </value>
        kAny                        = 0, 
        /// <summary>
        /// 15 degrees.
        /// </summary>
        ///
        /// <value>
        /// 1
        /// </value>
        k15                         = 1,
        /// <summary>
        /// 30 degrees.
        /// </summary>
        ///
        /// <value>
        /// 2
        /// </value>
        k30                         = 2,
        /// <summary>
        /// 45 degrees.
        /// </summary>
        ///
        /// <value>
        /// 3
        /// </value>
        k45                         = 3,
        /// <summary>
        /// 60 degrees.
        /// </summary>
        ///
        /// <value>
        /// 4
        /// </value>
        k60                         = 4,
        /// <summary>
        /// 90 degrees.
        /// </summary>
        ///
        /// <value>
        /// 5
        /// </value>
        k90                         = 6,
        /// <summary>
        /// 180 degrees.
        /// </summary>
        ///
        /// <value>
        /// 6
        /// </value>
        kHorz                       = 12
    };

public:
    /// <summary>
    /// Default constructor.
    /// </summary>
    ///
    /// <remarks> 
    /// Default constructor.
    /// </remarks>
    ///
    AcDbMLeaderStyle();

    /// <summary>
    /// Default destructor.
    /// </summary>
    ///
    /// <remarks> 
    /// Default destructor.
    /// </remarks>
    ///
    virtual ~AcDbMLeaderStyle();

    ACDB_DECLARE_MEMBERS(AcDbMLeaderStyle);

    /// <summary>
    /// Get the name of AcDbMLeaderStyle
    /// </summary>
    ///
    /// <param name="pszName">
    /// Output the name of AcDbMLeaderStyle
    /// </param>
    ///
    /// <returns>
    /// Return Acae::eOk if Successful
    /// </returns>
    virtual Acad::ErrorStatus   getName(ACHAR*& pszName) const;

    /// <summary>
    /// Set the name of AcDbMLeaderStyle
    /// </summary>
    ///
    /// <param name="pszName">
    /// Input the name of AcDbMLeaderStyle
    /// </param>
    ///
    /// <returns>
    /// Return Acae::eOk if Successful
    /// </returns>
    virtual Acad::ErrorStatus   setName(const ACHAR * pszName);

    /// <summary>
    /// Return if the AcDbMLeaderStyle can be renamed.
    /// </summary>
    ///
    /// <returns>
    /// Return true if the AcDbMLeaderStyle is not Standard style.
    /// </returns>
    bool isRenamable() const;

    /// <summary>
    /// Return the pointer to a string containing the description of this mleader style.
    /// </summary>
    ///
    /// <returns>
    /// Return the pointer to a string containing the description of this mleader style.
    /// </returns>
    virtual const ACHAR*        description(void) const;

    /// <summary>
    /// Set the pointer to a string containing the description of this mleader style.
    /// </summary>
    ///
    /// <param name="pszDescription">
    /// Input the pointer to a string containing the description of this mleader style.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    virtual Acad::ErrorStatus   setDescription(const ACHAR * pszDescription);

    /// <summary>
    /// Return an unsigned integer representing the operation bit set for the AcDbMLeaderStyle object.
    /// </summary>
    ///
    /// <returns>
    /// Return an unsigned integer representing the operation bit set for the AcDbMLeaderStyle object.
    /// </returns>
    virtual Adesk::UInt32       bitFlags() const;

    /// <summary>
    /// Set the operation bit set for the AcDbMLeaderStyle object.
    /// </summary>
    ///
    /// <param name="flags">
    /// Input the operation bit set for the AcDbMLeaderStyle object.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    virtual Acad::ErrorStatus   setBitFlags(Adesk::UInt32 flags);

    /// <summary>
    /// Set the content type of AcDbMLeaderStyle.
    /// </summary>
    ///
    /// <param name="contentType">
    /// Input the content type
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setContentType                (ContentType contentType);

    /// <summary>
    /// Return the content type of AcDbMLeaderStyle.
    /// </summary>
    ///
    /// <returns>
    /// Return the content type of AcDbMLeaderStyle.
    /// </returns>
    ContentType               contentType                   () const;

    /// <summary>
    /// Set the order of MLeader creation.
    /// </summary>
    ///
    /// <param name="drawMLeaderOrderType">
    /// Input the order of MLeader creation
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setDrawMLeaderOrderType       (DrawMLeaderOrderType drawMLeaderOrderType);

    /// <summary>
    /// Return the order of MLeader creation.
    /// </summary>
    ///
    /// <returns>
    /// Return the order of MLeader creation.
    /// </returns>
    DrawMLeaderOrderType      drawMLeaderOrderType          () const;

    /// <summary>
    /// Set the order of Leader line creation when creating a MLeader.
    /// </summary>
    ///
    /// <param name="drawLeaderOrderType">
    /// Input the order of Leader line creation when creating a MLeader
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setDrawLeaderOrderType        (DrawLeaderOrderType drawLeaderOrderType);

    /// <summary>
    /// Return the order of Leader line creation when creating a MLeader.
    /// </summary>
    ///
    /// <returns>
    /// Return the order of Leader line creation when creating a MLeader.
    /// </returns>
    DrawLeaderOrderType       drawLeaderOrderType           () const;

    /// <summary>
    /// Set the max number of segment points in leader lines.
    /// </summary>
    ///
    /// <param name="maxLeaderSegmentsPoints">
    /// Input the max number of segment points in leader lines
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    /// 
    /// <remarks>
    /// If maxLeaderSegmentsPoints is 0, the max number of points is unlimited.
    /// </remarks>
    Acad::ErrorStatus         setMaxLeaderSegmentsPoints    (int maxLeaderSegmentsPoints);

    /// <summary>
    /// Return the max number of segment points in leader lines.
    /// </summary>
    ///
    /// <returns>
    /// Return the max number of segment points in leader lines.
    /// If the max number of points is unlimited, 0 will be returned.
    /// </returns>
    int                       maxLeaderSegmentsPoints       () const;

    /// <summary>
    /// Set the first segment angle constraint when creating a MLeader
    /// </summary>
    ///
    /// <param name="angle">
    /// Input the first segment angle constraint when creating a MLeader
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    /// 
    /// <remarks>
    /// If angle is kAny, the angle constraint is unused.
    /// </remarks>
    Acad::ErrorStatus         setFirstSegmentAngleConstraint (SegmentAngleType angle);

    /// <summary>
    /// Return the first segment angle constraint when creating a MLeader.
    /// </summary>
    ///
    /// <returns>
    /// Return the first segment angle constraint when creating a MLeader.
    /// If the angle constraint is unused, kAny will be returned.
    /// </returns>
    SegmentAngleType          firstSegmentAngleConstraint    () const;

    /// <summary>
    /// Set the second segment angle constraint when creating a MLeader
    /// </summary>
    ///
    /// <param name="angle">
    /// Input the second segment angle constraint when creating a MLeader
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful
    /// </returns>
    /// 
    /// <remarks>
    /// If angle is kAny, the angle constraint is unused.
    /// </remarks>
    Acad::ErrorStatus         setSecondSegmentAngleConstraint(SegmentAngleType angle);

    /// <summary>
    /// Return the second segment angle constraint when creating a MLeader.
    /// </summary>
    ///
    /// <returns>
    /// Return the second segment angle constraint when creating a MLeader.
    /// If the angle constraint is unused, kAny will be returned. 
    /// </returns>
    SegmentAngleType          secondSegmentAngleConstraint   () const;

    /// <summary>
    /// Set the leader line type.
    /// </summary>
    ///
    /// <param name="leaderLineType">
    /// Input the leader line type
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setLeaderLineType             (LeaderType leaderLineType);

    /// <summary>
    /// Return the leader line type.
    /// </summary>
    ///
    /// <returns>
    /// Return the leader line type.
    /// </returns>
    LeaderType                leaderLineType                () const;

    /// <summary>
    /// Set the color of leader lines.
    /// </summary>
    ///
    /// <param name="leaderLineColor">
    /// Input the color of leader lines
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setLeaderLineColor            (const AcCmColor& leaderLineColor);

    /// <summary>
    /// Return the color of leader lines.
    /// </summary>
    ///
    /// <returns>
    /// Return the color of leader lines.
    /// </returns>
    AcCmColor                 leaderLineColor               () const;

    /// <summary>
    /// Set the linetype of leader lines.
    /// </summary>
    ///
    /// <param name="leaderLineTypeId">
    /// Input the linetype Id.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setLeaderLineTypeId           (AcDbObjectId leaderLineTypeId);

    /// <summary>
    /// Return the linetype Id of leader lines.
    /// </summary>
    ///
    /// <returns>
    /// Return the linetype Id of leader lines.
    /// </returns>
    AcDbObjectId              leaderLineTypeId              () const;

    /// <summary>
    /// Set the line weight of leader lines.
    /// </summary>
    ///
    /// <param name="leaderLineWeight">
    /// Input the line weight of leader lines
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setLeaderLineWeight           (AcDb::LineWeight leaderLineWeight);

    /// <summary>
    /// Return the line weight of leader lines.
    /// </summary>
    ///
    /// <returns>
    /// Return the line weight of leader lines.
    /// </returns>
    AcDb::LineWeight          leaderLineWeight              () const;

    /// <summary>
    /// Enable/disable landing of leader line.
    /// </summary>
    ///
    /// <param name="enableLanding">
    /// Input boolean to enable/disable landing of leader line.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    ///
    /// <remarks>
    /// If disable landing, the landing gap will be ignored.
    /// </remarks>
    Acad::ErrorStatus         setEnableLanding              (bool enableLanding);

    /// <summary>
    /// Indicate whether landing of leader line is enabled.
    /// </summary>
    ///
    /// <returns>
    /// If landing of leader line is enabled, returns true; otherwise, returns false.
    /// </returns>
    bool                      enableLanding                 () const;

    /// <summary>
    /// Set the gap between MText and the tail of leader lines.
    /// </summary>
    ///
    /// <param name="landingGap">
    /// Input the gap between MText and the tail of leader lines.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setLandingGap                 (double landingGap);

    /// <summary>
    /// Return the gap between MText and the tail of leader lines.
    /// </summary>
    ///
    /// <returns>
    /// Return the gap between MText and the tail of leader lines.
    /// </returns>
    double                    landingGap                    () const;

    /// <summary>
    /// Enable or disable dog-leg leader lines.
    /// </summary>
    ///
    /// <param name="enableDogleg">
    /// Input boolean to enable/disable dog-leg leader lines.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setEnableDogleg               (bool enableDogleg);

    /// <summary>
    /// Indicate whether dog-leg leader lines are enabled.
    /// </summary>
    ///
    /// <returns>
    /// Return true if dog-leg leader lines are enabled; otherwise, returns false.
    /// </returns>
    bool                      enableDogleg                  () const;

    /// <summary>
    /// Return the length of dog-leg leader line.
    /// </summary>
    ///
    /// <param name="doglegLength">
    /// Input the length of dog-leg leader line.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setDoglegLength               (double doglegLength);

    /// <summary>
    /// Return the length of dog-leg leader line.
    /// </summary>
    ///
    /// <returns>
    /// Return the length of dog-leg leader line.
    /// </returns>
    double                    doglegLength                  () const;

    /// <summary>
    /// Set the arrow symbol id by arrow name.
    /// </summary>
    ///
    /// <param name="name">
    /// Input the name of arrow symbol.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setArrowSymbolId              (const ACHAR* name);

    /// <summary>
    /// Set the arrow symbol by objectId.
    /// </summary>
    ///
    /// <param name="arrowSymbolId">
    /// Input the objectId of arrow symbol.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setArrowSymbolId              (AcDbObjectId arrowSymbolId);

    /// <summary>
    /// Return objectId of the arrow symbol.
    /// </summary>
    ///
    /// <returns>
    /// Return objectId of the arrow symbol.
    /// </returns>
    AcDbObjectId              arrowSymbolId                 () const;

    /// <summary>
    /// Set the arrow size.
    /// </summary>
    ///
    /// <param name="arrowSize">
    /// Input arrow size.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setArrowSize                  (double arrowSize);

    /// <summary>
    /// Return arrow size.
    /// </summary>
    ///
    /// <returns>
    /// Return arrow size.
    /// </returns>
    double                    arrowSize                     () const;

    /// <summary>
    /// Set the default text displayed in MText of balloon content.
    /// </summary>
    ///
    /// <param name="defaultMText">
    /// Input the default text displayed in MText of balloon content.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    ///
    /// <remarks>
    /// This function just copies the mtext's content and fields.
    /// </remarks>
    Acad::ErrorStatus         setDefaultMText               (const AcDbMText* defaultMText);

    /// <summary>
    /// Return the default mtext
    /// </summary>
    ///
    /// <returns>
    /// Return the cloned mtext. If there is no default mtext, return NULL.
    /// </returns>
    AcDbMText*                defaultMText                  () const;

    /// <summary>
    /// Set text style by objectId.
    /// </summary>
    ///
    /// <param name="textStyleId">
    /// Input the objectId of text style.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setTextStyleId                (AcDbObjectId textStyleId);

    /// <summary>
    /// Return the objectId of text style.
    /// </summary>
    ///
    /// <returns>
    /// Return the objectId of text style.
    /// </returns>
    AcDbObjectId              textStyleId                   () const;

    /// <summary>
    /// Set the type of text attachment to specific direction leader.
    /// </summary>
    ///
    /// <param name="textAttachmentType">
    /// Input the type of text attachment.
    /// </param>
    /// <param name="leaderDirection">
    /// Input text leader direction type.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setTextAttachmentType         (TextAttachmentType textAttachmentType,
                                                             LeaderDirectionType leaderDirection);

    /// <summary>
    /// Returns text attachment type of specific direction leader.
    /// </summary>
    ///
    /// <param name="leaderDirection">
    /// Input text leader direction type.
    /// </param>
    ///
    /// <returns>
    /// Return text attachment type.
    /// </returns>
    TextAttachmentType        textAttachmentType            (LeaderDirectionType leaderDirection) const;

    /// <remarks>
    /// Deprecated: This method will be removed in a future release.
    /// Instead, use the method:
    /// <code>
    /// Acad::ErrorStatus setTextAttachmentType(TextAttachmentType textAttachmentType,
    ///                                         LeaderDirectionType leaderDirection);
    /// </code>
    /// </remarks>
    Acad::ErrorStatus         setTextAttachmentType         (TextAttachmentType textAttachmentType);

    /// <remarks>
    /// Deprecated: This method will be removed in a future release.
    /// Instead, use the method:
    /// <code>
    /// TextAttachmentType textAttachmentType(LeaderDirectionType leaderDirection) const;
    /// </code>
    /// </remarks>
    TextAttachmentType        textAttachmentType            () const;

    /// <summary>
    /// Set the angle type of text with respect to the last leader line segment.
    /// </summary>
    ///
    /// <param name="textAngleType">
    /// Input the angle type.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setTextAngleType              (TextAngleType textAngleType);

    /// <summary>
    /// Return the angle type of text with respect to the last leader line segment.
    /// </summary>
    ///
    /// <returns>
    /// Return the angle type of text with respect to the last leader line segment.
    /// </returns>
    TextAngleType             textAngleType                 () const;

    /// <summary>
    /// Set text alignment type.
    /// </summary>
    ///
    /// <param name="textAlignmentType">
    /// Input text alignment type.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setTextAlignmentType          (TextAlignmentType textAlignmentType);

    /// <summary>
    /// Return text alignment type.
    /// </summary>
    ///
    /// <returns>
    /// Return text alignment type.
    /// </returns>
    TextAlignmentType         textAlignmentType             () const;

    /// <summary>
    /// Input true to always align text on the left when creating a mleader.
    /// </summary>
    ///
    /// <param name="bAlwaysLeft">
    /// Input true to always align text on the left when creating a mleader.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setTextAlignAlwaysLeft        (bool bAlwaysLeft);

    /// <summary>
    /// Return true if always align text on the left when creating a mleader.
    /// </summary>
    ///
    /// <returns>
    /// Return true if always align text on the left when creating a mleader.
    /// </returns>
    bool                      textAlignAlwaysLeft           () const;

    /// <summary>
    /// Set text color of MText.
    /// </summary>
    ///
    /// <param name="textColor">
    /// Input the color.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setTextColor                  (const AcCmColor& textColor);

    /// <summary>
    /// Return text color of MText.
    /// </summary>
    ///
    /// <returns>
    /// Return text color of MText.
    /// </returns>
    AcCmColor                 textColor                     () const;

    /// <summary>
    /// Set the text height of MText.
    /// </summary>
    ///
    /// <param name="textHeight">
    /// Input text height.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setTextHeight                 (double textHeight);

    /// <summary>
    /// Return text height of MText.
    /// </summary>
    ///
    /// <returns>
    /// Return text height of MText.
    /// </returns>
    double                    textHeight                    () const;

    /// <summary>
    /// Display or hide text frame around the MText.
    /// </summary>
    ///
    /// <param name="enableFrameText">
    /// Input boolean to display/hide frame text.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setEnableFrameText            (bool enableFrameText);

    /// <summary>
    /// Indicate whether or not the text frame is displayed around the MText.
    /// </summary>
    ///
    /// <returns>
    /// Return true if the text frame is enabled; otherwise, return false.
    /// </returns>
    bool                      enableFrameText               () const;

    /// <summary>
    /// Set the alignment space value.
    /// </summary>
    ///
    /// <param name="alignSpace">
    /// Input alignment space value.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setAlignSpace                 (double alignSpace);

    /// <summary>
    /// Return alignment space value.
    /// </summary>
    ///
    /// <returns>
    /// Return alignment space value.
    /// </returns>
    double                    alignSpace                    () const;

    /// <summary>
    /// Set the Id of the block by name.
    /// </summary>
    ///
    /// <param name="name">
    /// Name of the built-in block.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setBlockId                    (const ACHAR* name);

    /// <summary>
    /// Set the Id of the block referenced by MLeader, it's a block table record id.
    /// </summary>
    ///
    /// <param name="blockId">
    /// Id of the block table record refenrenced by MLeader.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setBlockId                    (AcDbObjectId blockId);

    /// <summary>
    /// Return the Id of the block table record referenced by MLeader.
    /// </summary>
    ///
    /// <returns>
    /// Return the Id of the block table record referenced by MLeader.
    /// </returns>
    AcDbObjectId              blockId                       () const;

    /// <summary>
    /// Set block color in block content.
    /// </summary>
    ///
    /// <param name="blockColor">
    /// Input block color.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setBlockColor                 (const AcCmColor& blockColor);

    /// <summary>
    /// Return block color in block content.
    /// </summary>
    ///
    /// <returns>
    /// Return block color in block content.
    /// </returns>
    AcCmColor                 blockColor                    () const;

    /// <summary>
    /// Set the scale of the block referenced by MLeader.
    /// </summary>
    ///
    /// <param name="scale">
    /// Scale of the block refenrenced by MLeader.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    ///
    /// <remarks>
    /// Currently AutoCAD and the ARX API libraries make no use of this method.
    /// This method is deprecated and will be removed in a future version.
    /// </remarks>
    Acad::ErrorStatus         setBlockScale                 (const AcGeScale3d& scale);

    /// <summary>
    /// Return the sacle of the block referenced by MLeader.
    /// </summary>
    ///
    /// <returns>
    /// Return the sacle of the block referenced by MLeader.
    /// </returns>
    ///
    /// <remarks>
    /// Currently AutoCAD and the ARX API libraries make no use of this method.
    /// This method is deprecated and will be removed in a future version.
    /// </remarks>
    AcGeScale3d               blockScale                    () const;

    /// <summary>
    /// Disable/enable the blockScale value managed by setBlockScale().
    /// </summary>
    ///
    /// <param name="enableBlockScale">
    /// Input boolean to disable/enable blockScale.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    ///
    /// <remarks>
    /// Currently AutoCAD and the ARX API libraries make no use of this method.
    /// This method is deprecated and will be removed in a future version.
    /// </remarks>
    Acad::ErrorStatus         setEnableBlockScale           (bool enableBlockScale);

    /// <summary>
    /// Indicate whether the blockScale value managed by setBlockScale() works.
    /// </summary>
    ///
    /// <returns>
    /// Return true if the blockScale is enabled; otherwise, return false.
    /// </returns>
    ///
    /// <remarks>
    /// Currently AutoCAD and the ARX API libraries make no use of this method.
    /// This method is deprecated and will be removed in a future version.
    /// </remarks>
    bool                      enableBlockScale              () const;

    /// <summary>
    /// Set the rotation of the block referenced by MLeader.
    /// </summary>
    ///
    /// <param name="rotation">
    /// Rotation of the block refenrenced by MLeader.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    ///
    /// <remarks>
    /// Currently AutoCAD and the ARX API libraries make no use of this method.
    /// This method is deprecated and will be removed in a future version.
    /// </remarks>
    Acad::ErrorStatus         setBlockRotation              (double rotation);

    /// <summary>
    /// Return the rotation of the block referenced by MLeader.
    /// </summary>
    ///
    /// <returns>
    /// Return the rotation of the block referenced by MLeader.
    /// </returns>
    ///
    /// <remarks>
    /// Currently AutoCAD and the ARX API libraries make no use of this method.
    /// This method is deprecated and will be removed in a future version.
    /// </remarks>
    double                    blockRotation                 () const;

    /// <summary>
    /// Disable/enable the blockRotation value managed by setBlockRotation().
    /// </summary>
    ///
    /// <param name="enableBlockRotation">
    /// Input boolean to disable/enable blockRotation.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    ///
    /// <remarks>
    /// Currently AutoCAD and the ARX API libraries make no use of this method.
    /// This method is deprecated and will be removed in a future version.
    /// </remarks>
    Acad::ErrorStatus         setEnableBlockRotation        (bool enableBlockRotation);

    /// <summary>
    /// Indicate whether the blockRotation value managed by setBlockRotation() works.
    /// </summary>
    ///
    /// <returns>
    /// Return true if the blockRotation is enabled; otherwise, returns false.
    /// </returns>
    ///
    /// <remarks>
    /// Currently AutoCAD and the ARX API libraries make no use of this method.
    /// This method is deprecated and will be removed in a future version.
    /// </remarks>
    bool                      enableBlockRotation           () const;

    /// <summary>
    /// Set block connection type.
    /// </summary>
    ///
    /// <param name="blockConnectionType">
    /// Input block connection type.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setBlockConnectionType        (BlockConnectionType blockConnectionType);

    /// <summary>
    /// Return block connection type.
    /// </summary>
    ///
    /// <returns>
    /// Return block connection type.
    /// </returns>
    BlockConnectionType       blockConnectionType           () const;

    /// <summary>
    /// Set the scale of mleader created by this style.
    /// </summary>
    ///
    /// <param name="scale">
    /// Scale of mleader created by this style.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setScale                      (double scale);

    /// <summary>
    /// Return the scale of mleader created by this style.
    /// </summary>
    ///
    /// <returns>
    /// Return the scale of mleader created by this style.
    /// </returns>
    double                    scale                         () const;

    /// <summary>
    /// Indicate whether properties were changed.
    /// </summary>
    ///
    /// <returns>
    /// Return true if properties were changed; otherwise, returns false.
    /// </returns>
    bool                      overwritePropChanged          () const;

    /// <summary>
    /// Add this AcDbMLeaderStyle into database.
    /// </summary>
    ///
    /// <param name="pDb">
    /// Pointer of the database which will hold the style
    /// </param>
    /// <param name="styleName">
    /// Name of the MLeader Style
    /// </param>
    /// <param name="mleaderStyleId">
    /// Output the AcDbObjectId of the AcDbMLeaderStyle posted into database
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         postMLeaderStyleToDb          (AcDbDatabase* pDb, const ACHAR* styleName, AcDbObjectId & mleaderStyleId);

    /// <summary>
    /// Set the annotative status of AcDbMLeaderStyle.
    /// </summary>
    ///
    /// <param name="isAnnotative">
    /// New annotative status for AcDbMLeaderStyle
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setAnnotative              (bool isAnnotative);

    /// <summary>
    /// Return AcDbMLeaderStyle's annotative status.
    /// </summary>
    ///
    /// <returns>
    /// Return true if this is a annotative AcDbMLeaderStyle;
    /// Otherwise, return false.
    /// </returns>
    bool                      annotative                 () const;

    /// <summary>
    /// Set the break size used for breaking leader lines.
    /// </summary>
    ///
    /// <param name="size">
    /// Size specifies the gap used for breaking leader lines.
    /// </param>
    ///
    /// <returns>
    /// Return Acad::eOk if successful.
    /// </returns>
    Acad::ErrorStatus         setBreakSize (double size);

    /// <summary>
    /// Return the size of the gap used for breaking leader lines.
    /// </summary>
    ///
    /// <returns>
    /// Return the size of the gap used for breaking leader lines.
    /// </returns>
    double                    breakSize () const;

    /// <summary>
    /// Sets text attachment Direction of MText content.
    /// </summary>
    ///
    /// <param name="textAttachmentDirection">
    /// Input text attachment direction defined in AcDbMLeaderStyle::TextAttachmentDirection.
    /// </param>
    ///
    /// <returns>
    /// Returns Acad::eOk if successful.Return values for errors are implementation-dependent.
    /// </returns>
    ///
    Acad::ErrorStatus         setTextAttachmentDirection(AcDbMLeaderStyle::TextAttachmentDirection textAttachmentDirection);

    /// <summary>
    /// Gets text attachment direction of MText content.
    /// </summary>
    ///
    /// <returns>
    /// Returns text attachment direction of MText content.
    /// </returns>
    ///
    TextAttachmentDirection   textAttachmentDirection() const;

    /// <summary>
    /// Sets if horizontal leader lines are automatically extended to text.
    /// </summary>
    ///
    /// <param name="value">
    /// Input boolean to make the automatically leader extension on/off.
    /// </param>
    ///
    /// <returns>
    /// Returns Acad::eOk if successful.Return values for errors are implementation-dependent.
    /// </returns>
    ///
    Acad::ErrorStatus setExtendLeaderToText(bool value);

    /// <summary>
    /// Gets if horizontal leader lines are automatically extended to text.
    /// </summary>
    ///
    /// <returns>
    /// Returns true if horizontal leader lines are automatically extended to text; otherwise, returns false.
    /// </returns>
    ///
    bool extendLeaderToText() const;

protected:

    /// <summary>
    /// Gets corresponding COM wrapper class ID.
    /// </summary>
    ///
    /// <param name="pClsid">
    /// OutPut corresponding COM wrapper class ID.
    /// </param>
    ///
    /// <returns>
    /// Returns Acad::eOk if successful.Return values for errors are implementation-dependent.
    /// </returns>
    ///
    virtual Acad::ErrorStatus subGetClassID                    (CLSID* pClsid) const;
};

#endif // __DBMLEADERSTYLE_H__

