public async Task<ShapeBase> GetShapeInforAsync (ShapeBase input)
		{
			if (input is SquareShape)
				return await GetSquareInfoAsync (input as SquareShape);
			if (input is CircleShape)
				return await GetCircleInfoAsync (input as CircleShape);
			return input;
		}

		public ShapeViewModel (ShapeBase shape)
		{
			_shape = shape;
			_webServices = ColorWebServices.Instance;
			_imageService = ImageService.Instance;
			_shapeFactory = ShapeFactory.Instance;
			DoubleTapCommand = new Command (async ()=> HandleDoubleTap());
		}

 /// <summary>
 /// Overridden function
 /// </summary>
 /// <param name="child"></param>
 public override void RemoveChild(ShapeBase child)
 {
     base.RemoveChild (child);
       if (child is PathNodeShape)
     Update();
 }

        public void AddUIControlInstance(ShapeBase child)
        {
            if (UIListInstance != null)
            {
                if (child is UIShapeSliderControl)
                {
                    //

                    UIListInstance.AddScrollbarControl(child._engineInstance);
                }

            }
        }

        void AddSoundShapesRecursive(ShapeCollection shapeList, ShapeBase parent)
        {
            if (parent.ShapeVirtualCounter > 0 || !parent.Modifiable)
            return;

              ShapeBase soundShape = parent as ShapeObject3D;
              if (soundShape != null && (soundShape.GetType().FullName == "SoundEditorPlugin.SoundShape" || soundShape.GetType().FullName == "SoundEditorPlugin.SoundCollisionShape"))
            shapeList.Add(soundShape);

              if (parent.HasChildren())
            foreach (ShapeBase shape in parent.ChildCollection)
              AddSoundShapesRecursive(shapeList, shape);
        }

 public override void OnChildRemoved(ShapeBase childShape, int iDepth)
 {
     base.OnChildRemoved(childShape, iDepth);
       if (iDepth == 1 && childShape is BoneProxyShape)
     _cachedBoneList = null;
 }

        void AddShapesRecursive(ShapeCollection target, ShapeBase parent, Rectangle2D selection )
        {
            if (parent.ShapeVirtualCounter==0 && parent.CanCopyPaste && (parent is Shape3D))
              {
            Shape3D shape3D = (Shape3D)parent;
            if (selection.IsInside(shape3D.x, shape3D.y))
            {
              target.Add(parent);
              //return; // iterate through children as well - the CloneForClipboard will take care of handling duplicates
            }
              }

              if (parent.HasChildren())
              {
            ShapeCollection children = parent.ChildCollection;
            foreach (ShapeBase child in children)
              AddShapesRecursive(target, child, selection);
              }
        }

      public override IShapeVisitor.VisitResult Visit(ShapeBase shape)
      {
        if (shape is StaticMeshGroupShape)
        {
          StaticMeshGroupShape groupShape = shape as StaticMeshGroupShape;

          if (groupShape == _ignoreShape || groupShape.ExportFileName == null || groupShape.ExportFileName == "")
          {
            return VisitResult.VisitOk;
          }

          if (groupShape.ExportFileName.StartsWith(_searchExportFileName))
          {
            int newIndex = -1;
            string remaining = groupShape.ExportFileName.Substring(_searchExportFileName.Length);
            if (remaining.Length > 0)
            {
              try
              {
                newIndex = Convert.ToInt32(remaining);
              }
              catch (Exception)
              {
                newIndex = -1;
              }
            }
            if (newIndex > _maxIndex)
            {
              _maxIndex = newIndex;
            }
          }
        }
        return VisitResult.VisitOk;
      }  

        private void SelectEntities(ShapeBase shape, String classText, String modelText, ShapeCollection sel)
        {
            //check the entity
            EntityShape entity = shape as EntityShape;
              if (entity!=null)
              {
            bool bSelect = true;

            if (checkEntityClass.Checked)
              bSelect &= (entity.EntityClass.ToUpper().IndexOf(classText)!=-1);
            if (checkModel.Checked)
              bSelect &= (entity.ModelFile.ToUpper().IndexOf(modelText)!=-1);

            if (bSelect)
              sel.Add(shape);
              }

            //check its children
            foreach(ShapeBase child in shape.ChildCollection)
            {
                SelectEntities(child, classText, modelText, sel);
            }
        }

        Layer GetUnAssignedLayer(ShapeBase shape)
        {
            if (_UnAssignedLayers == null)
            _UnAssignedLayers = new Dictionary<Layer, Layer>();

              Layer layer = null;
              if (!_UnAssignedLayers.TryGetValue(shape.ParentLayer, out layer))
              {
            Object[] parameters = { "UnassignedShapes_" + shape.ParentLayer.LayerName };
            layer = EditorManager.LayerFactory.CreateInstance(parameters);
            this.Add(new AddLayerAction(layer,true));
            _UnAssignedLayers.Add(shape.ParentLayer, layer);
              }
              return layer;
        }

        bool GetShapePosAndBox(ShapeBase shape, out Vector3F pos, out BoundingBox box)
        {
            if (shape.HasChildren())
              {
            int iValidCount = 0;
            BoundingBox baccum = new BoundingBox();
            Vector3F paccum = Vector3F.Zero;
            foreach (ShapeBase child in shape.ChildCollection)
            {
              BoundingBox b1;
              Vector3F p1;
              if (!GetShapePosAndBox(child, out p1, out b1))
            continue;
              iValidCount++;
              paccum += p1;
              if (b1 != null && b1.Valid)
            baccum.AddBox(b1);
            }
            pos = paccum;
            box = baccum;
            if (iValidCount == 0)
              return false;
            pos *= (1.0f / (float)iValidCount); // average position
            return true;
              }

              if (shape is Shape3D)
              {
            pos = ((Shape3D)shape).Position;
            box = ((Shape3D)shape).AbsoluteBoundingBox;
            if (box == null || !box.Valid)
              box = null;
            return true;
              }
              pos = Vector3F.Zero;
              box = null;
              return false;
        }

        Layer GetBestLayer(ShapeBase shape)
        {
            BoundingBox bbox;
              Vector3F pos;
              if (!GetShapePosAndBox(shape, out pos, out bbox))
            return null;
              if (bbox != null && bbox.Valid)
            pos = bbox.Center; // position from box center

              Zone bestZone = null;
              float fMinDist = 1000000000000.0f;
              foreach (Zone zone in _zones)
              {
            if (zone.Layers.Count < 1)
              continue;
            BoundingBox zonebox = zone.AssignmentBoundingBox;
            float fDist = zonebox.GetDistance(pos);
            if (fDist <= 0.0f)
            {
              if (bbox != null && bbox.Valid && zonebox.IsInside(bbox))
            fDist -= 10.0f; // extra score
            }
            if (bestZone == null || fDist < fMinDist)
            {
              bestZone = zone;
              fMinDist = fDist;
            }
              }
              if (bestZone == null)
            return null;
              return bestZone.Layers[0];
        }

 public ShapeCreatedEventArgs(ShapeBase shape)
 {
     _shape = shape;
 }

 public GestureListener(ShapeBase shape)
 {
     Shape = shape;
 }

 /// <summary>
 /// This shape type cannot be dragged in the tree view
 /// </summary>
 /// <param name="newParent"></param>
 /// <returns></returns>
 public override bool AllowsToSetParent(ShapeBase newParent)
 {
     return false;
 }

 public override void OnChildRemoved(ShapeBase childShape, int iDepth)
 {
   base.OnChildRemoved(childShape, iDepth);
   this._relevantShapes = null;
 }

        void AddPhysXComponentsRecursive(ShapeComponentCollection list, ShapeCollection entityList, ShapeBase parent)
        {
            if (parent.ShapeVirtualCounter > 0 || !parent.Modifiable)
            return;
              if (parent.ComponentCount > 0)
              {
            foreach (ShapeComponent comp in parent.Components)
            {
              if (!comp.Missing)
            continue;
              if (comp.DisplayName == "vPhysXRigidBody" || comp.DisplayName == "vPhysXCharacterController")
              {
            // Catch invalid casts
            try
            {
              UInt32 iValue = System.Convert.ToUInt32(comp.GetPropertyValue("m_iCollisionBitmask", false));
              if (iValue != 0)
                list.Add(comp);
            }
            catch(InvalidCastException)
            {}
              }
            }
              }
              EntityShape entity = parent as EntityShape;
              if (entity != null && (entity.EntityClass == "vPhysXEntity" || entity.EntityClass == "LineFollowerEntity_cl"))
              {
            entityList.Add(entity);
              }

              if (parent.HasChildren())
            foreach (ShapeBase shape in parent.ChildCollection)
              AddPhysXComponentsRecursive(list, entityList, shape);
        }

 public GetExportFileNameMaxIndexVisitor(string searchExportFileName, ShapeBase ignoreShape)
 {
   _searchExportFileName = searchExportFileName;
   _ignoreShape = ignoreShape;
 }

 public override bool AllowsToAddChild(ShapeBase newChild)
 {
     if (!(newChild is CustomVolumeVertex))
       {
     return false;
       }
       return base.AllowsToAddChild(newChild);
 }

 /// <summary>
 /// Overridden function
 /// </summary>
 /// <param name="child"></param>
 public override void RemoveChild(ShapeBase child)
 {
     base.RemoveChild(child);
       if (child is CustomVolumeVertex)
     Update();
 }