Alsing.Windows.Forms.SyntaxBox.EditViewControl.OnKeyDown C# (CSharp) 메소드

OnKeyDown() 보호된 메소드

Overrides the default OnKeyDown
protected OnKeyDown ( KeyEventArgs e ) : void
e System.Windows.Forms.KeyEventArgs
리턴 void
        protected override void OnKeyDown(KeyEventArgs e)
        {
            base.OnKeyDown(e);
            _KeyDownHandled = e.Handled;

            if (e.KeyCode == Keys.Escape && (InfoTipVisible || AutoListVisible))
            {
                InfoTipVisible = false;
                AutoListVisible = false;
                e.Handled = true;
                Redraw();
                return;
            }

            if (!e.Handled && InfoTipVisible && InfoTip.Count > 1)
            {
                //move infotip selection
                if (e.KeyCode == Keys.Up)
                {
                    _SyntaxBox.InfoTipSelectedIndex++;
                    e.Handled = true;
                    return;
                }

                if (e.KeyCode == Keys.Down)
                {
                    _SyntaxBox.InfoTipSelectedIndex--;

                    e.Handled = true;
                    return;
                }
            }

            if (!e.Handled && AutoListVisible)
            {
                //move autolist selection
                if ((e.KeyCode == Keys.Up || e.KeyCode == Keys.Down || e.KeyCode ==
                                                                       Keys.PageUp || e.KeyCode == Keys.PageDown))
                {
                    AutoList.SendKey((int) e.KeyCode);
                    e.Handled = true;
                    return;
                }



                //inject inser text from autolist
                if (mKeysThatInsertFromAutolist.Contains(e.KeyCode) || 
                    /////////////HACK ALERT:  Won't work on international keyboards!!!!
                    (e.KeyCode == Keys.D9 && e.Modifiers == Keys.Shift))
                {
                    string s = AutoList.SelectedText;
                    if (s != "")
                        InsertAutolistText();
                    AutoListVisible = false;
                    e.Handled = true;
                    Redraw();
                    return;
                }
            }


            if (!e.Handled)
            {
                //do keyboard actions
                foreach (KeyboardAction ka in _SyntaxBox.KeyboardActions)
                {
                    if (!ReadOnly || ka.AllowReadOnly)
                    {
                        if ((ka.Key == (Keys) (int) e.KeyCode) && ka.Alt == e.Alt && ka.Shift
                                                                                     == e.Shift &&
                            ka.Control == e.Control)
                            ka.Action();
                        //if keys match , call action delegate
                    }
                }


                //------------------------------------------------------------------------------------------------------------


                switch ((Keys) (int) e.KeyCode)
                {
                    case Keys.ShiftKey:
                    case Keys.ControlKey:
                    case Keys.Alt:
                        return;

                    case Keys.Down:
                        if (e.Control)
                            ScrollScreen(1);
                        else
                        {
                            Caret.MoveDown(e.Shift);
                            Redraw();
                        }
                        break;
                    case Keys.Up:
                        if (e.Control)
                            ScrollScreen(- 1);
                        else
                        {
                            Caret.MoveUp(e.Shift);
                        }
                        Redraw();
                        break;
                    case Keys.Left:
                        {
                            if (e.Control)
                            {
                                MoveCaretToPrevWord(e.Shift);
                            }
                            else
                            {
                                Caret.MoveLeft(e.Shift);
                            }
                        }
                        Redraw();
                        break;
                    case Keys.Right:
                        {
                            if (e.Control)
                            {
                                MoveCaretToNextWord(e.Shift);
                            }
                            else
                            {
                                Caret.MoveRight(e.Shift);
                            }
                        }
                        Redraw();
                        break;
                    case Keys.End:
                        if (e.Control)
                            Caret.MoveAbsoluteEnd(e.Shift);
                        else
                            Caret.MoveEnd(e.Shift);
                        Redraw();
                        break;
                    case Keys.Home:
                        if (e.Control)
                            Caret.MoveAbsoluteHome(e.Shift);
                        else
                            Caret.MoveHome(e.Shift);
                        Redraw();
                        break;
                    case Keys.PageDown:
                        Caret.MoveDown(View.VisibleRowCount - 2, e.Shift);
                        Redraw();
                        break;
                    case Keys.PageUp:
                        Caret.MoveUp(View.VisibleRowCount - 2, e.Shift);
                        Redraw();
                        break;

                    default:
                        break;
                }


                //dont do if readonly
                if (!ReadOnly)
                {
                    switch ((Keys) (int) e.KeyCode)
                    {
                        case Keys.Enter:
                            {
                                if (e.Control)
                                {
                                    if (Caret.CurrentRow.CanFold)
                                    {
                                        Caret.MoveHome(false);
                                        Document.ToggleRow(Caret.CurrentRow);
                                        Redraw();
                                    }
                                }
                                else
                                    InsertEnter();
                                break;
                            }
                        case Keys.Back:
                            if (!e.Control)
                                DeleteBackwards();
                            else
                            {
                                if (Selection.IsValid)
                                    Selection.DeleteSelection();
                                else
                                {
                                    Selection.ClearSelection();
                                    MoveCaretToPrevWord(true);
                                    Selection.DeleteSelection();
                                }
                                Caret.CurrentRow.Parse(true);
                            }

                            break;
                        case Keys.Delete:
                            {
                                if (!e.Control && !e.Alt && !e.Shift)
                                {
                                    Delete();
                                }
                                else if (e.Control && !e.Alt && !e.Shift)
                                {
                                    if (Selection.IsValid)
                                    {
                                        Cut();
                                    }
                                    else
                                    {
                                        Selection.ClearSelection();
                                        MoveCaretToNextWord(true);
                                        Selection.DeleteSelection();
                                    }
                                    Caret.CurrentRow.Parse(true);
                                }
                                break;
                            }
                        case Keys.Insert:
                            {
                                if (!e.Control && !e.Alt && !e.Shift)
                                {
                                    _OverWrite = !_OverWrite;
                                }
                                break;
                            }
                        case Keys.Tab:
                            {
                                if (!Selection.IsValid)
                                {
                                    // ROB: Implementation of .TabsToSpaces
                                    if (!TabsToSpaces)
                                    {
                                        InsertText("\t");
                                    }
                                    else
                                    {
                                        InsertText(new string(' ', TabSize));
                                    }
                                    // ROB-END
                                }

                                break;
                            }
                        default:
                            {
                                break;
                            }
                    }
                }
                Caret.Blink = true;
                //this.Redraw ();
            }
        }