//-------------------------------------------------------------------------------------
 void treeView_SelectedNodeChanged(object sender, ITreeItem item)
 {
  if(isOkEnabled == null)
   ButtonOkEnabled = item != null;
  else
   ButtonOkEnabled = item == null ? false : isOkEnabled(item);
 }

 public void Select(ModifierKeys modifierKey, ICollection<ITreeItem> rootTreeItems, ITreeItem newSelectedItem, ITreeItem oldSelectedItem)
 {
     switch (modifierKey)
     {
         case ModifierKeys.Shift:
             if(_previousSelectionWasShift)
             {
                 _rangeSelector.Select(rootTreeItems, newSelectedItem, _previousShiftSelection);
             }
             else
             {
                 _rangeSelector.Select(rootTreeItems, newSelectedItem, oldSelectedItem);
                 _previousShiftSelection = oldSelectedItem;
             }
             _previousSelectionWasShift = true;
             break;
         case ModifierKeys.Control:
             _previousSelectionWasShift = false;
             _inverseSelector.Select(rootTreeItems, newSelectedItem);
             break;
         default:
             _previousSelectionWasShift = false;
             _nullSelector.Select(rootTreeItems, newSelectedItem);
             break;
     }
 }

			//-------------------------------------------------------------------------------------
			/// <summary>
			/// Инициализирующий конструктор.
			/// </summary>
			/// <param name="hasChildren">Определяет, имеются ли дочерние элементы.</param>
			/// <param name="item">Элемент дерева, для которого определяется наличие дочерних элементов.</param>
			/// <param name="tree">Дерево</param>
			public SimTreeGridItemEventArgs(ITree tree, ITreeItem item, bool hasChildren)
				: this()
			{
				Item = item;
				HasChildren = hasChildren;
				Tree = tree;
			}

        public ItemSelectorControl( ITreeItem itemEditor )
        {
            ItemEditor = itemEditor ;

            InitializeComponent( ) ;

            _levelExplorer = new LevelExplorerControl
                {
                    Dock = DockStyle.Fill,
                    Parent = this,
                    CheckBoxes= false,
                    Visible = true,
                    ShowToolStrip = false,
                    HideContextMenus=true,
                    InteractsWithModel=false
                } ;

            _levelExplorer.ItemSelected += ( s, e ) =>
                                           	{
                                           		if( e.Item is ItemEditor )
                                           		{
                                           			ItemEditor = e.Item as ItemEditor ;
                                           		}
                                           	} ;

            Controls.Add( _levelExplorer );

            _levelExplorer.Refresh(  );
        }

 public ModelChangedEventArgs( ITreeItem item )
 {
     ItemsAffected = new[ ]
         {
             item
         } ;
 }

        public void Select(ICollection<ITreeItem> items, ITreeItem item)
        {
            var flattenedItems = _hierarchyFlattener.Flatten(items);

            foreach (var treeItem in flattenedItems)
            {
                treeItem.IsSelected2 = treeItem == item;
            }
        }

 public void SelectItem(ITreeItem item)
 {
     if (_oldSelectedItem == null)
     {
         _oldSelectedItem = item;
     }
     _multiSelector.Select(Keyboard.Modifiers, _treeItems, item, _oldSelectedItem);
     _oldSelectedItem = item;
     SelectedItems = GetSelectedItems();
 }

		//-------------------------------------------------------------------------------------
		#region << Controls Handlers>>
		private void ftvTree_SelectedNodeChanged(object sender, ITreeItem item)
		{
			if(item == null)
			{
				propertyGrid.SelectedObject = null;
				lblEditSortOrder.Value = string.Empty;
				return;
			}
			propertyGrid.SelectedObject = item;
			lblEditSortOrder.Value = item.SortOrder == null ? string.Empty : item.SortOrder.ToString();
		}

 private void AddChildren(ITreeItem rootTreeItem)
 {
     if (rootTreeItem.Children != null)
     {
         foreach (var child in rootTreeItem.Children)
         {
             _denormalizedItems.Add(child);
             AddChildren(child);
         }
     }
 }

        internal static List<ITreeItem> CreateHierarchy(ITreeItem treeItem)
        {
            var hierarchy = new List<ITreeItem>();

            ITreeItem temp = treeItem;

            while (temp != null)
            {
                hierarchy.Add(temp);
                temp = temp.Parent;
            }

            return hierarchy;
        }

        public static void AddDiagram(ITreeItem project,
            bool select,
            Func<ITreeItem> createDiagram,
            IdCounter counter)
        {
            var diagram = CreateDiagramItem(null, createDiagram, counter);

            project.Add(diagram);

            ModelEditor.Store(null, diagram);

            if (select == true)
                diagram.SetSelected(true);
        }

 private static void AddSelectedItemsFromChildren(ITreeItem treeItem, ICollection<object> selectedItems)
 {
     if(treeItem.Children != null)
     {
         foreach (var child in treeItem.Children)
         {
             if (child.IsSelected2)
             {
                 var dataContext = ((TreeViewItem) treeItem).DataContext;
                 selectedItems.Add(dataContext);
             }
             AddSelectedItemsFromChildren(child, selectedItems);
         }
     }
 }

 public void Expand(ITreeItem treeItem)
 {
     var root = treeItem;
     var catchTreeItem = new List<ITreeItem>();
     while (true)
     {
         if (root == null)
             break;
         catchTreeItem.Insert(0, root);
         root = root.Parent;
     }
     foreach (var item in catchTreeItem)
     {
         (item as TreeItem).Expanded = true;
     }
 }

        public ITreeItem FindCommonAncestor(ITreeItem other)
        {
            if (other == null) throw new ArgumentNullException("other");

            if (Parent == other)
            {
                return Parent;
            }
            else
            {
                List<ITreeItem> myHierarchy = TreeItemHelper.CreateHierarchy(this);

                List<ITreeItem> othersHierarchy = TreeItemHelper.CreateHierarchy(other);

                IEnumerable<ITreeItem> intersection = myHierarchy.Intersect(othersHierarchy);

                return intersection.FirstOrDefault();
            }
        }

        IBehaviour buildBehaviour( ITreeItem forItem )
        {
            ItemProperties itemProperties = forItem.ItemProperties;

            var interpolationBehaviour = new PositionAnimationBehaviour(
                itemProperties,
                new PositionAnimationBehaviourProperties
                    {
                        DurationInSeconds = .75f,
                        Easing = Easing.EaseInOut,
                        From = itemProperties.Position,
                        To = Vector2.Zero,
                        Name = @"movement_animation_{0}".FormatWith(IoC.Model.NextItemNumber),
                        NameOfPropertyToModify = @"Position",
                        ClrTypeOfInterpolator = typeof(Quartic).AssemblyQualifiedName,
                    });

            return interpolationBehaviour ;
        }

        IBehaviour buildBehaviour(ITreeItem forEditor)
        {
            ItemProperties itemProperties = forEditor.ItemProperties ;

            var behaviour = new ScaleAnimationBehaviour(
                itemProperties,
                new FloatAnimationBehaviourProperties
                    {
                        DurationInSeconds = .75f,
                        Easing = Easing.EaseInOut,
                        From = 1,
                        To = 2,
                        Name = @"scale_animation_{0}".FormatWith( IoC.Model.NextItemNumber ),
                        NameOfPropertyToModify = @"Scale",
                        ClrTypeOfInterpolator = typeof( Quartic ).AssemblyQualifiedName
                    } ) ;

            return behaviour ;
        }

        public void Select(ICollection<ITreeItem> rootItems, ITreeItem item1, ITreeItem item2)
        {
            var flatItemsList = _hierarchyFlattener.Flatten(rootItems).ToList();
            var indexOfItem1 = flatItemsList.IndexOf(item1);
            var indexOfItem2 = flatItemsList.IndexOf(item2);

            ITreeItem firstItem;
            ITreeItem secondItem;

            if(indexOfItem1 < indexOfItem2)
            {
                firstItem = item1;
                secondItem = item2;
            }
            else
            {
                firstItem = item2;
                secondItem = item1;
            }

            var firstItemFound = false;
            var secondItemFound = false;
            foreach (var treeItem in flatItemsList)
            {
                if (treeItem == firstItem)
                {
                    firstItemFound = true;
                }
                if (firstItemFound && !secondItemFound)
                {
                    treeItem.IsSelected2 = true;
                }
                else
                {
                    treeItem.IsSelected2 = false;
                }
                if (treeItem == secondItem)
                {
                    secondItemFound = true;
                }
            }
        }

		//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		//-------------------------------------------------------------------------------------
		#region << Constructors >>
		/// <summary>
		/// Инициализирующий конструктор.
		/// </summary>
		/// <param name="item">Объект данных, для элемента которого определяется индекс изображения.</param>
		/// <param name="imageIndex">Индекс изображения.</param>
		public NeedImageIndexEventArgs(ITreeItem item, int imageIndex) : base ()
		{
			this.item = item;
			this.imageIndex = imageIndex;
		}

		/// <summary>
		/// Метод, вызывающий событие SelectedNodeChanged.
		/// </summary>
		/// <param name="item">Элемент дерева.</param>
		protected void OnSelectedNodeChanged(ITreeItem item)
		{
			if(SelectedNodeChanged != null)
				SelectedNodeChanged(this, item);
		}

		/// <summary>
		/// Метод, вызывающий событие SelectedNodeChanging.
		/// </summary>
		/// <param name="item">Элемент дерева.</param>
		protected bool OnSelectedNodeChanging(ITreeItem item)
		{
			if(SelectedNodeChanging != null)
			{
				CancelEventArgs<object> args = new CancelEventArgs<object>(item);
				SelectedNodeChanging(this, args);
				return args.Cancel;
			}
			else
				return false; 
		}