← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/DisplayBindings/FormsDesigner/Project/Src/FormKeyHandler.cs

  • Committer: sk
  • Date: 2011-09-10 05:17:57 UTC
  • Revision ID: halega@halega.com-20110910051757-qfouz1llya9m6boy
4.1.0.7915 Release Candidate 1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/AddIns/DisplayBindings/FormsDesigner/Project/Src/FormKeyHandler.cs
 
1
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 
2
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
3
 
 
4
using System;
 
5
using System.Collections;
 
6
using System.Collections.Generic;
 
7
using System.ComponentModel;
 
8
using System.ComponentModel.Design;
 
9
using System.Reflection;
 
10
using System.Windows.Forms;
 
11
using System.Windows.Forms.Design;
 
12
 
 
13
using ICSharpCode.Core;
 
14
using ICSharpCode.SharpDevelop.Gui;
 
15
 
 
16
namespace ICSharpCode.FormsDesigner
 
17
{
 
18
        public sealed class FormKeyHandler : IMessageFilter
 
19
        {
 
20
                const int keyPressedMessage          = 0x100;
 
21
                const int leftMouseButtonDownMessage = 0x0202;
 
22
                
 
23
                readonly Dictionary<Keys, CommandWrapper> keyTable = new Dictionary<Keys, CommandWrapper>();
 
24
                public static bool inserted = false;
 
25
                public static void Insert()
 
26
                {
 
27
                        inserted = true;
 
28
                        Application.AddMessageFilter(new FormKeyHandler());
 
29
                }
 
30
                
 
31
                public FormKeyHandler()
 
32
                {
 
33
                        // normal keys
 
34
                        keyTable[Keys.Left]  = new CommandWrapper(MenuCommands.KeyMoveLeft);
 
35
                        keyTable[Keys.Right] = new CommandWrapper(MenuCommands.KeyMoveRight);
 
36
                        keyTable[Keys.Up]    = new CommandWrapper(MenuCommands.KeyMoveUp);
 
37
                        keyTable[Keys.Down]  = new CommandWrapper(MenuCommands.KeyMoveDown);
 
38
                        keyTable[Keys.Tab]   = new CommandWrapper(MenuCommands.KeySelectNext);
 
39
                        keyTable[Keys.Delete]   = new CommandWrapper(MenuCommands.Delete);
 
40
                        keyTable[Keys.Back]   = new CommandWrapper(MenuCommands.Delete);
 
41
                        
 
42
                        // shift modified keys
 
43
                        keyTable[Keys.Left | Keys.Shift]  = new CommandWrapper(MenuCommands.KeySizeWidthDecrease);
 
44
                        keyTable[Keys.Right | Keys.Shift] = new CommandWrapper(MenuCommands.KeySizeWidthIncrease);
 
45
                        keyTable[Keys.Up | Keys.Shift]    = new CommandWrapper(MenuCommands.KeySizeHeightDecrease);
 
46
                        keyTable[Keys.Down | Keys.Shift]  = new CommandWrapper(MenuCommands.KeySizeHeightIncrease);
 
47
                        keyTable[Keys.Tab | Keys.Shift]   = new CommandWrapper(MenuCommands.KeySelectPrevious);
 
48
                        keyTable[Keys.Delete| Keys.Shift]   = new CommandWrapper(MenuCommands.Delete);
 
49
                        keyTable[Keys.Back| Keys.Shift]   = new CommandWrapper(MenuCommands.Delete);
 
50
                        
 
51
                        // ctrl modified keys
 
52
                        keyTable[Keys.Left | Keys.Control]  = new CommandWrapper(MenuCommands.KeyNudgeLeft);
 
53
                        keyTable[Keys.Right | Keys.Control] = new CommandWrapper(MenuCommands.KeyNudgeRight);
 
54
                        keyTable[Keys.Up | Keys.Control]    = new CommandWrapper(MenuCommands.KeyNudgeUp);
 
55
                        keyTable[Keys.Down | Keys.Control]  = new CommandWrapper(MenuCommands.KeyNudgeDown);
 
56
                        
 
57
                        // ctrl + shift modified keys
 
58
                        keyTable[Keys.Left | Keys.Control | Keys.Shift]  = new CommandWrapper(MenuCommands.KeyNudgeWidthDecrease);
 
59
                        keyTable[Keys.Right | Keys.Control | Keys.Shift] = new CommandWrapper(MenuCommands.KeyNudgeWidthIncrease);
 
60
                        keyTable[Keys.Up | Keys.Control | Keys.Shift]    = new CommandWrapper(MenuCommands.KeyNudgeHeightDecrease);
 
61
                        keyTable[Keys.Down | Keys.Control | Keys.Shift]  = new CommandWrapper(MenuCommands.KeyNudgeHeightIncrease);
 
62
                }
 
63
                
 
64
                public bool PreFilterMessage(ref Message m)
 
65
                {
 
66
                        if (m.Msg != keyPressedMessage /*&& m.Msg != leftMouseButtonDownMessage*/) {
 
67
                                return false;
 
68
                        }
 
69
                        
 
70
                        FormsDesignerViewContent formDesigner = WorkbenchSingleton.Workbench.ActiveContent as FormsDesignerViewContent;
 
71
                        
 
72
                        if (formDesigner == null || formDesigner.Host == null) {
 
73
                                return false;
 
74
                        }
 
75
                        if (formDesigner.UserContent != null && !((Control)formDesigner.UserContent).ContainsFocus) {
 
76
                                return false;
 
77
                        }
 
78
                        
 
79
                        Control originControl = Control.FromChildHandle(m.HWnd);
 
80
                        if (originControl != null && formDesigner.UserContent != null && !(formDesigner.UserContent == originControl || formDesigner.UserContent.Contains(originControl))) {
 
81
                                // Ignore if message origin not in forms designer
 
82
                                // (e.g. navigating the main menu)
 
83
                                return false;
 
84
                        }
 
85
                        
 
86
                        Keys keyPressed = (Keys)m.WParam.ToInt32() | Control.ModifierKeys;
 
87
                        
 
88
                        if (keyPressed == Keys.Escape) {
 
89
                                if (formDesigner.IsTabOrderMode) {
 
90
                                        formDesigner.HideTabOrder();
 
91
                                        return true;
 
92
                                }
 
93
                        }
 
94
                        
 
95
                        CommandWrapper commandWrapper;
 
96
                        if (keyTable.TryGetValue(keyPressed, out commandWrapper)) {
 
97
                                if (commandWrapper.CommandID == MenuCommands.Delete) {
 
98
                                        // Check Delete menu is enabled.
 
99
                                        if (!formDesigner.EnableDelete) {
 
100
                                                return false;
 
101
                                        }
 
102
                                }
 
103
                                LoggingService.Debug("Run menu command: " + commandWrapper.CommandID);
 
104
                                
 
105
                                IMenuCommandService menuCommandService = (IMenuCommandService)formDesigner.Host.GetService(typeof(IMenuCommandService));
 
106
                                ISelectionService   selectionService = (ISelectionService)formDesigner.Host.GetService(typeof(ISelectionService));
 
107
                                ICollection components = selectionService.GetSelectedComponents();
 
108
                                if (components.Count == 1) {
 
109
                                        foreach (IComponent component in components) {
 
110
                                                if (HandleMenuCommand(formDesigner, component, keyPressed))
 
111
                                                        return false;
 
112
                                        }
 
113
                                }
 
114
                                
 
115
                                menuCommandService.GlobalInvoke(commandWrapper.CommandID);
 
116
                                
 
117
                                if (commandWrapper.RestoreSelection) {
 
118
                                        selectionService.SetSelectedComponents(components);
 
119
                                }
 
120
                                return true;
 
121
                        }
 
122
                        
 
123
                        return false;
 
124
                }
 
125
                
 
126
                bool HandleMenuCommand(FormsDesignerViewContent formDesigner, IComponent activeComponent, Keys keyPressed)
 
127
                {
 
128
                        Assembly asm = typeof(WindowsFormsDesignerOptionService).Assembly;
 
129
                        // Microsoft made ToolStripKeyboardHandlingService internal, so we need Reflection
 
130
                        Type keyboardType = asm.GetType("System.Windows.Forms.Design.ToolStripKeyboardHandlingService");
 
131
                        object keyboardService = formDesigner.Host.GetService(keyboardType);
 
132
                        if (keyboardService == null) {
 
133
                                LoggingService.Debug("no ToolStripKeyboardHandlingService found");
 
134
                                return false; // handle command normally
 
135
                        }
 
136
                        if (activeComponent is ToolStripItem) {
 
137
                                if (keyPressed == Keys.Up) {
 
138
                                        keyboardType.InvokeMember("ProcessUpDown",
 
139
                                                                  BindingFlags.Instance
 
140
                                                                  | BindingFlags.Public
 
141
                                                                  | BindingFlags.InvokeMethod,
 
142
                                                                  null, keyboardService, new object[] { false });
 
143
                                        return true; // command was handled specially
 
144
                                } else if (keyPressed == Keys.Down) {
 
145
                                        keyboardType.InvokeMember("ProcessUpDown",
 
146
                                                                  BindingFlags.Instance
 
147
                                                                  | BindingFlags.Public
 
148
                                                                  | BindingFlags.InvokeMethod,
 
149
                                                                  null, keyboardService, new object[] { true });
 
150
                                        return true; // command was handled specially
 
151
                                }
 
152
                        }
 
153
                        bool active = (bool)keyboardType.InvokeMember("TemplateNodeActive",
 
154
                                                                      BindingFlags.Instance
 
155
                                                                      | BindingFlags.NonPublic
 
156
                                                                      | BindingFlags.GetProperty,
 
157
                                                                      null, keyboardService, null);
 
158
                        if (active) {
 
159
                                return true; // command will handled specially by the text box, don't invoke the CommandID
 
160
                        }
 
161
                        return false; // invoke the CommandID
 
162
                }
 
163
                
 
164
                sealed class CommandWrapper
 
165
                {
 
166
                        CommandID commandID;
 
167
                        bool      restoreSelection;
 
168
                        
 
169
                        public CommandID CommandID {
 
170
                                get {
 
171
                                        return commandID;
 
172
                                }
 
173
                        }
 
174
                        
 
175
                        public bool RestoreSelection {
 
176
                                get {
 
177
                                        return restoreSelection;
 
178
                                }
 
179
                        }
 
180
                        
 
181
                        public CommandWrapper(CommandID commandID) : this(commandID, false)
 
182
                        {
 
183
                        }
 
184
                        public CommandWrapper(CommandID commandID, bool restoreSelection)
 
185
                        {
 
186
                                this.commandID        = commandID;
 
187
                                this.restoreSelection = restoreSelection;
 
188
                        }
 
189
                }
 
190
        }
 
191
}