public static int GetModifierKeysSum(ModifierKeys modifierKeys)
{
int sum = 0x0000;
if (modifierKeys.HasFlag(ModifierKeys.Alt))
{
sum += 0x0001;
}
if (modifierKeys.HasFlag(ModifierKeys.Control))
{
sum += 0x0002;
}
if (modifierKeys.HasFlag(ModifierKeys.Shift))
{
sum += 0x0004;
}
if (modifierKeys.HasFlag(ModifierKeys.Windows))
{
sum += 0x0008;
}
return(sum);
}
private void UpdateKeyboard(ModifierKeys theEvent)
{
int keys = (int)Agg.UI.Keys.None;
var shiftKey = theEvent.HasFlag(GLFW.ModifierKeys.Shift);
Keyboard.SetKeyDownState(Agg.UI.Keys.Shift, shiftKey);
if (shiftKey)
{
keys |= (int)Agg.UI.Keys.Shift;
}
var controlKey = theEvent.HasFlag(GLFW.ModifierKeys.Control) ||
theEvent.HasFlag(GLFW.ModifierKeys.Super);
Keyboard.SetKeyDownState(Agg.UI.Keys.Control, controlKey);
if (controlKey)
{
keys |= (int)Agg.UI.Keys.Control;
}
var altKey = theEvent.HasFlag(GLFW.ModifierKeys.Alt);
Keyboard.SetKeyDownState(Agg.UI.Keys.Alt, altKey);
if (altKey)
{
keys |= (int)Agg.UI.Keys.Alt;
}
ModifierKeys = (Agg.UI.Keys)keys;
}
private static HotkeyFlags GetFlags(ModifierKeys modifiers, bool noRepeat)
{
var flags = HotkeyFlags.None;
if (modifiers.HasFlag(ModifierKeys.Shift))
{
flags |= HotkeyFlags.Shift;
}
if (modifiers.HasFlag(ModifierKeys.Control))
{
flags |= HotkeyFlags.Control;
}
if (modifiers.HasFlag(ModifierKeys.Alt))
{
flags |= HotkeyFlags.Alt;
}
if (modifiers.HasFlag(ModifierKeys.Windows))
{
flags |= HotkeyFlags.Windows;
}
if (noRepeat)
{
flags |= HotkeyFlags.NoRepeat;
}
return(flags);
}
/**<summary>Tries to parse the keybind.</summary>*/
public static bool TryParse(string s, out Keybind keybind)
{
Key key = Key.None;
ModifierKeys modifiers = ModifierKeys.None;
for (int i = 0; i < 3; i++)
{
if (!modifiers.HasFlag(ModifierKeys.Control) && s.StartsWith("Ctrl+", StringComparison.InvariantCultureIgnoreCase))
{
modifiers |= ModifierKeys.Control;
s = s.Substring(5);
}
if (!modifiers.HasFlag(ModifierKeys.Shift) && s.StartsWith("Shift+", StringComparison.InvariantCultureIgnoreCase))
{
modifiers |= ModifierKeys.Shift;
s = s.Substring(6);
}
if (!modifiers.HasFlag(ModifierKeys.Alt) && s.StartsWith("Alt+", StringComparison.InvariantCultureIgnoreCase))
{
modifiers |= ModifierKeys.Alt;
s = s.Substring(4);
}
}
if (Enum.TryParse <Key>(s, out key))
{
keybind = new Keybind(key, modifiers);
return(true);
}
keybind = Keybind.None;
return(false);
}
public static string GetShortcut(Key key, ModifierKeys modifiers, bool global = false)
{
string shortcut = key.ToString();
if (modifiers.HasFlag(ModifierKeys.Control))
{
shortcut += " + Ctrl";
}
if (modifiers.HasFlag(ModifierKeys.Shift))
{
shortcut += " + Shift";
}
if (modifiers.HasFlag(ModifierKeys.Alt))
{
shortcut += " + Alt";
}
if (global)
{
shortcut += GlobalShortcutSuffix;
}
return(shortcut);
}
public static NSEventModifierMask ToNSEventModifierMask(this ModifierKeys keys)
{
var mask = (NSEventModifierMask)0;
if (keys.HasFlag(ModifierKeys.Alt))
{
mask |= NSEventModifierMask.AlternateKeyMask;
}
if (keys.HasFlag(ModifierKeys.Command))
{
mask |= NSEventModifierMask.CommandKeyMask;
}
if (keys.HasFlag(ModifierKeys.Control))
{
mask |= NSEventModifierMask.ControlKeyMask;
}
if (keys.HasFlag(ModifierKeys.Shift))
{
mask |= NSEventModifierMask.ShiftKeyMask;
}
if (keys.HasFlag(ModifierKeys.Meta))
{
mask |= NSEventModifierMask.CommandKeyMask;
}
return(mask);
}
public static List <VirtualKeyCode> ModifiersToKeys(ModifierKeys keys)
{
var list = new List <VirtualKeyCode>(3);
if (keys.HasFlag(ModifierKeys.Control))
{
list.Add(VirtualKeyCode.CONTROL);
}
if (keys.HasFlag(ModifierKeys.Alt))
{
list.Add(VirtualKeyCode.MENU);
}
if (keys.HasFlag(ModifierKeys.Shift))
{
list.Add(VirtualKeyCode.SHIFT);
}
if (keys.HasFlag(ModifierKeys.WinKey))
{
list.Add(VirtualKeyCode.LWIN);
}
return(list);
}
public static System.Windows.Forms.Keys ToWinforms(this ModifierKeys modifier)
{
var retVal = System.Windows.Forms.Keys.None;
if (modifier.HasFlag(System.Windows.Input.ModifierKeys.Alt))
{
retVal |= System.Windows.Forms.Keys.Alt;
}
if (modifier.HasFlag(System.Windows.Input.ModifierKeys.Control))
{
retVal |= System.Windows.Forms.Keys.Control;
}
if (modifier.HasFlag(System.Windows.Input.ModifierKeys.None))
{
retVal |= System.Windows.Forms.Keys.None;
}
if (modifier.HasFlag(System.Windows.Input.ModifierKeys.Shift))
{
retVal |= System.Windows.Forms.Keys.Shift;
}
if (modifier.HasFlag(System.Windows.Input.ModifierKeys.Windows))
{
}
return(retVal);
}
private void UpdateKeyboardStatus()
{
ModifierKeys modifiers = InputManager.Current.PrimaryKeyboardDevice.Modifiers;
ctrlIsDown = (modifiers.HasFlag(ModifierKeys.Control));
shiftIsDown = (modifiers.HasFlag(ModifierKeys.Shift));
}
public static string StringifyShortcutKeys(Key key, ModifierKeys modifier)
{
var content = String.Empty;
if (modifier.HasFlag(ModifierKeys.Control))
{
content += "Ctrl-";
}
if (modifier.HasFlag(ModifierKeys.Shift))
{
content += "Shift-";
}
if (modifier.HasFlag(ModifierKeys.Alt))
{
content += "Alt-";
}
switch (key)
{
case Key.D0:
case Key.D1:
case Key.D2:
case Key.D3:
case Key.D4:
case Key.D5:
case Key.D6:
case Key.D7:
case Key.D8:
case Key.D9:
content += key.ToString().Substring(1);
break;
case Key.NumPad0:
case Key.NumPad1:
case Key.NumPad2:
case Key.NumPad3:
case Key.NumPad4:
case Key.NumPad5:
case Key.NumPad6:
case Key.NumPad7:
case Key.NumPad8:
case Key.NumPad9:
content += key.ToString().Substring(6);
break;
case Key.LeftAlt:
case Key.RightAlt:
case Key.LeftCtrl:
case Key.RightCtrl:
case Key.LeftShift:
case Key.RightShift:
// ignore control keys
break;
default:
content += key.ToString();
break;
}
return content;
}
public Hotkey(ModifierKeys p_ModifierKeys, Keys p_Key)
{
// Assign properties
Control = p_ModifierKeys.HasFlag(ModifierKeys.Control);
Shift = p_ModifierKeys.HasFlag(ModifierKeys.Shift);
Alt = p_ModifierKeys.HasFlag(ModifierKeys.Alt);
Key = p_Key;
Initialize();
}
/// <summary>
/// 生成 <see cref="HookEventArgs"/> class 的新实例。
/// </summary>
/// <param name="keyCode">Win32下的键码</param>
public HookEventArgs(UInt32 keyCode)
{
this.Key = KeyInterop.KeyFromVirtualKey((int)keyCode);
ModifierKeys modifier = Keyboard.Modifiers;
this.Alt = modifier.HasFlag(ModifierKeys.Alt);
this.Control = modifier.HasFlag(ModifierKeys.Control);
this.Shift = modifier.HasFlag(ModifierKeys.Shift);
this.Windows = modifier.HasFlag(ModifierKeys.Windows);
}
/// <inheritdoc />
public bool ArePressed(ModifierKeys modifiers)
{
bool alt = modifiers.HasFlag(ModifierKeys.Alt);
bool ctrl = modifiers.HasFlag(ModifierKeys.Control);
bool shift = modifiers.HasFlag(ModifierKeys.Shift);
bool win = modifiers.HasFlag(ModifierKeys.Windows);
return((!alt || this.IsPressed(Key.LeftAlt) || this.IsPressed(Key.RightAlt)) &&
(!ctrl || this.IsPressed(Key.LeftCtrl) || this.IsPressed(Key.RightCtrl)) &&
(!shift || this.IsPressed(Key.LeftShift) || this.IsPressed(Key.RightShift)) &&
(!win || this.IsPressed(Key.LWin) || this.IsPressed(Key.RWin)));
}
public void Alter(ModifierKeys p_ModifierKeys, Keys p_Key)
{
Control c_TempControl = m_WindowControl;
Unregister();
Control = p_ModifierKeys.HasFlag(ModifierKeys.Control);
Shift = p_ModifierKeys.HasFlag(ModifierKeys.Shift);
Alt = p_ModifierKeys.HasFlag(ModifierKeys.Alt);
Key = p_Key;
Register(c_TempControl);
}
public static int GetIncrement(bool forward, ModifierKeys modifiers)
{
int increment = forward ? 1 : -1;
if (modifiers.HasFlag(ModifierKeys.Shift))
{
increment *= 5;
}
if (modifiers.HasFlag(ModifierKeys.Control))
{
increment *= 10;
}
return increment;
}
public SettingViewModel()
{
Key key = (Key)Properties.Settings.Default.EnumKey;
ModifierKeys modifier = (ModifierKeys)Properties.Settings.Default.EnumModifierKeys;
ShortcutKey.Value = key.ToString();
ModifierShift.Value = modifier.HasFlag(ModifierKeys.Shift);
ModifierAlt.Value = modifier.HasFlag(ModifierKeys.Alt);
ModifierCtrl.Value = modifier.HasFlag(ModifierKeys.Control);
ModifierWindows.Value = modifier.HasFlag(ModifierKeys.Windows);
GHKeyString.Value = HotKeyManager.GetGHKeyString();
}
Key GetKeyIgnoringModifiers(ModifierKeys modifierKeys, Key key)
{
if (modifierKeys.HasFlag(ModifierKeys.Alt))
{
if (key == Key.LeftAlt)
{
return(Key.None);
}
if (key == Key.RightAlt)
{
return(Key.None);
}
}
if (modifierKeys.HasFlag(ModifierKeys.Control))
{
if (key == Key.LeftCtrl)
{
return(Key.None);
}
if (key == Key.RightCtrl)
{
return(Key.None);
}
}
if (modifierKeys.HasFlag(ModifierKeys.Shift))
{
if (key == Key.LeftShift)
{
return(Key.None);
}
if (key == Key.RightShift)
{
return(Key.None);
}
}
if (modifierKeys.HasFlag(ModifierKeys.Windows))
{
if (key == Key.LWin)
{
return(Key.None);
}
if (key == Key.RWin)
{
return(Key.None);
}
}
return(key);
}
private void TwitchChat_MouseDoubleClick(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left && ModifierKeys.HasFlag(Keys.Control))
{
this.TwitchChat.Text = "";
}
}
private void FrmSingleDt_KeyDown(object sender, KeyEventArgs e)
{
switch (e.KeyCode)
{
//case Keys.PageUp:
// if (e.Modifiers == Keys.Control)
// dataNavigatorMain.Buttons.First.DoClick();
// else
// dataNavigatorMain.Buttons.Prev.DoClick();
// break;
//case Keys.PageDown:
// if (e.Modifiers == Keys.Control)
// dataNavigatorMain.Buttons.Last.DoClick();
// else
// dataNavigatorMain.Buttons.Next.DoClick();
// break;
case Keys.Escape:
CancelUpdate();
break;
case Keys.F12:
UpdateData();
break;
case Keys.S:
if (ModifierKeys.HasFlag(Keys.Control))
{
UpdateData();
}
break;
}
}
void ButtonImportGamesClick(object sender, EventArgs e)
{
bool fromLeague = (ModifierKeys.HasFlag(Keys.Control) && ModifierKeys.HasFlag(Keys.Shift)) ||
(ModifierKeys.HasFlag(Keys.Control) && ModifierKeys.HasFlag(Keys.Alt)) ||
(ModifierKeys.HasFlag(Keys.Shift) && ModifierKeys.HasFlag(Keys.Alt));
if (fromLeague)
{
Fixture.Games.Parse(League, Fixture.Teams);
}
else
{
if (radioButtonTab.Checked)
{
Fixture.Games.Parse(textBoxGames.Text, Fixture.Teams, '\t');
}
else if (textBoxSeparator.Text.Length > 0)
{
Fixture.Games.Parse(textBoxGames.Text, Fixture.Teams, textBoxSeparator.Text[0]);
}
}
textBoxGames.Text = Fixture.Games.ToString();
textBoxGrid.Lines = Fixture.Games.ToGrid(Fixture.Teams);
}
private void notifyIcon1_MouseDown(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Right)
{
return;
}
var rType = Program.settings.DefaultDataFlow;
if (ModifierKeys.HasFlag(Keys.Control))
{
rType = rType == EDataFlow.eRender ? EDataFlow.eCapture : EDataFlow.eRender;
}
if (ModifierKeys.HasFlag(Keys.Alt))
{
ChangeDeviceState(rType, true, 0, true);
}
else
{
RenderType = rType;
RefreshDevices(RenderType);
if (DeactivatedOnIcon)
{
return;
}
SetSizes();
}
}
public void Swap(ModifierKeys modifier)
{
switch (PaintMode)
{
// case PaintMode.Tile:
// SwapTile();
// break;
// case PaintMode.Wall:
// SwapWall();
// break;
case PaintMode.TileAndWall:
if (modifier.HasFlag(ModifierKeys.Shift))
{
SwapWall();
}
else
{
SwapTile();
}
break;
case PaintMode.Liquid:
SwapLiquid();
break;
}
}
private void Chart1_MouseWheel(object sender, MouseEventArgs e)
{
if (ModifierKeys.HasFlag(Keys.Control))
{
int m = e.Delta < 0 ? 1 : -1;
tbScale.ChartAreas[0].AxisX.ScaleView.Size -= 10 * m;
}
else
{
var a = tbScale.ChartAreas[0].AxisX.ScaleView;
double m = e.Delta < 0 ? 1 : -1;
double target = 0.002d * m;
double step = target / 10;
if (chkAnimChart.Checked)
{
Task.Run(() =>
{
double progress = 0;
while (progress < Math.Abs(target))
{
tbScale.Invoke((MethodInvoker) delegate { a.Position += step; });
progress += Math.Abs(step);
Thread.Sleep(10);
}
});
}
else
{
a.Position += target;
}
}
}
private void DrawingArea_MouseWheel(object sender, MouseEventArgs e)
{
//Pow() is used so that a certain number of detents will always give the same scaling
float scale = (float)Math.Pow(1 + SCALING_FACTOR, e.Delta);
float scaleX = scale;
//holding shift scales Y only
if (ModifierKeys.HasFlag(Keys.Shift))
{
scaleX = 1;
}
float scaleY = scale;
//holding Ctrl scales X only
if (ModifierKeys.HasFlag(Keys.Control))
{
scaleY = 1;
}
ScaleAroundPoint(scaleX, scaleY, e.Location);
drawingArea.Invalidate();
}
private void dgvt_CellClick(object sender, DataGridViewCellEventArgs e)
{
if (dgvt.CurrentRow.Index >= 0 && dgvt.CurrentRow.Index < dgvt.Rows.Count)
{
string id = dgvt.CurrentRow.Cells["id"].Value.ToString();
if (ModifierKeys.HasFlag(Keys.Control))
{
bool refresh = false;
string sectionid = dgvk.CurrentRow.Cells["ID"].Value.ToString();
foreach (DataRow dr in itemsdt.Select(" id = " + id))
{
if (listdt.Select(" id = " + id).Count() == 0)
{
listdt.ImportRow(dr);
string sql = "insert into sectionquestion(questionid,sectionid) values(" + id + "," + sectionid + ")";
dc.Update(sql);
//RefreshdgvList(sectionid);
refresh = true;
}
}
if (refresh)
{
//RefreshdgvList(sectionid);
;
}
}
else
{
RefreshItemListDtsave(id);
}
}
}
private void treeView_BeforeSelect(object sender, TreeViewCancelEventArgs e)
{
if (e.Node is TreeNodeLocalItem)
{
TreeNodeLocalItem treeNodeServerFolder = (TreeNodeLocalItem)e.Node;
treeView.BeginUpdate();
if (ModifierKeys.HasFlag(Keys.Shift))
{
SetExistingNodeSelection(treeNodeServerFolder, ModifierKeys.HasFlag(Keys.Control));
TreeNodeLocalItem prevItem = treeNodeServerFolder.PrevVisibleNode as TreeNodeLocalItem;
while (prevItem != null && !prevItem.IsMultiSelect)
{
SetExistingNodeSelection(prevItem, ModifierKeys.HasFlag(Keys.Control));
prevItem = prevItem.PrevVisibleNode as TreeNodeLocalItem;
}
}
else
{
if (!ModifierKeys.HasFlag(Keys.Control))
{
ClearExistingNodeSelection(new string[] { treeNodeServerFolder.LocalItem });
}
SetExistingNodeSelection(treeNodeServerFolder, ModifierKeys.HasFlag(Keys.Control));
}
treeView.EndUpdate();
e.Cancel = true;
this.m_lastSelectedPath = treeNodeServerFolder.LocalItem;
if (LastSelectedServerItemChanged != null)
{
LastSelectedServerItemChanged(this, new EventArgs());
}
}
}
private void PbPlot_MouseDown(object sender, MouseEventArgs e)
{
draggingAxLine = settings.GetDraggableAxisLineUnderCursor(e.Location);
if (draggingAxLine != null)
{
OnMouseDownOnPlottable(EventArgs.Empty);
}
else
{
// mouse is being used for click and zoom
if (e.Button == MouseButtons.Left && ModifierKeys.HasFlag(Keys.Shift))
{
mouseMiddleDownLocation = e.Location;
}
else if (e.Button == MouseButtons.Left && enablePanning)
{
mouseLeftDownLocation = e.Location;
}
else if (e.Button == MouseButtons.Right && enableZooming)
{
mouseRightDownLocation = e.Location;
}
else if (e.Button == MouseButtons.Middle)
{
mouseMiddleDownLocation = e.Location;
}
axisLimitsOnMouseDown = plt.Axis();
}
}
private bool zedGraphControl_PostMouseMoveEvent(ZedGraphControl sender, MouseEventArgs e)
{
if (sender.DragEditingPair == null)
{
return(true);
}
if (sender.DragEditingPair.X < 0)
{
sender.DragEditingPair.X = 0;
}
if (sender.DragEditingPair.X > 100)
{
sender.DragEditingPair.X = 100;
}
if (sender.DragEditingPair.Y < 0)
{
sender.DragEditingPair.Y = 0;
}
if (sender.DragEditingPair.Y > 100)
{
sender.DragEditingPair.Y = 100;
}
if (!Curve.IsLibraryReference && e.Button == MouseButtons.Left && !ModifierKeys.HasFlag(Keys.Shift))
{
txtXValue.Text = sender.DragEditingPair.X.ToString("0.####");
txtYValue.Text = sender.DragEditingPair.Y.ToString("0.####");
txtXValue.Enabled = txtYValue.Enabled = btnUpdateCoordinates.Enabled = true;
}
// actually does nothing, just haven't changed the event handler definition
return(true);
}
private void RulerForm_MouseWheel(object sender, MouseEventArgs e)
{
// Resize according to mouse scroll direction.
var amount = Math.Sign(e.Delta);
if (ModifierKeys.HasFlag(Keys.Shift))
{
amount *= Settings.LargeStep;
}
else
{
amount *= Settings.SmallStep;
}
// Add to width or height according to current mode and mouse location
if (ResizeMode == FormResizeMode.Horizontal)
{
Width += amount;
}
else if (ResizeMode == FormResizeMode.Vertical)
{
Height += amount;
}
else
{
if (e.Y > this.RestrictSize)
{
Height += amount;
}
else
{
Width += amount;
}
}
}
private void notifyIcon1_MouseDown(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Right)
{
if (Program.settings.QuickSwitchEnabled && !DeactivatedOnIcon)
{
notifyIcon.ContextMenuStrip = null;
QuickSwitchDevice(false, Program.settings.DefaultDataFlow, Program.settings.QuickSwitchShowOSD);
}
else
{
notifyIcon.ContextMenuStrip = trayMenu;
}
return;
}
var rType = Program.settings.DefaultDataFlow;
if (ModifierKeys.HasFlag(Keys.Control))
{
rType = rType == EDataFlow.eRender ? EDataFlow.eCapture : EDataFlow.eRender;
}
RenderType = rType;
RefreshDevices(RenderType);
if (DeactivatedOnIcon)
{
return;
}
SetSizes();
}
private void notifyIcon1_MouseUp(object sender, MouseEventArgs e)
{
if (DeactivatedOnIcon)
{
DeactivatedOnIcon = false;
return;
}
if (ModifierKeys.HasFlag(Keys.Alt))
{
return;
}
if (listDevices.Items.Count > 0)
{
VolBar.RegisterDevice(RenderType);
}
if (e.Button == MouseButtons.Left)
{
timer1.Enabled = true;
Show();
Activate();
}
}
private bool HandleSelectComponent(GraphCommand command)
{
uint compId = (uint)command.GetArgument(0);
ModifierKeys modifiers = ((ModifierKeys)command.GetArgument(1));
IVisualNode selectedNode = null;
nodeCollection.TryGetValue(compId, out selectedNode);
if (selectedNode != null)
{
VisualNode node = (VisualNode)selectedNode;
if (modifiers.HasFlag(ModifierKeys.Control))//toggle
{
node.Selected = !node.Selected;
}
else
{
node.Selected = true;
}
}
else
{
edgeController.SelectComponent(compId, modifiers);
}
this.selectionBox.UpdateSelectionBox(GetSelectedNodes());
return(true);
}
public Shortcut(Key key, ModifierKeys modifiers, bool toggles, int group)
{
AssignedKey = key.ToString();
isToggle = toggles;
belongsToGroup = group;
if (modifiers != ModifierKeys.None) {
hasMods = true;
modsList = new List<string>();
if (modifiers.HasFlag(ModifierKeys.Control)) {
modsList.Add("Ctrl");
}
if (modifiers.HasFlag(ModifierKeys.Alt)) {
modsList.Add("Alt");
}
if (modifiers.HasFlag(ModifierKeys.Shift)) {
modsList.Add("Shift");
}
} else {
hasMods = false;
}
}
/// <summary>
/// キー表現を判別可能な文字列に変換します。
/// </summary>
public static String KeyToString(ModifierKeys modkeys, Key key)
{
String ret = key.ToString();
if (modkeys.HasFlag(ModifierKeys.Shift))
ret = "Shift+" + ret;
if (modkeys.HasFlag(ModifierKeys.Windows))
ret = "Win+" + ret;
if (modkeys.HasFlag(ModifierKeys.Alt))
ret = "Alt+" + ret;
if (modkeys.HasFlag(ModifierKeys.Control))
ret = "Control+" + ret;
return ret;
}
private static HotkeyFlags GetFlags(ModifierKeys modifiers, bool noRepeat)
{
var flags = HotkeyFlags.None;
if (modifiers.HasFlag(ModifierKeys.Shift))
flags |= HotkeyFlags.Shift;
if (modifiers.HasFlag(ModifierKeys.Control))
flags |= HotkeyFlags.Control;
if (modifiers.HasFlag(ModifierKeys.Alt))
flags |= HotkeyFlags.Alt;
if (modifiers.HasFlag(ModifierKeys.Windows))
flags |= HotkeyFlags.Windows;
if (noRepeat)
flags |= HotkeyFlags.NoRepeat;
return flags;
}
internal bool SelectComponent(uint componentId, ModifierKeys modifiers)
{
selectedEdge = null;
edgeCollection.TryGetValue(componentId, out selectedEdge);
if (selectedEdge != null)
{
if (modifiers.HasFlag(ModifierKeys.Control))
selectedEdge.Selected = !selectedEdge.Selected;
else
selectedEdge.Selected = true;
selectedEdge.Compose();
}
return true;
}
private static List<VirtualKeyCode> getVirtualKeyCodes_byModkey(ModifierKeys modkey)
{
List<VirtualKeyCode> Buffer = new List<VirtualKeyCode>();
if (modkey.HasFlag(ModifierKeys.Alt))
Buffer.Add(VirtualKeyCode.LMENU);
if (modkey.HasFlag(ModifierKeys.Shift))
Buffer.Add(VirtualKeyCode.LSHIFT);
if (modkey.HasFlag(ModifierKeys.Ctrl))
Buffer.Add(VirtualKeyCode.LCONTROL);
return Buffer;
}
private static void ReleaseModKey(ModifierKeys ModKey)
{
if (ModKey == ModifierKeys.None)
return;
//-- log action
A_Handler.Log.LogEntry.addLogEntry("Released ModKey(" + ModKey + ")");
//
if (ModKey.HasFlag(ModifierKeys.Alt))
WindowsInput.InputSimulator.SimulateKeyUp(VirtualKeyCode.MENU);
if (ModKey.HasFlag(ModifierKeys.Shift))
WindowsInput.InputSimulator.SimulateKeyUp(VirtualKeyCode.SHIFT);
if (ModKey.HasFlag(ModifierKeys.Ctrl))
WindowsInput.InputSimulator.SimulateKeyUp(VirtualKeyCode.CONTROL);
}
public void Swap(ModifierKeys modifier)
{
switch (PaintMode)
{
case PaintMode.Tile:
SwapTile();
break;
case PaintMode.Wall:
SwapWall();
break;
case PaintMode.TileAndWall:
if (modifier.HasFlag(ModifierKeys.Shift))
SwapWall();
else
SwapTile();
break;
case PaintMode.Liquid:
SwapLiquid();
break;
}
}
public static string ModifierKeysToString(ModifierKeys modifiers)
{
string ret = "";
if (modifiers.HasFlag(ModifierKeys.Shift)) ret += "SHIFT + ";
if (modifiers.HasFlag(ModifierKeys.Control)) ret += "CONTROL + ";
if (modifiers.HasFlag(ModifierKeys.Alt)) ret += "ALT + ";
if (modifiers.HasFlag(ModifierKeys.Windows)) ret += "WINDOWS + ";
return ret;
}
private void BeginDragSelectionRegion(ModifierKeys modifiers)
{
if (!modifiers.HasFlag(ModifierKeys.Control) && !modifiers.HasFlag(ModifierKeys.Shift))
ClearSelectionInternal();
currentDragState = DragState.RegionSelection;
if (visualHost != null)
this.visualHost.BeginDragSelection();
}
