示例#1
0
 void _items_E_ItemChanged(wTreeNodeItem item)
 {
     if (E_TreeNodeChanged != null)
     {
         E_TreeNodeChanged(this, _items.IndexOf(item));
     }
 }
示例#2
0
 void _items_E_ItemListChanged(wTreeNodeItem item)
 {
     if (E_TreeNodeChanged != null)
     {
         E_TreeNodeChanged(this, -1);
     }
 }
示例#3
0
 void editor_E_EditorValueChanging(wTreeNodeItem item, wEditorValueChangingArgs args)
 {
     if (E_TreeNodeEditorValueChanging != null)
     {
         E_TreeNodeEditorValueChanging(item, args);
     }
 }
 /// <summary>
 /// 체크박스의 값을 toggle한다.
 /// </summary>
 /// <param name="node"></param>
 /// <param name="itemIndex"></param>
 internal void SetCheckboxIfItemIsCheckbox(wTreeNode node, int itemIndex)
 {
     if (node.Items[itemIndex] != null && node.Items[itemIndex].ItemType == wTreeNodeItemTypes.CheckBox)
     {
         wTreeNodeItem item  = node.Items[itemIndex];
         bool?         value = (bool?)item.Value;
         if (value == true)
         {
             item.Value = false;
         }
         else if (value == false)
         {
             item.Value = true;
         }
         else
         {
             item.Value = true; //중간상태일 때는 true로 바꿈.
         }
         bool newValue = (bool)item.Value;
         node.ControlChildChecks(itemIndex, newValue);
         node.ControlParentChecks(itemIndex);
         node.DrawBuffer();
         _ownerTree.wDrawHandler.ReDrawTree(false);
         if (E_CheckItemChanged != null)
         {
             E_CheckItemChanged(node, item, newValue);
         }
     }
 }
示例#5
0
 void editor_E_EditorValueChanged(wTreeNodeItem item, object oldValue, object newValue)
 {
     if (E_TreeNodeItemValueChanged != null)
     {
         E_TreeNodeItemValueChanged(item.OwnerNode, item, oldValue, newValue);
     }
 }
示例#6
0
 void editor_E_EditorValueChangeCanceled(wTreeNode node, wTreeNodeItem item)
 {
     if (E_TreeNodeItemValueChangeCanceled != null)
     {
         E_TreeNodeItemValueChangeCanceled(node, item);
     }
 }
示例#7
0
 void _items_E_ItemChanged(wTreeNodeItem item)
 {
     //DrawBuffer();
     _needRefresh = true;
     if (E_TreeNodeChanged != null)
     {
         E_TreeNodeChanged(this, new wTreeNodeChangedEventArgs(_items.IndexOf(item)));
     }
 }
示例#8
0
        void textEditor_LostFocus(object sender, EventArgs e)
        {
            TextBox       box  = sender as TextBox;
            wTreeNodeItem item = ItemToEdit;

            object oldValue = item.Value;

            OnEditorValueChanged(oldValue, box.Text);
            HideEditor();
        }
示例#9
0
        /// <summary>
        /// item을 위해서 textboxeditor를 보여준다.
        /// </summary>
        /// <param name="item"></param>
        public override void ShowEditorFor(wTreeNodeItem item, Rectangle area)
        {
            if (SelectionHandler.SelectedNode != item.OwnerNode)
            {
                SelectionHandler.SelectedNode = item.OwnerNode;
                DrawHandler.ReDrawTree(false);
            }
            EditorControl.Text = item.Value.ToString();

            base.ShowEditorFor(item, area);
        }
示例#10
0
        void comboEditor_LostFocus(object sender, EventArgs e)
        {
            if (EventEnabled == false)
            {
                return;
            }
            ComboBox      box  = sender as ComboBox;
            wTreeNodeItem item = ItemToEdit;

            object oldValue = item.Value;

            OnEditorValueChanged(oldValue, box.Text);
            HideEditor();
        }
示例#11
0
        void comboEditor_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (EventEnabled == false)
            {
                return;
            }
            ComboBox      box      = sender as ComboBox;
            wTreeNodeItem item     = ItemToEdit;
            object        oldValue = item.Value;

            item.TextArraySelectedIndex = box.SelectedIndex;

            OnEditorValueChanged(oldValue, item.TextArraySelectedIndex);
            HideEditor();
        }
        /// <summary>
        /// item을 위해서 textboxeditor를 보여준다.
        /// </summary>
        /// <param name="item"></param>
        public override void ShowEditorFor(wTreeNodeItem item, Rectangle area)
        {
            base.ShowEditorFor(item, area);
            ImageSelectorDialog dlg    = new ImageSelectorDialog();
            DialogResult        result = dlg.ShowDialog(item.Image, item._imageWidth, item._imageHeight);

            if (result == DialogResult.Abort || result == DialogResult.Cancel)
            {
                return;
            }
            item.Image        = dlg.NewImage;
            item._imageWidth  = dlg.ImageWidth;
            item._imageHeight = dlg.ImageHeight;
            item.OwnerNode.DrawBuffer();
            DrawHandler.ReDrawTree(false);
        }
示例#13
0
 /// <summary>
 /// 특정 값으로 체크박스를 셋팅한다.
 /// </summary>
 /// <param name="node"></param>
 /// <param name="itemIndex"></param>
 /// <param name="checkBoxValue"></param>
 internal void SetCheckboxValueIfItemIsCheckbox(wTreeNode node, int itemIndex, bool checkBoxValue)
 {
     if (node.Items[itemIndex] != null && node.Items[itemIndex].ItemType == wTreeNodeItemTypes.CheckBox)
     {
         wTreeNodeItem item = node.Items[itemIndex];
         item.Value = checkBoxValue;
         bool newValue = (bool)item.Value;
         node.ControlChildChecks(itemIndex, newValue);
         node.ControlParentChecks(itemIndex);
         node.DrawBuffer();
         _ownerTree.wDrawHandler.ReDrawTree(false);
         if (E_CheckItemChanged != null)
         {
             E_CheckItemChanged(node, item, newValue);
         }
     }
 }
示例#14
0
        /// <summary>
        /// 체크박스의 값을 toggle한다.
        /// </summary>
        /// <param name="parentNode"></param>
        /// <param name="itemIndex"></param>
        internal void SetCheckboxIfItemIsCheckbox(IwTreeNodeCollectionParent parentNode, int childStart, int childEnd, int itemIndex)
        {
            int min = childStart < childEnd ? childStart : childEnd;
            int max = childStart < childEnd ? childEnd : childStart;
            Dictionary <wTreeNodeItem, bool> itemValues = new Dictionary <wTreeNodeItem, bool>();

            for (int i = min; i <= max; i++)
            {
                if (i == childStart)
                {
                    continue;
                }
                wTreeNode child = parentNode.Children[i];

                if (child.Items[itemIndex] != null && child.Items[itemIndex].ItemType == wTreeNodeItemTypes.CheckBox)
                {
                    wTreeNodeItem item  = child.Items[itemIndex];
                    bool?         value = (bool?)item.Value;
                    if (value == true)
                    {
                        item.Value = false;
                    }
                    else if (value == false)
                    {
                        item.Value = true;
                    }
                    else
                    {
                        item.Value = true; //중간상태일 때는 true로 바꿈.
                    }
                    bool newValue = (bool)item.Value;
                    child.ControlChildChecks(itemIndex, newValue);
                    child.DrawBuffer();
                    itemValues.Add(item, newValue);//toggle이니까 무조건 바뀐다.
                }
            }
            parentNode.Children[0].ControlParentChecks(itemIndex);
            _ownerTree.wDrawHandler.ReDrawTree(false);
            if (itemValues.Count > 0)
            {
                if (E_CheckItemChanged != null)
                {
                    E_CheckItemsChanged(parentNode as wTreeNode, itemValues);
                }
            }
        }
示例#15
0
        /// <summary>
        /// node를 선택하고, item을 선택하면 해당 Action을 한다. 이 함수의 결과로 SelectedItem이 바뀐다.
        /// </summary>
        /// <param name="selectedNode"></param>
        /// <param name="pt"></param>
        internal void SetNodeSelected(wTreeNode selectedNode, wTreeNodeItem item)
        {
            wTreeNodeItemSelectingArgs args = new wTreeNodeItemSelectingArgs();

            if (E_TreeNodeSelecting != null)
            {
                E_TreeNodeSelecting(SelectedNode, item, args);
            }
            if (args.IsCancel)
            {
                return;
            }
            //_pressedNode = selectedNode;
            if (selectedNode != null)
            {
                //selectedNode.IsExpaned = !selectedNode.IsExpaned;

                if (item != null)
                {
                    //_pressedItem = item;
                    //MessageBox.Show(item.ItemType.ToString());

                    if (item.ItemType == wTreeNodeItemTypes.PlusMinus)
                    {
                        selectedNode.IsExpanded = !selectedNode.IsExpanded;
                        selectedNode.ReDrawNode();
                        //_ownerTree.DrawHandler.ReDrawTree(true);
                    }
                }
                _selectedItem = item;

                if (E_TreeNodeSelected != null)
                {
                    E_TreeNodeSelected(SelectedNode, item);
                }
            }


            //this.Focus();
        }
示例#16
0
        /// <summary>
        /// 특정 값으로 체크박스를 셋팅한다.
        /// </summary>
        /// <param name="node"></param>
        /// <param name="itemIndex"></param>
        /// <param name="checkBoxValue"></param>
        internal void SetCheckboxValueIfItemIsCheckbox(IwTreeNodeCollectionParent parentNode, int childStart, int childEnd, int itemIndex, bool checkBoxValue)
        {
            int min = childStart < childEnd ? childStart : childEnd;
            int max = childStart < childEnd ? childEnd : childStart;
            Dictionary <wTreeNodeItem, bool> itemValues = new Dictionary <wTreeNodeItem, bool>();

            for (int i = min; i <= max; i++)
            {
                wTreeNode child = parentNode.Children[i];


                if (child.Items[itemIndex] != null && child.Items[itemIndex].ItemType == wTreeNodeItemTypes.CheckBox)
                {
                    wTreeNodeItem item     = child.Items[itemIndex];
                    bool?         oldValue = (bool?)item.Value;
                    if (checkBoxValue != oldValue)
                    {
                        item.Value = checkBoxValue;
                        bool newValue = (bool)item.Value;
                        child.ControlChildChecks(itemIndex, newValue);
                        child.DrawBuffer();
                        if (oldValue != newValue)
                        {
                            itemValues.Add(item, newValue);                      //값이 바뀔 때만 추가한다.
                        }
                    }
                }
            }
            parentNode.Children[0].ControlParentChecks(itemIndex);
            _ownerTree.wDrawHandler.ReDrawTree(false);
            if (itemValues.Count > 0)
            {
                if (E_CheckItemChanged != null)
                {
                    E_CheckItemsChanged(parentNode as wTreeNode, itemValues);
                }
            }
        }
示例#17
0
        void textEditor_KeyUp(object sender, KeyEventArgs e)
        {
            TextBox       box  = sender as TextBox;
            wTreeNodeItem item = ItemToEdit;

            if (Control.ModifierKeys == Keys.None)
            {
                if ((e.KeyData) == Keys.Enter)
                {
                    object oldValue = item.Value;

                    OnEditorValueChanged(oldValue, box.Text, true);

                    HideEditor();
                    _isValueChanged = false;
                }
                else if ((e.KeyData) == Keys.Escape)
                {
                    OnValueChangeCanceled();
                    HideEditor();
                }
            }
        }
示例#18
0
        /// <summary>
        /// item을 위해서 textboxeditor를 보여준다.
        /// </summary>
        /// <param name="item"></param>
        public override void ShowEditorFor(wTreeNodeItem item, Rectangle area)
        {
            ComboBox.Items.Clear();
            Image    temp   = new Bitmap(100, 100);
            Graphics g      = Graphics.FromImage(temp);
            int      maxWid = 0;

            foreach (string text in item.TextArray)
            {
                SizeF size = g.MeasureString(text, ComboBox.Font);
                if (maxWid < (int)size.Width + 1)
                {
                    maxWid = (int)size.Width + 1;
                }
                ComboBox.Items.Add(text);
            }
            Rectangle rect = new Rectangle(area.X, area.Y, maxWid + 10, area.Height);

            base.ShowEditorFor(item, rect);
            ComboBox.DroppedDown   = true;
            EventEnabled           = false;
            ComboBox.SelectedIndex = item.TextArraySelectedIndex;
            EventEnabled           = true;
        }
示例#19
0
        /// <summary>
        /// Editor를 시작할 때 할 작업..
        /// </summary>
        /// <param name="item"></param>
        public virtual void ShowEditorFor(wTreeNodeItem item, Rectangle area)
        {
            _itemToEdit = item;

            _ownerTree.wEditorHandler.ShowEditor(this, area);
        }
示例#20
0
 internal void OnNodeItemValueChanged(wTreeNode node, wTreeNodeItem item, object oldValue, object newValue)
 {
     E_TreeNodeItemValueChanged(node, item, oldValue, newValue);
 }
示例#21
0
 internal void OnNodeItemValueChangeCanceled(wTreeNode node, wTreeNodeItem item)
 {
     E_TreeNodeItemValueChangeCanceled(node, item);
 }
示例#22
0
        public void ShowEditor(wTreeNodeItem item, Rectangle area)
        {
            if (item.ItemType == wTreeNodeItemTypes.Image)
            {
                if (item.ImageEditorType == ImageEditorTypes.Custom)
                {
                    item.CustomEditor.SetValue(item.Value);
                    if (item.CustomEditor != null)
                    {
                        ShowEditor(item.CustomEditor, area);
                    }
                }
                else if (item.ImageEditorType == ImageEditorTypes.ImageSelector)
                {
                    _imageSelector.ShowEditorFor(item, area);
                }
                else if (item.ImageEditorType == ImageEditorTypes.None)
                {
                    if (BasicImageEditor == ImageEditorTypes.ImageSelector)
                    {
                        _imageSelector.ShowEditorFor(item, area);
                    }
                }
            }
            else if (item.ItemType == wTreeNodeItemTypes.Text)
            {
                if (item.TextEditorType == TextEditorTypes.None)
                {
                    if (BasicTextEditor == TextEditorTypes.TextBox)
                    {
                        _textBoxEditor.ShowEditorFor(item, area);
                    }
                }
                else if (item.TextEditorType == TextEditorTypes.TextBox)
                {
                    _textBoxEditor.ShowEditorFor(item, area);
                }

                else if (item.TextEditorType == TextEditorTypes.Custom)
                {
                    if (item.CustomEditor != null)
                    {
                        item.CustomEditor.ShowEditorFor(item, area);
                    }
                }
            }
            else if (item.ItemType == wTreeNodeItemTypes.TextArray)
            {
                if (item.TextArrayEditorType == TextArrayEditorTypes.None)
                {
                    if (BasicTextArrayEditor == TextArrayEditorTypes.ComboBox)
                    {
                        Rectangle rect = new Rectangle(area.X, area.Y, area.Width + 10, area.Height);
                        _comboBoxEditor.ShowEditorFor(item, rect);
                    }
                }
                else if (item.TextArrayEditorType == TextArrayEditorTypes.ComboBox)
                {
                    Rectangle rect = new Rectangle(area.X, area.Y, area.Width + 10, area.Height);
                    _comboBoxEditor.ShowEditorFor(item, rect);
                }
                else if (item.TextArrayEditorType == TextArrayEditorTypes.Custom)
                {
                    if (item.CustomEditor != null)
                    {
                        item.CustomEditor.ShowEditorFor(item, area);
                    }
                }
            }
        }
        void wTree_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            Point pt;
            //= new Point(e.X - Margin.Left, e.Y - Margin.Top);
            wTreeNode              clickedNode = GetNodeFromPoint(e.Location, out pt);// _pressedNode;
            wTreeNodeItem          item        = clickedNode.GetItemFromPoint(pt);
            wTreeNodeItemMouseArgs args        = new wTreeNodeItemMouseArgs(e);

            if (E_TreeNodeDoubleClicked != null)
            {
                E_TreeNodeDoubleClicked(clickedNode, item, args);
            }

            if (args.IsCanceled)
            {
                return;
            }

            if (_lastMouseUpNode != null)
            {
                //selectedNode.IsExpaned = !selectedNode.IsExpaned;

                if (item != null)
                {
                    if (e.Button == System.Windows.Forms.MouseButtons.Left)
                    {
                        if (Control.ModifierKeys == Keys.None)
                        {
                            if (item.ItemType == wTreeNodeItemTypes.CheckBox && (item.CheckBoxActiveAction & CheckboxActiveActions.DoubleClick) == CheckboxActiveActions.DoubleClick)
                            {
                                SelectionHandler.SetCheckboxIfItemIsCheckbox(_lastMouseUpNode, item.ItemIndex);
                            }
                            else
                            {
                                if (item.EditorActivateAction == EditorActivateActions.DoubleClick)
                                {
                                    EditorHandler.ShowEditor(item, item.ItemArea);
                                }
                                else if (item.EditorActivateAction == EditorActivateActions.UseBasicSetting)
                                {
                                    if (EditorHandler.EditorActivateAction == EditorActivateBasicActions.DoubleClick)
                                    {
                                        EditorHandler.ShowEditor(item, item.ItemArea);
                                    }
                                }
                            }
                        }
                        else if ((Control.ModifierKeys & Keys.Control) == Keys.Control)
                        {
                            if (item.EditorActivateAction == EditorActivateActions.CtrlDoubleClick)
                            {
                                EditorHandler.ShowEditor(item, item.ItemArea);
                            }
                            else if (item.EditorActivateAction == EditorActivateActions.UseBasicSetting)
                            {
                                if (EditorHandler.EditorActivateAction == EditorActivateBasicActions.CtrlDoubleClick)
                                {
                                    EditorHandler.ShowEditor(item, item.ItemArea);
                                }
                            }
                        }
                        else if ((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
                        {
                            if (item.EditorActivateAction == EditorActivateActions.ShiftDoubleClick)
                            {
                                EditorHandler.ShowEditor(item, item.ItemArea);
                            }
                            else if (item.EditorActivateAction == EditorActivateActions.UseBasicSetting)
                            {
                                if (EditorHandler.EditorActivateAction == EditorActivateBasicActions.ShiftDoubleClick)
                                {
                                    EditorHandler.ShowEditor(item, item.ItemArea);
                                }
                            }
                        }
                        else if ((Control.ModifierKeys & Keys.Alt) == Keys.Alt)
                        {
                            if (item.EditorActivateAction == EditorActivateActions.AltDoubleClick)
                            {
                                EditorHandler.ShowEditor(item, item.ItemArea);
                            }
                            else if (item.EditorActivateAction == EditorActivateActions.UseBasicSetting)
                            {
                                if (EditorHandler.EditorActivateAction == EditorActivateBasicActions.AltDoubleClick)
                                {
                                    EditorHandler.ShowEditor(item, item.ItemArea);
                                }
                            }
                        }
                    }
                }



                _doubleClicked = true;
            }
        }
        void _ownerTree_MouseClick(object sender, MouseEventArgs e)
        {
            if (e.Clicks != 1)
            {
                return;
            }

            Point pt;

            //= new Point(e.X - Margin.Left, e.Y - Margin.Top);
            wTreeNode              clickedNode = GetNodeFromPoint(e.Location, out pt);// _pressedNode;
            wTreeNodeItem          item        = (clickedNode == null)? null : clickedNode.GetItemFromPoint(pt);
            wTreeNodeItemMouseArgs args        = new wTreeNodeItemMouseArgs(new MouseEventArgs(e.Button, e.Clicks, pt.X, pt.Y, e.Delta));

            if (E_TreeNodeClicked != null)
            {
                E_TreeNodeClicked(clickedNode, item, args);
            }
            if (args.IsCanceled)
            {
                return;
            }

            if (clickedNode != null)
            {
                //selectedNode.IsExpaned = !selectedNode.IsExpaned;

                if (item != null)
                {
                    #region item is not null
                    if (e.Button == System.Windows.Forms.MouseButtons.Left)
                    {
                        if (Control.ModifierKeys == Keys.None)
                        {
                            if (item.ItemType == wTreeNodeItemTypes.CheckBox && (item.CheckBoxActiveAction & CheckboxActiveActions.Click) == CheckboxActiveActions.Click)
                            {
                                SelectionHandler.SetCheckboxIfItemIsCheckbox(clickedNode, item.ItemIndex);
                            }
                            else
                            {
                                if (clickedNode.IsSelected)
                                {
                                    if ((item.EditorActivateAction & EditorActivateActions.ClickOnSelection) == EditorActivateActions.ClickOnSelection)
                                    {
                                        EditorHandler.ShowEditor(item, item.ItemArea);
                                    }
                                    else if ((item.EditorActivateAction & EditorActivateActions.Click) == EditorActivateActions.Click)
                                    {
                                        EditorHandler.ShowEditor(item, item.ItemArea);
                                    }
                                    else if (item.EditorActivateAction == EditorActivateActions.UseBasicSetting)
                                    {
                                        if ((EditorHandler.EditorActivateAction & EditorActivateBasicActions.ClickOnSelection) == EditorActivateBasicActions.ClickOnSelection)
                                        {
                                            EditorHandler.ShowEditor(item, item.ItemArea);
                                        }
                                        else if ((EditorHandler.EditorActivateAction & EditorActivateBasicActions.Click) == EditorActivateBasicActions.Click)
                                        {
                                            EditorHandler.ShowEditor(item, item.ItemArea);
                                        }
                                    }
                                }
                                else
                                {
                                    if ((item.EditorActivateAction & EditorActivateActions.Click) == EditorActivateActions.Click)
                                    {
                                        EditorHandler.ShowEditor(item, item.ItemArea);
                                    }
                                }
                                _isShiftDown = false;

                                SelectionHandler.SelectedNode = clickedNode;
                                SelectionHandler.SetNodeSelected(clickedNode, item);
                            }
                        }
                        else if ((Control.ModifierKeys & Keys.Control) == Keys.Control)
                        {
                            if (item.ItemType == wTreeNodeItemTypes.CheckBox && (item.CheckBoxActiveAction & CheckboxActiveActions.Click) == CheckboxActiveActions.Click)
                            {
                                if (clickedNode != null && clickedNode.TreeParent == clickedNode.TreeParent)
                                {
                                    int itemIndex = item.ItemIndex;
                                    int lastIndex = clickedNode.Index;


                                    SelectionHandler.SetCheckboxValueIfItemIsCheckbox(clickedNode.TreeParent, lastIndex, clickedNode.Index, itemIndex, true);
                                }
                                else
                                {
                                    if ((item.CheckBoxActiveAction & CheckboxActiveActions.Click) == CheckboxActiveActions.Click)
                                    {
                                        SelectionHandler.SetCheckboxValueIfItemIsCheckbox(clickedNode, item.ItemIndex, true);
                                    }
                                }
                            }
                            else
                            {
                                if (clickedNode.IsSelected)
                                {
                                    clickedNode.SetSelection(false);
                                    SelectedNode = null;
                                    clickedNode.DrawBuffer();
                                }
                                else
                                {
                                    clickedNode.SetSelection(true);
                                    SelectedNode = null;
                                    clickedNode.DrawBuffer();
                                }

                                if ((item.EditorActivateAction & EditorActivateActions.CtrlClick) == EditorActivateActions.CtrlClick)
                                {
                                    EditorHandler.ShowEditor(item, item.ItemArea);
                                }
                                else if (item.EditorActivateAction == EditorActivateActions.UseBasicSetting)
                                {
                                    if ((EditorHandler.EditorActivateAction & EditorActivateBasicActions.CtrlClick) == EditorActivateBasicActions.CtrlClick)
                                    {
                                        EditorHandler.ShowEditor(item, item.ItemArea);
                                    }
                                }
                            }
                        }
                        else if ((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
                        {
                            _isShiftDown = true;

                            if (item.ItemType == wTreeNodeItemTypes.CheckBox && (item.CheckBoxActiveAction & CheckboxActiveActions.Click) == CheckboxActiveActions.Click)
                            {
                                if (clickedNode != null && clickedNode.TreeParent == clickedNode.TreeParent)
                                {
                                    int itemIndex = item.ItemIndex;
                                    int lastIndex = (_oldClickedNode == null)? clickedNode.Index : _oldClickedNode.Index;

                                    SelectionHandler.SetCheckboxIfItemIsCheckbox(clickedNode.TreeParent, lastIndex, clickedNode.Index, itemIndex);
                                }
                                else
                                {
                                    if ((item.CheckBoxActiveAction & CheckboxActiveActions.Click) == CheckboxActiveActions.Click)
                                    {
                                        SelectionHandler.SetCheckboxIfItemIsCheckbox(clickedNode, item.ItemIndex);
                                    }
                                }
                            }
                            else
                            {
                                if ((item.EditorActivateAction & EditorActivateActions.ShiftClick) == EditorActivateActions.ShiftClick)
                                {
                                    EditorHandler.ShowEditor(item, item.ItemArea);
                                }
                                else if (item.EditorActivateAction == EditorActivateActions.UseBasicSetting)
                                {
                                    if ((EditorHandler.EditorActivateAction & EditorActivateBasicActions.ShiftClick) == EditorActivateBasicActions.ShiftClick)
                                    {
                                        EditorHandler.ShowEditor(item, item.ItemArea);
                                    }
                                }
                            }
                        }
                        else if ((Control.ModifierKeys & Keys.Alt) == Keys.Alt)
                        {
                            if (item.ItemType == wTreeNodeItemTypes.CheckBox && (item.CheckBoxActiveAction & CheckboxActiveActions.Click) == CheckboxActiveActions.Click)
                            {
                                if (clickedNode != null && clickedNode.TreeParent == clickedNode.TreeParent)
                                {
                                    int itemIndex = item.ItemIndex;
                                    int lastIndex = clickedNode.Index;
                                    SelectionHandler.SetCheckboxIfItemIsCheckbox(clickedNode.TreeParent, lastIndex, clickedNode.Index, itemIndex);
                                }
                                else
                                {
                                    if ((item.CheckBoxActiveAction & CheckboxActiveActions.Click) == CheckboxActiveActions.Click)
                                    {
                                        SelectionHandler.SetCheckboxValueIfItemIsCheckbox(clickedNode, item.ItemIndex, false);
                                    }
                                }
                            }
                            else
                            {
                                if ((item.EditorActivateAction & EditorActivateActions.AltClick) == EditorActivateActions.AltClick)
                                {
                                    EditorHandler.ShowEditor(item, item.ItemArea);
                                }
                                else if (item.EditorActivateAction == EditorActivateActions.UseBasicSetting)
                                {
                                    if ((EditorHandler.EditorActivateAction & EditorActivateBasicActions.AltClick) == EditorActivateBasicActions.AltClick)
                                    {
                                        EditorHandler.ShowEditor(item, item.ItemArea);
                                    }
                                }
                            }
                        }
                    }
                    #endregion
                }
                else // item is null
                {
                    if (e.Button == System.Windows.Forms.MouseButtons.Left)
                    {
                        if (Control.ModifierKeys == Keys.None)
                        {
                            _isShiftDown = false;

                            SelectionHandler.SelectedNode = clickedNode;
                            SelectionHandler.SetNodeSelected(clickedNode, item);
                        }
                        else if ((Control.ModifierKeys & Keys.Control) == Keys.Control)
                        {
                            if (clickedNode.IsSelected)
                            {
                                clickedNode.SetSelection(false);
                                SelectedNode = null;
                                clickedNode.DrawBuffer();
                            }
                            else
                            {
                                clickedNode.SetSelection(true);
                                SelectedNode = null;
                                clickedNode.DrawBuffer();
                            }
                        }
                        else if ((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
                        {
                            _isShiftDown = true;
                        }
                        else if ((Control.ModifierKeys & Keys.Alt) == Keys.Alt)
                        {
                        }
                    }
                }


                _oldClickedNode = clickedNode;
            }
        }
        /// <summary>
        /// 마우스 키를 눌렀을 때
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void wTree_MouseDown(object sender, MouseEventArgs e)
        {
            Point     pt;
            wTreeNode selectedNode = GetNodeFromPoint(e.Location, out pt);
            //int index = 0;
            wTreeNodeItemMouseArgs args = new wTreeNodeItemMouseArgs(new MouseEventArgs(e.Button, e.Clicks, pt.X, pt.Y, e.Delta));
            wTreeNodeItem          item = (selectedNode == null) ? null : selectedNode.GetItemFromPoint(pt);

            if (E_TreeNodeMouseDown != null)
            {
                E_TreeNodeMouseDown(selectedNode, item, args);
            }
            if (args.IsCanceled)
            {
                return;
            }

            _pressedNode = selectedNode;
            _pressedItem = item;
            if (_pressedItem != null && _pressedItem.ItemType == wTreeNodeItemTypes.CheckBox)
            {
            }
            else
            {
                if ((ModifierKeys & Keys.Control) != Keys.Control)//Control을 안눌렀다면 이전의 선택부분을 모두 지움..
                {
                    if ((ModifierKeys & Keys.Shift) == Keys.Shift)
                    {
                        if (_isShiftDown)//이전에 shift를 누른 채 떼지 않았다면..
                        {
                            //_pressedNode = _lastMouseUp;//이전에 클릭했던 지점부터 시작..

                            //SelectedNode = _lastMouseUp;
                            int tempSelecting = VisibleNodes.IndexOf(selectedNode);
                            SelectionHandler.drawSelectingNodes(VisibleNodes.IndexOf(_lastMouseUpNode), tempSelecting);
                            _isShiftDown = true;
                        }
                        else
                        {
                            SelectionHandler.ClearAllSelections();

                            //_pressedNode = _lastMouseUp;//이전에 클릭했던 지점부터 시작..

                            //SelectedNode = _lastMouseUp;
                            int tempSelectingStart = VisibleNodes.IndexOf(_lastMouseUpNode);
                            int tempSelecting      = VisibleNodes.IndexOf(selectedNode);
                            SelectionHandler.drawSelectingNodes(tempSelectingStart, tempSelecting);
                            _isShiftDown = true;
                        }
                        DrawHandler.ReDrawTree(false);
                    }
                    else
                    {
                        SelectionHandler.ClearAllSelections();

                        //SetNodeSelected(selectedNode, pt);
                        DrawHandler.ReDrawTree(false);
                    }

                    //this.Focus();
                }
            }
            if (EditorHandler.ActivatedEditor != null || _ownerTree.Focused == false)
            {
                ReleaseFocus();
            }
        }
        /// <summary>
        /// 마우스키를 뗐을 때..
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void wTree_MouseUp(object sender, MouseEventArgs e)
        {
            if (_doubleClicked)
            {
                _doubleClicked = false;
                return;
            }


            Point pt;
            //= new Point(e.X - Margin.Left, e.Y - Margin.Top);
            wTreeNode mouseUpNode = GetNodeFromPoint(e.Location, out pt);// _pressedNode;

            //Point pt;
            //wTreeNode clickedNode = GetNodeFromPoint(e.Location, out pt);// _pressedNode;
            //wTreeNodeItem item = clickedNode.GetItemFromPoint(pt);
            //wTreeNodeItemMouseArgs args = new wTreeNodeItemMouseArgs(e);
            //if (E_TreeNodeDoubleClicked != null) E_TreeNodeDoubleClicked(clickedNode, item, args);

            wTreeNodeItem item = (mouseUpNode == null)? null : mouseUpNode.GetItemFromPoint(pt);

            wTreeNodeItemMouseArgs args = new wTreeNodeItemMouseArgs(new MouseEventArgs(e.Button, e.Clicks, pt.X, pt.Y, e.Delta));


            if (E_TreeNodeMouseUp != null)
            {
                E_TreeNodeMouseUp(mouseUpNode, mouseUpNode.GetItemFromPoint(pt), args);
            }
            if (args.IsCanceled)
            {
                return;
            }

            SelectionHandler.FixSelections();

            if (_pressedNode != null && mouseUpNode != null)
            {
                bool isDragging;
                if (_pressedNode != mouseUpNode)
                {
                    isDragging = true;
                }
                else
                {
                    isDragging = false;
                }
                if (EditorHandler.ActivatedEditor != null && EditorHandler.ActivatedEditor.ItemToEdit != item)
                {
                    EditorHandler.HideEditor();
                }

                if (e.Button == System.Windows.Forms.MouseButtons.Left)
                {
                    if ((ModifierKeys & Keys.Control) == Keys.Control)
                    {
                        if (isDragging)//selection
                        {
                        }
                        else //제자리 클릭..
                        {
                        }
                    }
                    else if ((ModifierKeys & Keys.Shift) == Keys.Shift)
                    {
                    }
                    else
                    {
                    }
                }
                if (item != null && isDragging == false)                    //item clicked or right clicked
                {
                    if (e.Button == System.Windows.Forms.MouseButtons.Left) //item clicked
                    {
                        if (Control.ModifierKeys == Keys.None)
                        {//click
                        }
                        else if ((Control.ModifierKeys & Keys.Control) == Keys.Control)
                        {
                        }
                        else if ((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
                        {
                        }
                        else if ((Control.ModifierKeys & Keys.Alt) == Keys.Alt)
                        {
                        }
                    }
                }
            }

            _pressedNode = null;
            SelectionHandler.ReleaseTempSelection();

            _lastMouseUpNode = mouseUpNode;
            _lastMouseUpItem = item;
            DrawHandler.ReDrawTree(false);
            //SetNodeSelected(selectedNode, pt);
            //this.Focus();
        }
        /// <summary>
        /// 마우스커서가 움직일 때..
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void wTree_MouseMove(object sender, MouseEventArgs e)
        {
            bool isRollOver = (DrawHandler.BasicDrawing & BasicDrawings.RollOver) != BasicDrawings.None;
            bool isMultipleSelection //drag&drop 가능시 drag로 multiple selection은 활성화되면 안된다.
                = IsDragAndDropEnabled == false && (DrawHandler.BasicDrawing & BasicDrawings.MultiSelections) != BasicDrawings.None;


            if (isMultipleSelection ||
                E_TreeNodeMouseDragging != null
                )
            {
                if (Control.MouseButtons == System.Windows.Forms.MouseButtons.Left)
                {
                    wTreeNode hoveredNode = null;
                    Point     pt;
                    //= new Point(e.X - Margin.Left, e.Y - Margin.Top);
                    hoveredNode = GetNodeFromPoint(e.Location, out pt);// _pressedNode;
                    wTreeNodeItem item = (hoveredNode == null)? null : hoveredNode.GetItemFromPoint(pt);

                    if (_pressedNode != null)
                    {
                        wTreeNodeItemMouseArgs args = new wTreeNodeItemMouseArgs(new MouseEventArgs(e.Button, e.Clicks, pt.X, pt.Y, e.Delta));
                        bool isNewArea = (RollOverNode == null || RollOverNode.Equals(hoveredNode) == false);
                        if (E_TreeNodeMouseDragging != null)
                        {
                            E_TreeNodeMouseDragging(hoveredNode, item, isNewArea, args);
                        }
                        if (args.IsCanceled)
                        {
                            return;
                        }


                        if (hoveredNode != null && isNewArea)
                        {
                            int tempSelecting      = VisibleNodes.IndexOf(hoveredNode);
                            int tempSelectingStart = VisibleNodes.IndexOf(_pressedNode);
                            SelectionHandler.drawSelectingNodes(tempSelectingStart, tempSelecting);
                            wTreeNode oldRollOver = RollOverNode;
                            RollOverNode = hoveredNode;
                            if ((BasicDrawing & BasicDrawings.RollOver) == BasicDrawings.RollOver)
                            {
                                hoveredNode.DrawBuffer();
                            }


                            DrawHandler.ReDrawTree(false);
                            //if(oldRollOver!=null) ReDrawNode(oldRollOver);
                            //if(RollOverNode!=null) ReDrawNode(RollOverNode);
                        }
                    }
                }
            }
            else if (E_TreeNodeMouseMove != null ||
                     isRollOver
                     )//이벤트가 구현되었을 때만 들어가도록..
            {
                wTreeNode hoveredNode = null;
                Point     pt;
                //= new Point(e.X - Margin.Left, e.Y - Margin.Top);
                hoveredNode = GetNodeFromPoint(e.Location, out pt);// _pressedNode;

                //if (hoveredNode == null) return;

                wTreeNodeItem item = (hoveredNode == null) ? null : hoveredNode.GetItemFromPoint(pt);

                wTreeNodeItemMouseArgs args = new wTreeNodeItemMouseArgs(new MouseEventArgs(e.Button, e.Clicks, pt.X, pt.Y, e.Delta));
                bool isNewArea = (RollOverNode == null || RollOverNode.Equals(hoveredNode) == false);
                if (E_TreeNodeMouseMove != null)
                {
                    E_TreeNodeMouseMove(SelectionHandler.SelectedNode, item, isNewArea, args);
                }
                if (args.IsCanceled)
                {
                    return;
                }

                if (hoveredNode != null && isNewArea)
                {//selectedNode가 null이 아니고, 이전 _rollOverNode가 아닐 때, 혹은 처음 rollOver되었을 때..
                 //selectedNode.IsExpaned = !selectedNode.IsExpaned;



                    wTreeNode oldRollOver = RollOverNode;
                    RollOverNode = hoveredNode;

                    //SelectedNode = selectedNode;
                    if ((BasicDrawing & BasicDrawings.RollOver) == BasicDrawings.RollOver)
                    {
                        hoveredNode.DrawBuffer();
                    }

                    //wTreeNodeItem item = hoveredNode.GetItemFromPoint(pt);

                    if ((BasicDrawing & BasicDrawings.RollOver) == BasicDrawings.RollOver)
                    {
                        DrawHandler.ReDrawTree(false);
                    }
                    //if (oldRollOver != null) ReDrawNode(oldRollOver);
                    //if (RollOverNode != null) ReDrawNode(RollOverNode);
                }
            }
            else if (_pressedNode != null && IsDragAndDropEnabled)
            {
                if (E_TreeNodeDraggedOut != null)
                {
                    E_TreeNodeDraggedOut(_pressedNode, null, null);
                }
                _pressedNode = null;
                _pressedItem = null;
            }
        }