using System;
using System.Drawing;
using System.Windows.Forms;
using Microsoft.VisualBasic.PowerPacks;

namespace Dongke.WinForm.Controls.InvoiceLayout
{
    /// <summary>
    /// 
    /// </summary>
    [Serializable]
    public abstract class LayoutItem : ICloneable, IDisposable
    {
        #region 成员变量
        private int _id;                                                // ID
        private object _tag;                                            // 扩展
        private readonly ItemType _type;                        // Item类别
        // 位置
        /// <summary>
        /// 
        /// </summary>
        protected float _top;                                        // 上位置X (mm単位)
        /// <summary>
        /// 
        /// </summary>
        protected float _left;                                        // 左位置Y (mm単位)
        /// <summary>
        /// 
        /// </summary>
        protected float _width;                                    // 宽 (mm単位)
        /// <summary>
        /// 
        /// </summary>
        protected float _height;                                    // 高 (mm単位)
        /// <summary>
        /// 
        /// </summary>
        protected float _right;                                        // 右位置 (mm単位)
        /// <summary>
        /// 
        /// </summary>
        protected float _bottom;                                    // 下位置 (mm単位)
        /// <summary>
        /// 
        /// </summary>
        protected bool _sideRatioFixed = false;            // 横纵比例是否固定
        /// <summary>
        /// 
        /// </summary>
        private ItemLock _lock = ItemLock.None;            // Item锁定

        /// <summary>
        /// 
        /// </summary>
        [NonSerialized]
        protected Shape _shape;                                // 图形对象
        /// <summary>
        /// 
        /// </summary>
        [NonSerialized]
        protected SimpleShape _simpleShape;
        /// <summary>
        /// 
        /// </summary>
        [NonSerialized]
        protected LineShape _lineShape;
        /// <summary>
        /// 
        /// </summary>
        [NonSerialized]
        protected LayoutBox _owner;                            // LayoutBox
        /// <summary>
        /// 
        /// </summary>
        [NonSerialized]
        private ItemFrame _frame;                                // Item选择框
        /// <summary>
        /// 
        /// </summary>
        [NonSerialized]
        private bool _isSelected;                                    // Item是否选择
        /// <summary>
        /// 
        /// </summary>
        [NonSerialized]
        private bool _isNew;                                        // 新追加的Item
        /// <summary>
        /// 
        /// </summary>
        [NonSerialized]
        private RectangleF _rectangleFDraw;                // Item的范围 - 绘制用 (mm単位)
        #endregion 成员变量

        #region 属性
        /// <summary>
        /// LayoutBox内使用的Item标识。
        /// </summary>
        /// <remarks>
        /// </remarks>
        public int ID
        {
            get
            {
                return _id;
            }
        }

        /// <summary>
        /// object扩展
        /// </summary>
        /// <remarks>
        /// 等同于 System.Windows.Forms.Control.Tag ，可以参考 MSDN的Control.Tag
        /// </remarks>
        public object Tag
        {
            get
            {
                return _tag;
            }
            set
            {
                _tag = value;
                if (_owner != null)
                {
                    _owner.SetItemChangedArgs(this, ItemChangeType.Modified);
                }
            }
        }

        /// <summary>
        /// 获取或设置Item类别。
        /// </summary>
        public ItemType ItemType
        {
            get
            {
                return _type;
            }
        }

        /// <summary>
        /// 获取或设置Item在LayoutBox内的X坐标 mm单位。
        /// </summary>
        public float Top
        {
            get
            {
                return _top;
            }
            set
            {
                if (value != _top)
                {
                    if (SetTop(value) && _owner != null)
                    {
                        _owner.SetItemChangedArgs(this, ItemChangeType.Moved);
                    }
                }
            }
        }

        /// <summary>
        /// 获取或设置Item在LayoutBox内的Y坐标 mm单位。
        /// </summary>
        public float Left
        {
            get
            {
                return _left;
            }
            set
            {
                if (value != _left)
                {
                    if (SetLeft(value) && _owner != null)
                    {
                        _owner.SetItemChangedArgs(this, ItemChangeType.Moved);
                    }
                }
            }
        }

        /// <summary>
        /// 获取或设置Item在LayoutBox内的宽 mm单位。
        /// </summary>
        public float Width
        {
            get
            {
                return _width;
            }
            set
            {
                if (value != _width)
                {
                    if (SetWidth(value) && _owner != null)
                    {
                        _owner.SetItemChangedArgs(this, ItemChangeType.Modified);
                    }
                }
            }
        }

        /// <summary>
        /// 获取或设置Item在LayoutBox内的高 mm单位。
        /// </summary>
        public float Height
        {
            get
            {
                return _height;
            }
            set
            {
                if (value != _height)
                {
                    if (SetHeight(value) && _owner != null)
                    {
                        _owner.SetItemChangedArgs(this, ItemChangeType.Modified);
                    }
                }
            }
        }

        /// <summary>
        /// 获取Item在LayoutBox内的右位置 mm单位。
        /// </summary>
        public float Right
        {
            get
            {
                return _left + _width;
                //return _right;
            }
            //set
            //{
            //    if (value != _right)
            //    {
            //        if (SetRight(value) && _owner != null)
            //        {
            //            _owner.SetItemChangedArgs(this, ItemChangeType.Change);
            //        }
            //    }
            //}
        }

        /// <summary>
        /// 获取Item在LayoutBox内的下位置 mm单位。
        /// </summary>
        public float Bottom
        {
            get
            {
                return _top + _height;
                //return _bottom;
            }
            //set
            //{
            //    if (value != _bottom)
            //    {
            //        if (SetBottom(value) && _owner != null)
            //        {
            //            _owner.SetItemChangedArgs(this, ItemChangeType.Change);
            //        }
            //    }
            //}
        }

        /// <summary>
        /// 获取或设置图片横纵比例是否固定
        /// </summary>
        public bool SideRatioFixed
        {
            get
            {
                return _sideRatioFixed;
            }
            set
            {
                if (value != _sideRatioFixed)
                {
                    _sideRatioFixed = value;
                    if (Owner != null)
                    {
                        Owner.SetItemChangedArgs(this, ItemChangeType.Modified);
                    }
                }
            }
        }

        /// <summary>
        /// 获取或设置Item锁定
        /// </summary>
        internal ItemLock ItemLockType
        {
            get
            {
                return _lock;
            }
            set
            {
                if (value != _lock)
                {
                    _lock = value;
                    ResetItemFrame();
                }
            }
        }

        /// <summary>
        /// 获取Item是否是选择状态。
        /// </summary>
        public bool Selected
        {
            get
            {
                return _isSelected;
            }
            internal set
            {
                if (value != _isSelected)
                {
                    _isSelected = value;
                }
            }
        }

        /// <summary>
        /// 获取或设置是否是新追加的Item。
        /// </summary>
        internal bool IsNew
        {
            get
            {
                return _isNew;
            }
            set
            {
                _isNew = value;
            }
        }

        /// <summary>
        /// Item所属的LayoutBox
        /// </summary>
        internal LayoutBox Owner
        {
            get
            {
                return _owner;
            }
            set
            {
                if (_owner != value)
                {
                    if (_owner != null)
                    {
                        _owner.Items.Remove(this);
                        //if (_control != null &&
                        //    _owner.PaperArea.Controls.Contains(_control))
                        //{
                        //    _owner.PaperArea.Controls.Remove(_control);
                        //}
                        if (_shape != null && _owner.ItemShapes.Contains(_shape))
                        {
                            _owner.ItemShapes.Remove(_shape);
                        }
                    }
                    _owner = value;
                    if (_owner != null)
                    {
                        _owner.Items.Add(this);
                        //if (_control != null &&
                        //    !_owner.PaperArea.Controls.Contains(_control))
                        //{
                        //    _owner.PaperArea.Controls.Add(_control);
                        //    int count = value.SelectedItems.Count;
                        //    _owner.PaperArea.Controls.SetChildIndex(_control, count);
                        //}
                        if (_shape != null && !_owner.ItemShapes.Contains(_shape))
                        {
                            _owner.ItemShapes.Add(_shape);
                            _shape.BringToFront();
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Item对应的图形
        /// </summary>
        internal Shape Shape
        {
            get
            {
                return _shape;
            }
            private set
            {
                if (_shape != value)
                {
                    if (_shape != null)
                    {
                        _shape.Dispose();
                    }
                    _shape = value;
                    if (_shape != null)
                    {
                        if (_shape is SimpleShape)
                        {
                            _simpleShape = _shape as SimpleShape;
                        }
                        else if (_shape is LineShape)
                        {
                            _lineShape = _shape as LineShape;
                        }
                        SetShapeProperty(GetZoom());
                        if (_owner != null && !_owner.ItemShapes.Contains(_shape))
                        {
                            _owner.ItemShapes.Add(_shape);
                            _shape.BringToFront();
                        }
                        _shape.DoubleClick += new EventHandler(OnDoubleClickControl);
                        _shape.MouseDown += new MouseEventHandler(OnMouseDownControl);
                        _shape.PreviewKeyDown += new PreviewKeyDownEventHandler(OnPreviewKeyDown);
                        _shape.MouseMove += new MouseEventHandler(OnMouseMove);
                        _shape.Paint += new PaintEventHandler(OnPaint);
                        ResetShapeLocationAndSize(false);
                    }
                }
            }
        }
        /// <summary>
        /// 
        /// </summary>
        protected SimpleShape SimpleShape
        {
            get
            {
                return _simpleShape;
            }
        }
        /// <summary>
        /// 
        /// </summary>
        protected LineShape LineShape
        {
            get
            {
                return _lineShape;
            }
        }

        /// <summary>
        /// 图形范围
        /// </summary>
        internal protected virtual Rectangle ShapeBounds
        {
            get
            {
                return _simpleShape != null ? _simpleShape.Bounds : Rectangle.Empty;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        internal protected virtual Rectangle ShapeVirtualBounds
        {
            get
            {
                return ShapeBounds;
            }
        }

        /// <summary>
        /// 获取或设置Item的选中边框
        /// </summary>
        internal ItemFrame Frame
        {
            get
            {
                return _frame;
            }
            set
            {
                if (_frame != value)
                {
                    _frame = value;
                }
            }
        }

        /// <summary>
        /// 获取或设置Item的范围 - 绘制用 (mm単位)
        /// </summary>
        protected virtual RectangleF RectangleFDraw
        {
            get
            {
                return _rectangleFDraw;
            }
            set
            {
                _rectangleFDraw = value;
            }
        }
        #endregion 属性

        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="box">Layoutbox</param>
        /// <param name="itemType">item类别</param>
        internal LayoutItem(LayoutBox box, ItemType itemType)
        {
            _rectangleFDraw = RectangleF.Empty;
            _top = LayoutConsts.ITEM_LOCATION_DEF;
            _left = LayoutConsts.ITEM_LOCATION_DEF;
            _width = 0f;
            _height = 0f;
            _right = _left + _width;
            _bottom = _top + _height;
            _id = 0;
            _type = itemType;
            Owner = box;

            if (_owner != null)
            {
                _id = _owner.NewItemID;
                Shape = LayoutUtility.GetNewShape(this);
                //SetShapeProperty();
                SetDrawProperty();
            }
        }
        #endregion 构造函数

        #region 事件处理
        /// <summary>
        /// Item图形上的OnMouseMove事件
        /// </summary>
        /// <param name="sender">指定的对象</param>
        /// <param name="e">提供的事件数据</param>
        private void OnMouseMove(object sender, MouseEventArgs e)
        {
            // TODO Item范围内移动
            if (_owner == null || _owner.LayoutMode != LayoutMode.Edit)
            {
                Cursor.Current = Cursors.Default;
            }
            else
            {
                if (_lock == ItemLock.None)
                {
                    Cursor.Current = Cursors.SizeAll;
                }
                else
                {
                    Cursor.Current = Cursors.Default;
                }
            }
        }

        /// <summary>
        /// Item图形上的OnPreviewKeyDown事件
        /// </summary>
        /// <param name="sender">指定的对象</param>
        /// <param name="e">提供的事件数据</param>
        private void OnPreviewKeyDown(object sender, PreviewKeyDownEventArgs e)
        {
            if (_owner == null || _owner.LayoutMode != LayoutMode.Edit
                || _owner.SelectedItems == null || _owner.SelectedItems.Count == 0)
            {
                return;
            }
            bool isInputKey = false;
            bool isDirty = false;
            if (e.KeyCode == Keys.Left)
            {
                isInputKey = true;
                // 选择的Item向左移动1像素
                foreach (LayoutItem item in _owner.SelectedItems)
                {
                    isDirty = item.LeftItem(1) ? true : isDirty;
                }
            }
            else if (e.KeyCode == Keys.Up)
            {
                isInputKey = true;
                // 选择的Item向上移动1像素
                foreach (LayoutItem item in _owner.SelectedItems)
                {
                    isDirty = item.UpItem(1) ? true : isDirty;
                }
            }
            else if (e.KeyCode == Keys.Right)
            {
                isInputKey = true;
                // 选择的Item向右移动1像素
                foreach (LayoutItem item in _owner.SelectedItems)
                {
                    isDirty = item.RightItem(1) ? true : isDirty;
                }
            }
            else if (e.KeyCode == Keys.Down)
            {
                isInputKey = true;
                // 选择的Item向下移动1像素
                foreach (LayoutItem item in _owner.SelectedItems)
                {
                    isDirty = item.DownItem(1) ? true : isDirty;
                }
            }
            if (isInputKey)
            {
                e.IsInputKey = isInputKey;
                if (isDirty && _owner != null)
                {
                    _owner.Dirty = true;
                }
            }
        }

        /// <summary>
        /// Item图形上的OnDoubleClickControl事件
        /// </summary>
        /// <param name="sender">指定的对象</param>
        /// <param name="e">提供的事件数据</param>
        private void OnDoubleClickControl(object sender, EventArgs e)
        {
            if (_isSelected
                && _owner != null
                && _owner.LayoutMode == LayoutMode.Edit
                && _owner.SelectedItems != null
                && _owner.SelectedItems.Count == 1)
            {
                // 显示Item的属性设置画面
                ShowItemPropertyDialog();
            }
        }

        /// <summary>
        /// Item图形上的OnMouseDownControl事件
        /// </summary>
        /// <param name="sender">指定的对象</param>
        /// <param name="e">提供的事件数据</param>
        private void OnMouseDownControl(object sender, MouseEventArgs e)
        {
            // 选中Item
            if (_owner == null || _owner.LayoutMode != LayoutMode.Edit)
            {
                return;
            }
            if (_owner != null)
            {
                // Item的选择方式
                if (Control.ModifierKeys == Keys.Control
                    || Control.ModifierKeys == Keys.Shift)
                {
                    _owner.SelectItemMultiple(this, !_isSelected);
                }
                else
                {
                    if (!_isSelected)
                    {
                        _owner.SelectItemSingle(this, true);
                    }
                }
            }
        }

        /// <summary>
        /// Item图形上的OnPaint事件
        /// </summary>
        /// <param name="sender">指定的对象</param>
        /// <param name="e">提供的事件数据</param>
        protected virtual void OnPaint(object sender, PaintEventArgs e)
        {
        }
        #endregion 事件处理

        #region 函数
        /// <summary>
        /// Item初始化
        /// </summary>
        /// <param name="box">LayoutBox</param>
        /// <param name="isNewID">是否生成新ID</param>
        /// <returns>是否成功</returns>
        internal virtual bool Init(LayoutBox box, bool isNewID)
        {
            Owner = box;
            if (_owner == null)
            {
                return false;
            }
            if (isNewID)
            {
                _id = _owner.NewItemID;
            }
            Shape = LayoutUtility.GetNewShape(this);
            //SetShapeProperty();
            SetDrawProperty();
            return true;
        }

        /// <summary>
        /// 刷新显示
        /// </summary>
        public virtual void Refresh()
        {
            if (_shape != null)
            {
                _shape.Refresh();
            }
        }

        /// <summary>
        /// 显示Item属性设置画面
        /// </summary>
        /// <returns>
        /// DialogResult.OK:选中的Item有效，设置成功<br/>
        /// DialogResult.Cancel:选中的Item有效，取消设置<br/>
        /// DialogResult.None:LayoutBox不是编辑模式，或选中的Item不是一个
        /// </returns>
        public DialogResult ShowItemPropertyDialog()
        {
            if (_owner != null && _owner.LayoutMode == LayoutMode.Edit)
            {
                // 显示Item属性设置画面
                DialogResult dialogResult = ShowItemPropertyDialogInner();
                if (dialogResult == DialogResult.OK)
                {
                    //_owner.PaperArea.Refresh();
                }
                return dialogResult;
            }
            return DialogResult.None;
        }

        /// <summary>
        /// 显示Item属性设置画面 - 子类实例化用
        /// </summary>
        /// <returns>
        /// DialogResult.OK:选中的Item有效，设置成功<br/>
        /// DialogResult.Cancel:选中的Item有效，取消设置<br/>
        /// DialogResult.None:LayoutBox不是编辑模式，或选中的Item不是一个
        /// </returns>
        protected virtual DialogResult ShowItemPropertyDialogInner()
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 改变Item的选择状态
        /// </summary>
        /// <param name="value">选中：true，取消选择：false</param>
        public void Select(bool value)
        {
            if (_owner.LayoutMode != LayoutMode.Edit)
            {
                return;
            }
            if (_owner != null)
            {
                _owner.SelectItemMultiple(this, value);
            }
        }

        /// <summary>
        /// 刷新显示Item选择边框
        /// </summary>
        internal void ResetItemFrame()
        {
            if (_isSelected && _frame != null)
            {
                _frame.CreateFrame();
            }
        }

        /// <summary>
        /// 改变Item图形的位置和大小
        /// </summary>
        protected virtual bool ResetShapeLocationAndSize(int left, int top, int width, int height)
        {
            if (_simpleShape != null)
            {
                _simpleShape.Location = new Point(left, top);
                _simpleShape.Size = new Size(width, height);
                return true;
            }
            return false;
        }
        /// <summary>
        /// 
        /// </summary>
        protected virtual bool ResetShapeLocation(int left, int top)
        {
            if (_simpleShape != null)
            {
                _simpleShape.Location = new Point(left, top);
                return true;
            }
            return false;
        }
        /// <summary>
        /// 
        /// </summary>
        protected virtual bool ResetShapeSize(int width, int height)
        {
            if (_simpleShape != null)
            {
                _simpleShape.Size = new Size(width, height);
                return true;
            }
            return false;
        }
        /// <summary>
        /// 根据zoom改变Item与Item图形的位置和大小
        /// </summary>
        protected virtual bool ResetItemLocationAndSize(int left, int top, int width, int height)
        {
            bool l = ResetItemLocation(left, top);
            bool s = ResetItemSize(width, height);
            return l && s;
        }
        /// <summary>
        /// 
        /// </summary>
        protected virtual bool ResetItemLocation(int left, int top)
        {
            if (_lock == ItemLock.LockLocationAndSize)
            {
                return false;
            }
            int zoom = 100;
            if (_owner != null)
            {
                zoom = _owner.Zoom;
            }
            if (_simpleShape != null && 0 < zoom)
            {
                if (_simpleShape.Top != top || _simpleShape.Left != left)
                {
                    if (_simpleShape.Top != top)
                    {
                        _top = LayoutCommon.PixelToMillimeter(top, zoom);
                        _bottom = _top + _height;
                    }
                    if (_simpleShape.Left != left)
                    {
                        _left = LayoutCommon.PixelToMillimeter(left, zoom);
                        _right = _left + _width;
                    }
                    _simpleShape.Location = new Point(left, top);
                    SetRectangleF();
                    if (_owner != null)
                    {
                        _owner.SetItemChangedArgs(this, ItemChangeType.Moved);
                    }
                }
            }
            return true;
        }
        /// <summary>
        /// 
        /// </summary>
        protected virtual bool ResetItemSize(int width, int height)
        {
            if (_lock != ItemLock.None)
            {
                return false;
            }
            int zoom = 100;
            if (_owner != null)
            {
                zoom = _owner.Zoom;
            }
            if (_simpleShape != null && 0 < zoom)
            {
                if (_simpleShape.Width != width || _simpleShape.Height != height)
                {
                    if (_simpleShape.Width != width)
                    {
                        _width = LayoutCommon.PixelToMillimeter(width, zoom);
                        _right = _left + _width;
                    }
                    if (_simpleShape.Height != height)
                    {
                        _height = LayoutCommon.PixelToMillimeter(height, zoom);
                        _bottom = _top + _height;
                    }
                    _simpleShape.Size = new Size(width, height);
                    SetRectangleF();
                    if (_owner != null)
                    {
                        _owner.SetItemChangedArgs(this, ItemChangeType.Modified);
                    }
                }
            }
            return true;
        }
        /// <summary>
        /// 根据zoom与Item图形的位置和大小，改变Item的位置和大小
        /// </summary>
        protected virtual bool ResetItemLocationAndSize()
        {
            bool l = ResetItemLocation();
            bool s = ResetItemSize();
            return l && s;
        }
        /// <summary>
        /// 
        /// </summary>
        protected virtual bool ResetItemLocation()
        {
            if (_lock == ItemLock.LockLocationAndSize)
            {
                return false;
            }
            int zoom = 100;
            if (_owner != null)
            {
                zoom = _owner.Zoom;
            }
            if (_simpleShape != null && 0 < zoom)
            {
                float top = LayoutCommon.PixelToMillimeter(_simpleShape.Top, zoom);
                float left = LayoutCommon.PixelToMillimeter(_simpleShape.Left, zoom);
                if (_top != top || _left != left)
                {
                    if (_top != top)
                    {
                        _top = top;
                        _bottom = _top + _height;
                    }
                    if (_left != left)
                    {
                        _left = left;
                        _right = _left + _width;
                    }
                    SetRectangleF();
                    if (_owner != null)
                    {
                        _owner.SetItemChangedArgs(this, ItemChangeType.Moved);
                    }
                }
            }
            return true;
        }
        /// <summary>
        /// 
        /// </summary>
        protected virtual bool ResetItemSize()
        {
            if (_lock != ItemLock.None)
            {
                return false;
            }
            int zoom = 100;
            if (_owner != null)
            {
                zoom = _owner.Zoom;
            }
            if (_simpleShape != null && 0 < zoom)
            {
                float width = LayoutCommon.PixelToMillimeter(_simpleShape.Width, zoom);
                float height = LayoutCommon.PixelToMillimeter(_simpleShape.Height, zoom);
                if (_width != width || _height != height)
                {
                    if (_width != width)
                    {
                        _width = width;
                        _right = _left + _width;
                    }
                    if (_height != height)
                    {
                        _height = height;
                        _bottom = _top + _height;
                    }
                    SetRectangleF();
                    if (_owner != null)
                    {
                        _owner.SetItemChangedArgs(this, ItemChangeType.Modified);
                    }
                }
            }
            return true;
        }

        /// <summary>
        /// 设置Item的X坐标
        /// </summary>
        /// <param name="value">X坐标</param>
        protected virtual bool SetTop(float value)
        {
            if (_lock == ItemLock.LockLocationAndSize)
            {
                return false;
            }
            if (value < LayoutConsts.ITEM_LOCATION_MIN
                || LayoutConsts.ITEM_LOCATION_MAX < value
                || _owner.PaperHeight <= value)
            {
                return false;
            }
            _top = value;
            _bottom = _top + _height;
            SetRectangleF();
            if (_simpleShape != null && _owner != null)
            {
                _simpleShape.Top = LayoutCommon.MillimeterToPixel(_top, _owner.Zoom);
                ResetItemFrame();
            }
            return true;
        }
        /// <summary>
        /// 设置Item的Y坐标
        /// </summary>
        /// <param name="value">Y坐标</param>
        protected virtual bool SetLeft(float value)
        {
            if (_lock == ItemLock.LockLocationAndSize)
            {
                return false;
            }
            if (value < LayoutConsts.ITEM_LOCATION_MIN
                || LayoutConsts.ITEM_LOCATION_MAX < value
                || _owner.PaperWidth <= value)
            {
                return false;
            }
            _left = value;
            _right = _left + _width;
            SetRectangleF();
            if (_simpleShape != null && _owner != null)
            {
                _simpleShape.Left = LayoutCommon.MillimeterToPixel(_left, _owner.Zoom);
                ResetItemFrame();
            }
            return true;
        }
        /// <summary>
        /// 设置Item的宽度
        /// </summary>
        /// <param name="value">宽</param>
        protected virtual bool SetWidth(float value)
        {
            if (_lock != ItemLock.None)
            {
                return false;
            }
            if (value < LayoutConsts.ITEM_SIZE_MIN
                || LayoutConsts.ITEM_SIZE_WIDTH_MAX < value)
            {
                return false;
            }
            float hValue = _height;
            if (_sideRatioFixed)
            {
                hValue = _height / _width * value;
                if (hValue < LayoutConsts.ITEM_SIZE_MIN
                    || LayoutConsts.ITEM_SIZE_WIDTH_MAX < hValue)
                {
                    return false;
                }
                _height = hValue;
                _bottom = _top + _height;
            }
            _width = value;
            _right = _left + _width;
            SetRectangleF();
            if (_simpleShape != null && _owner != null)
            {
                if (_sideRatioFixed)
                {
                    _simpleShape.Size = new Size(
                        LayoutCommon.MillimeterToPixel(_width, _owner.Zoom),
                        LayoutCommon.MillimeterToPixel(_height, _owner.Zoom));
                }
                else
                {
                    _simpleShape.Width = LayoutCommon.MillimeterToPixel(_width, _owner.Zoom);
                }
                ResetItemFrame();
            }
            return true;
        }
        /// <summary>
        /// 设置Item的高度
        /// </summary>
        /// <param name="value">高</param>
        protected virtual bool SetHeight(float value)
        {
            if (_lock != ItemLock.None)
            {
                return false;
            }
            if (value < LayoutConsts.ITEM_SIZE_MIN
                || LayoutConsts.ITEM_SIZE_HEIGHT_MAX < value)
            {
                return false;
            }
            float wValue = _height;
            if (_sideRatioFixed)
            {
                wValue = _width / _height * value;
                if (wValue < LayoutConsts.ITEM_SIZE_MIN
                    || LayoutConsts.ITEM_SIZE_WIDTH_MAX < wValue)
                {
                    return false;
                }
                _width = wValue;
                _right = _left + _width;
            }
            _height = value;
            _bottom = _top + _height;
            SetRectangleF();
            if (_simpleShape != null && _owner != null)
            {
                if (_sideRatioFixed)
                {
                    _simpleShape.Size = new Size(
                        LayoutCommon.MillimeterToPixel(_width, _owner.Zoom),
                        LayoutCommon.MillimeterToPixel(_height, _owner.Zoom));
                }
                else
                {
                    _simpleShape.Height = LayoutCommon.MillimeterToPixel(_height, _owner.Zoom);
                }
                ResetItemFrame();
            }
            return true;
        }

        /// <summary>
        /// 移动Item
        /// </summary>
        public virtual bool LeftItem(int value)
        {
            if (_lock == ItemLock.LockLocationAndSize)
            {
                return false;
            }
            if (_simpleShape != null && value <= _simpleShape.Left)
            {
                int left = _simpleShape.Left - value;
                if (_frame != null)
                {
                    _frame.Left -= value;
                }
                ResetItemLocation(left, _simpleShape.Top);
                return true;
            }
            return false;
        }
        /// <summary>
        /// 
        /// </summary>
        public virtual bool UpItem(int value)
        {
            if (_lock == ItemLock.LockLocationAndSize)
            {
                return false;
            }
            if (_simpleShape != null && value <= _simpleShape.Top)
            {
                int top = _simpleShape.Top - value;
                if (_frame != null)
                {
                    _frame.Top -= value;
                }
                ResetItemLocation(_simpleShape.Left, top);
                return true;
            }
            return false;
        }
        /// <summary>
        /// 
        /// </summary>
        public virtual bool RightItem(int value)
        {
            if (_lock == ItemLock.LockLocationAndSize)
            {
                return false;
            }
            if (_simpleShape != null)
            {
                int left = _simpleShape.Left + value;
                if (_owner != null
                    && left < _owner.PaperArea.Width
                    && left <= _owner.MaxItemLeft)
                {
                    if (_frame != null)
                    {
                        _frame.Left += value;
                    }
                    ResetItemLocation(left, _simpleShape.Top);
                    return true;
                }
            }
            return false;
        }
        /// <summary>
        /// 
        /// </summary>
        public virtual bool DownItem(int value)
        {
            if (_lock == ItemLock.LockLocationAndSize)
            {
                return false;
            }
            if (_simpleShape != null)
            {
                int top = _simpleShape.Top + value;
                if (_owner != null
                    && top < _owner.PaperArea.Height
                    && top <= _owner.MaxItemTop)
                {
                    if (_frame != null)
                    {
                        _frame.Top += value;
                    }
                    ResetItemLocation(_simpleShape.Left, top);
                    return true;
                }
            }
            return false;
        }
        /// <summary>
        /// 
        /// </summary>
        public virtual bool MoveItem(int left, int top)
        {
            if (_lock == ItemLock.LockLocationAndSize)
            {
                return false;
            }
            return ResetItemLocation(left, top);
        }
        /// <summary>
        /// 
        /// </summary>
        public virtual bool ChangeItemSize(int width, int height)
        {
            if (_lock != ItemLock.None)
            {
                return false;
            }
            return ResetItemSize(width, height);
        }
        /// <summary>
        /// 根据zom与Item，改变Item图形的位置和大小
        /// </summary>
        internal virtual bool ResetShapeLocationAndSize(bool isCheck)
        {
            int zoom = 100;
            if (_owner != null)
            {
                zoom = _owner.Zoom;
            }
            if (_shape != null)
            {
                int top = LayoutCommon.MillimeterToPixel(_top, zoom);
                int left = LayoutCommon.MillimeterToPixel(_left, zoom);
                int width = LayoutCommon.MillimeterToPixel(_width, zoom);
                int height = LayoutCommon.MillimeterToPixel(_height, zoom);

                ResetShapeLocationAndSize(left, top, width, height);
                ResetItemFrame();
                return true;
            }
            return false;
        }

        /// <summary>
        /// 初始化Item图形属性
        /// </summary>
        internal virtual void SetShapeProperty(float zoom)
        {
        }

        internal virtual float GetZoom()
        {
            float zoom = 1;
            if (Owner != null)
            {
                zoom = Owner.Zoom / 100f;
            }
            return (0 < zoom) ? zoom : 1;
        }

        /// <summary>
        /// 初始化Item绘制用属性
        /// </summary>
        internal virtual float SetDrawProperty()
        {
            float zoom = GetZoom();

            _rectangleFDraw.X = Left * zoom;
            _rectangleFDraw.Y = Top * zoom;
            _rectangleFDraw.Width = Width * zoom;
            _rectangleFDraw.Height = (Height - LayoutConsts.TEXT_MARGIN) * zoom;
            return zoom;
        }

        /// <summary>
        /// 初始化Item绘制用范围属性
        /// </summary>
        internal virtual float SetRectangleF()
        {
            float zoom = GetZoom();

            _rectangleFDraw.X = Left * zoom;
            _rectangleFDraw.Y = Top * zoom;
            _rectangleFDraw.Width = Width * zoom;
            _rectangleFDraw.Height = (Height - LayoutConsts.TEXT_MARGIN) * zoom;
            return zoom;
        }

        /// <summary>
        /// Item图形是否被此范围包含
        /// </summary>
        /// <param name="rect"></param>
        /// <returns></returns>
        internal protected virtual bool BoundsContainsBy(Rectangle rect)
        {
            return _simpleShape != null ? rect.Contains(_simpleShape.Bounds) : false;
        }
        /// <summary>
        /// 
        /// </summary>
        internal protected virtual bool BoundsContains(Rectangle rect)
        {
            return _simpleShape != null ? _simpleShape.Bounds.Contains(rect) : false;
        }
        /// <summary>
        /// 
        /// </summary>
        internal protected virtual bool IntersectsWith(Rectangle rect)
        {
            return _simpleShape != null ? _simpleShape.Bounds.IntersectsWith(rect) : false;
        }
        /// <summary>
        /// 
        /// </summary>
        internal protected virtual bool BoundsContains(Point pt)
        {
            return _simpleShape != null ? _simpleShape.Bounds.Contains(pt) : false;
        }

        #region ICloneable
        /// <summary>
        /// Creates a new object that is a copy of the current instance.
        /// </summary>
        /// <returns>A new object that is a copy of this instance.</returns>
        public virtual object Clone()
        {
            return MemberwiseClone();
        }
        #endregion ICloneable

        #region IDisposable
        /// <summary>
        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
        /// </summary>
        /// <param name="disposing"></param>
        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                lock (this)
                {
                    if (_shape != null)
                    {
                        _shape.Dispose();
                        _shape = null;
                    }
                    _owner = null;
                }
            }
        }
        #endregion IDisposable
        #endregion 函数
    }
}