private void KeyboardTriggerProcess(IntPtr hWnd, EventTriggerModel model)
{
var hWndActive = NativeHelper.GetForegroundWindow();
Task.Delay(100).Wait();
NativeHelper.SetForegroundWindow(hWnd);
var inputs = model.KeyboardCmd.ToUpper().Split(new char[] { '+' }, StringSplitOptions.RemoveEmptyEntries);
var modifiedKey = inputs.Where(r =>
{
if (Enum.TryParse($"{r}", out KeyCode keyCode))
{
return(keyCode.IsExtendedKey());
}
return(false);
}).Select(r =>
{
Enum.TryParse($"{r}", out KeyCode keyCode);
return(keyCode);
}).ToArray();
var command = new List <char>();
foreach (var input in inputs)
{
if (Enum.TryParse(input, out KeyCode keyCode))
{
if (!keyCode.IsExtendedKey())
{
for (int i = 0; i < input.Count(); i++)
{
command.Add(input[i]);
}
}
}
else
{
for (int i = 0; i < input.Count(); i++)
{
command.Add(input[i]);
}
}
}
var keys = command.Where(r =>
{
if (Enum.TryParse($"KEY_{r}", out KeyCode keyCode))
{
return(!keyCode.IsExtendedKey());
}
return(false);
}).Select(r =>
{
Enum.TryParse($"KEY_{r}", out KeyCode keyCode);
return(keyCode);
}).ToArray();
ObjectExtensions.GetInstance <InputManager>().Keyboard.ModifiedKeyStroke(modifiedKey, keys);
Task.Delay(100).Wait();
LogHelper.Debug($">>>>Keyboard Event");
NativeHelper.SetForegroundWindow(hWndActive);
}
private async Task InvokeNextEventTriggerAsync(BaseContentView view, EventTriggerModel model, CancellationToken token)
{
if (token.IsCancellationRequested)
{
return;
}
var processConfigModel = new ProcessConfigModel()
{
ItemDelay = _config.ItemDelay,
SearchImageResultDisplay = _config.SearchImageResultDisplay,
Processes = new List <Process>(),
Token = token,
Similarity = _config.Similarity,
};
Dispatcher.Invoke(() =>
{
if (_fixProcess.HasValue)
{
processConfigModel.Processes.Add(_fixProcess.Value.Value);
}
else
{
processConfigModel.Processes.AddRange(_processes.Where(r => r.Key.Equals(model.ProcessInfo.ProcessName)).Select(r => r.Value));
}
});
var nextItem = await view.InvokeNextEventTriggerAsync(model, processConfigModel);
if (nextItem != null)
{
await _taskQueue.Enqueue(async() => await InvokeNextEventTriggerAsync(view, nextItem, token));
}
}
private bool TryModelValidate(EventTriggerModel model, out Message message)
{
message = Message.Success;
model.KeyboardCmd = model.KeyboardCmd.Replace(" ", "");
if (model.Image == null)
{
message = Message.FailedImageValidate;
return(false);
}
if (model.EventType == EventType.Mouse && model.MouseTriggerInfo.MouseInfoEventType == MouseEventType.None)
{
message = Message.FailedMouseCoordinatesValidate;
return(false);
}
if (string.IsNullOrEmpty(model.KeyboardCmd) && model.EventType == EventType.Keyboard)
{
message = Message.FailedKeyboardCommandValidate;
return(false);
}
if (string.IsNullOrEmpty(model.ProcessInfo.ProcessName))
{
message = Message.FailedProcessValidate;
return(false);
}
return(true);
}
private void MouseTriggerProcess(IntPtr hWnd, Point location, EventTriggerModel model, Tuple <float, float> factor)
{
var mousePosition = new Point()
{
X = Math.Abs(model.ProcessInfo.Position.Left + (model.MouseTriggerInfo.StartPoint.X + location.X) * -1) * factor.Item1,
Y = Math.Abs(model.ProcessInfo.Position.Top + (model.MouseTriggerInfo.StartPoint.Y + location.Y) * -1) * factor.Item2
};
if (model.MouseTriggerInfo.MouseInfoEventType == MouseEventType.LeftClick)
{
LogHelper.Debug($">>>>LMouse Save Position X : {model.MouseTriggerInfo.StartPoint.X} Save Position Y : {model.MouseTriggerInfo.StartPoint.Y} Target X : { mousePosition.X } Target Y : { mousePosition.Y }");
NativeHelper.PostMessage(hWnd, WindowMessage.LButtonDown, 1, mousePosition.ToLParam());
Task.Delay(100).Wait();
NativeHelper.PostMessage(hWnd, WindowMessage.LButtonUp, 0, mousePosition.ToLParam());
}
else if (model.MouseTriggerInfo.MouseInfoEventType == MouseEventType.RightClick)
{
LogHelper.Debug($">>>>RMouse Save Position X : {model.MouseTriggerInfo.StartPoint.X} Save Position Y : {model.MouseTriggerInfo.StartPoint.Y} Target X : { mousePosition.X } Target Y : { mousePosition.Y }");
NativeHelper.PostMessage(hWnd, WindowMessage.RButtonDown, 1, mousePosition.ToLParam());
Task.Delay(100).Wait();
NativeHelper.PostMessage(hWnd, WindowMessage.RButtonDown, 0, mousePosition.ToLParam());
}
else if (model.MouseTriggerInfo.MouseInfoEventType == MouseEventType.Drag)
{
LogHelper.Debug($">>>>Drag Mouse Save Position X : {model.MouseTriggerInfo.StartPoint.X} Save Position Y : {model.MouseTriggerInfo.StartPoint.Y} Target X : { mousePosition.X } Target Y : { mousePosition.Y }");
NativeHelper.PostMessage(hWnd, WindowMessage.LButtonDown, 1, mousePosition.ToLParam());
Task.Delay(100).Wait();
for (int i = 0; i < model.MouseTriggerInfo.MiddlePoint.Count; ++i)
{
mousePosition = new Point()
{
X = Math.Abs(model.ProcessInfo.Position.Left + model.MouseTriggerInfo.MiddlePoint[i].X * -1) * factor.Item1,
Y = Math.Abs(model.ProcessInfo.Position.Top + model.MouseTriggerInfo.MiddlePoint[i].Y * -1) * factor.Item2
};
NativeHelper.PostMessage(hWnd, WindowMessage.MouseMove, 1, mousePosition.ToLParam());
Task.Delay(100).Wait();
}
mousePosition = new Point()
{
X = Math.Abs(model.ProcessInfo.Position.Left + model.MouseTriggerInfo.EndPoint.X * -1) * factor.Item1,
Y = Math.Abs(model.ProcessInfo.Position.Top + model.MouseTriggerInfo.EndPoint.Y * -1) * factor.Item2
};
NativeHelper.PostMessage(hWnd, WindowMessage.MouseMove, 1, mousePosition.ToLParam());
Task.Delay(100).Wait();
NativeHelper.PostMessage(hWnd, WindowMessage.LButtonUp, 0, mousePosition.ToLParam());
LogHelper.Debug($">>>>Drag Mouse Save Position X : {model.MouseTriggerInfo.EndPoint.X} Save Position Y : {model.MouseTriggerInfo.EndPoint.Y} Target X : { mousePosition.X } Target Y : { mousePosition.Y }");
}
else if (model.MouseTriggerInfo.MouseInfoEventType == MouseEventType.Wheel)
{
LogHelper.Debug($">>>>Wheel Save Position X : {model.MouseTriggerInfo.StartPoint.X} Save Position Y : {model.MouseTriggerInfo.StartPoint.Y} Target X : { mousePosition.X } Target Y : { mousePosition.Y }");
//NativeHelper.PostMessage(hWnd, WindowMessage.LButtonDown, 1, mousePosition.ToLParam());
//Task.Delay(100).Wait();
//NativeHelper.PostMessage(hWnd, WindowMessage.LButtonUp, 0, mousePosition.ToLParam());
//NativeHelper.PostMessage(hWnd, WindowMessage.MouseWheel, ObjectExtensions.MakeWParam((uint)WindowMessage.MKControl, (uint)(model.MouseTriggerInfo.WheelData * -1)), 0);
//var hwnd = NativeHelper.FindWindowEx(NativeHelper.FindWindow(null, "Test.txt - 메모장"), IntPtr.Zero, "Edit", null);
//var p = new System.Drawing.Point(0, 0);
NativeHelper.PostMessage(hWnd, WindowMessage.MouseWheel, ObjectExtensions.MakeWParam(0, model.MouseTriggerInfo.WheelData * ConstHelper.WheelDelta), mousePosition.ToLParam());
}
}
public void Execute(object parameter)
{
var notice = parameter as EventTriggerModel;
EventTriggerModel.DeleteOne(notice);
VM.Events.Remove(notice);
}
public async Task <EventTriggerModel> InvokeNextEventTriggerAsync(EventTriggerModel saveModel, ProcessConfigModel processEventTriggerModel)
{
if (processEventTriggerModel.Token.IsCancellationRequested)
{
return(null);
}
var nextModel = await TriggerProcess(saveModel, processEventTriggerModel);
return(nextModel.Item2);
}
private void RemoveIndexTriggerModel(EventTriggerModel model)
{
if (_indexTriggerModels.ContainsKey(model.TriggerIndex))
{
_indexTriggerModels.Remove(model.TriggerIndex);
}
foreach (var child in model.SubEventTriggers)
{
RemoveIndexTriggerModel(child);
}
}
private void InsertIndexTriggerModel(EventTriggerModel model)
{
if (_indexTriggerModels.ContainsKey(model.TriggerIndex) == false)
{
_indexTriggerModels.Add(model.TriggerIndex, model);
}
foreach (var child in model.SubEventTriggers)
{
InsertIndexTriggerModel(child);
}
}
public static ulong CompareIndex(this EventTriggerModel source, ulong index)
{
if (source.TriggerIndex > index)
{
index = source.TriggerIndex;
}
foreach (var child in source.SubEventTriggers)
{
index = child.CompareIndex(index);
}
return(index);
}
private void ImageTriggerProcess(IntPtr hWnd, Point location, EventTriggerModel model)
{
var position = new Point()
{
X = location.X + model.MouseTriggerInfo.StartPoint.X,
Y = location.Y + model.MouseTriggerInfo.StartPoint.Y
};
LogHelper.Debug($">>>>Image Location X : {position.X} Location Y : {position.Y}");
NativeHelper.PostMessage(hWnd, WindowMessage.LButtonDown, 1, position.ToLParam());
Task.Delay(100).Wait();
NativeHelper.PostMessage(hWnd, WindowMessage.LButtonUp, 0, position.ToLParam());
}
public static void Clear(this EventTriggerModel source)
{
source.Image = null;
source.EventType = EventType.Image;
source.MouseTriggerInfo = new MouseTriggerInfo();
source.MonitorInfo = new MonitorInfo();
source.KeyboardCmd = "";
source.ProcessInfo = new ProcessInfo();
source.SubEventTriggers = new ObservableCollection <EventTriggerModel>();
source.AfterDelay = 0;
source.RepeatInfo = new RepeatInfoModel();
source.EventToNext = 0;
source.TriggerIndex = 0;
}
public void MakeIndexTriggerModel(EventTriggerModel model)
{
if (model.TriggerIndex == 0)
{
model.TriggerIndex = IncreaseIndex();
}
else if (model.TriggerIndex > _cacheData.MaxIndex)
{
_cacheData.MaxIndex = model.TriggerIndex;
}
foreach (var child in model.SubEventTriggers)
{
MakeIndexTriggerModel(child);
}
}
private bool Validate(EventTriggerModel model)
{
var process = comboProcess.SelectedValue as Process;
model.ProcessInfo = new ProcessInfo()
{
ProcessName = process?.ProcessName,
Position = new Rect()
};
if (TryModelValidate(model, out Message error))
{
var rect = new Rect();
NativeHelper.GetWindowRect(process.MainWindowHandle, ref rect);
model.ProcessInfo.Position = rect;
if (model.EventType != EventType.Mouse)
{
foreach (var monitor in DisplayHelper.MonitorInfo())
{
if (monitor.Rect.IsContain(rect))
{
if (model.MonitorInfo != null)
{
model.Image = model.Image.Resize((int)(model.Image.Width * (monitor.Dpi.X * 1.0F / model.MonitorInfo.Dpi.X)), (int)(model.Image.Height * (monitor.Dpi.Y * 1.0F / model.MonitorInfo.Dpi.Y)));
}
model.MonitorInfo = monitor;
break;
}
}
}
return(true);
}
else
{
this.MessageShow("Error", DocumentHelper.Get(error));
return(false);
}
}
public static EventTriggerModel Clone(this EventTriggerModel source)
{
return(new EventTriggerModel(source));
}
private async Task <Tuple <bool, EventTriggerModel> > TriggerProcess(EventTriggerModel model, ProcessConfigModel processEventTriggerModel)
{
var isExcute = false;
var hWnd = IntPtr.Zero;
var applciationData = ObjectExtensions.GetInstance <ApplicationDataManager>().Find(model.ProcessInfo.ProcessName) ?? new ApplicationDataModel();
for (int i = 0; i < processEventTriggerModel.Processes.Count; ++i)
{
var factor = CalculateFactor(processEventTriggerModel.Processes[i].MainWindowHandle, model, applciationData.IsDynamic);
if (string.IsNullOrEmpty(applciationData.HandleName))
{
hWnd = processEventTriggerModel.Processes[i].MainWindowHandle;
}
else
{
var item = NativeHelper.GetChildHandles(processEventTriggerModel.Processes[i].MainWindowHandle).Where(r => r.Item1.Equals(applciationData.HandleName)).FirstOrDefault();
if (item != null)
{
hWnd = item.Item2;
}
else
{
hWnd = processEventTriggerModel.Processes[i].MainWindowHandle;
}
}
if (model.RepeatInfo.RepeatType == RepeatType.Search && model.SubEventTriggers.Count > 0)
{
var count = model.RepeatInfo.Count;
while (DisplayHelper.ProcessCapture(processEventTriggerModel.Processes[i], out Bitmap bmp, applciationData.IsDynamic) && count-- > 0)
{
var targetBmp = model.Image.Resize((int)Math.Truncate(model.Image.Width * factor.Item1.Item1), (int)Math.Truncate(model.Image.Height * factor.Item1.Item1));
var similarity = OpenCVHelper.Search(bmp, targetBmp, out Point location, processEventTriggerModel.SearchImageResultDisplay);
LogHelper.Debug($"RepeatType[Search : {count}] : >>>> Similarity : {similarity} % max Loc : X : {location.X} Y: {location.Y}");
CaptureImage(bmp);
if (!await TaskHelper.TokenCheckDelayAsync(model.AfterDelay, processEventTriggerModel.Token) || similarity > processEventTriggerModel.Similarity)
{
break;
}
for (int ii = 0; ii < model.SubEventTriggers.Count; ++ii)
{
await TriggerProcess(model.SubEventTriggers[ii], processEventTriggerModel);
if (processEventTriggerModel.Token.IsCancellationRequested)
{
break;
}
}
factor = CalculateFactor(processEventTriggerModel.Processes[i].MainWindowHandle, model, applciationData.IsDynamic);
}
}
else
{
if (DisplayHelper.ProcessCapture(processEventTriggerModel.Processes[i], out Bitmap bmp, applciationData.IsDynamic))
{
var targetBmp = model.Image.Resize((int)Math.Truncate(model.Image.Width * factor.Item1.Item1), (int)Math.Truncate(model.Image.Height * factor.Item1.Item2));
var similarity = OpenCVHelper.Search(bmp, targetBmp, out Point location, processEventTriggerModel.SearchImageResultDisplay);
LogHelper.Debug($"Similarity : {similarity} % max Loc : X : {location.X} Y: {location.Y}");
CaptureImage(bmp);
if (similarity > processEventTriggerModel.Similarity)
{
if (model.SubEventTriggers.Count > 0)
{
if (model.RepeatInfo.RepeatType == RepeatType.Count || model.RepeatInfo.RepeatType == RepeatType.Once)
{
for (int ii = 0; ii < model.RepeatInfo.Count; ++ii)
{
if (!await TaskHelper.TokenCheckDelayAsync(model.AfterDelay, processEventTriggerModel.Token))
{
break;
}
for (int iii = 0; iii < model.SubEventTriggers.Count; ++iii)
{
await TriggerProcess(model.SubEventTriggers[iii], processEventTriggerModel);
if (processEventTriggerModel.Token.IsCancellationRequested)
{
break;
}
}
}
}
else if (model.RepeatInfo.RepeatType == RepeatType.NoSearch)
{
while (await TaskHelper.TokenCheckDelayAsync(model.AfterDelay, processEventTriggerModel.Token))
{
isExcute = false;
for (int ii = 0; ii < model.SubEventTriggers.Count; ++ii)
{
var childResult = await TriggerProcess(model.SubEventTriggers[ii], processEventTriggerModel);
if (processEventTriggerModel.Token.IsCancellationRequested)
{
break;
}
if (isExcute == false && childResult.Item1)
{
isExcute = childResult.Item1;
}
}
if (!isExcute)
{
break;
}
}
}
}
else
{
isExcute = true;
if (model.EventType == EventType.Mouse)
{
location.X = applciationData.OffsetX;
location.Y = applciationData.OffsetY;
MouseTriggerProcess(hWnd, location, model, factor.Item2);
}
else if (model.EventType == EventType.Image)
{
var percentage = _random.NextDouble();
location.X = ((location.X + applciationData.OffsetX) / factor.Item2.Item1) + (targetBmp.Width / factor.Item2.Item1 * percentage);
location.Y = ((location.Y + applciationData.OffsetY) / factor.Item2.Item2) + (targetBmp.Height / factor.Item2.Item1 * percentage);
ImageTriggerProcess(hWnd, location, model);
}
else if (model.EventType == EventType.RelativeToImage)
{
location.X = ((location.X + applciationData.OffsetX) / factor.Item2.Item1) + (targetBmp.Width / factor.Item2.Item1 / 2);
location.Y = ((location.Y + applciationData.OffsetY) / factor.Item2.Item2) + (targetBmp.Height / factor.Item2.Item2 / 2);
ImageTriggerProcess(hWnd, location, model);
}
else if (model.EventType == EventType.Keyboard)
{
KeyboardTriggerProcess(processEventTriggerModel.Processes[i].MainWindowHandle, model);
}
if (!await TaskHelper.TokenCheckDelayAsync(model.AfterDelay, processEventTriggerModel.Token))
{
break;
}
if (model.EventToNext > 0 && model.TriggerIndex != model.EventToNext)
{
EventTriggerModel nextModel = null;
nextModel = ObjectExtensions.GetInstance <CacheDataManager>().GetEventTriggerModel(model.EventToNext);
if (nextModel != null)
{
LogHelper.Debug($">>>>Next Move Event : CurrentIndex [ {model.TriggerIndex} ] NextIndex [ {nextModel.TriggerIndex} ] ");
return(Tuple.Create(isExcute, nextModel));
}
}
}
}
}
}
}
await TaskHelper.TokenCheckDelayAsync(processEventTriggerModel.ItemDelay, processEventTriggerModel.Token);
return(Tuple.Create <bool, EventTriggerModel>(isExcute, null));
}
private Tuple <Tuple <float, float>, Tuple <float, float> > CalculateFactor(IntPtr hWnd, EventTriggerModel model, bool isDynamic)
{
var currentPosition = new Rect();
NativeHelper.GetWindowRect(hWnd, ref currentPosition);
var factor = NativeHelper.GetSystemDPI();
var factorX = 1.0F;
var factorY = 1.0F;
var positionFactorX = 1.0F;
var positionFactorY = 1.0F;
if (isDynamic)
{
foreach (var monitor in DisplayHelper.MonitorInfo())
{
if (monitor.Rect.IsContain(currentPosition))
{
factorX = factor.X * factorX / model.MonitorInfo.Dpi.X;
factorY = factor.Y * factorY / model.MonitorInfo.Dpi.Y;
if (model.EventType == EventType.Mouse)
{
positionFactorX = positionFactorX * monitor.Dpi.X / model.MonitorInfo.Dpi.X;
positionFactorY = positionFactorY * monitor.Dpi.Y / model.MonitorInfo.Dpi.Y;
}
else
{
positionFactorX = positionFactorX * factor.X / monitor.Dpi.X;
positionFactorY = positionFactorY * factor.Y / monitor.Dpi.Y;
}
break;
}
}
}
return(Tuple.Create(Tuple.Create(factorX, factorY), Tuple.Create(positionFactorX, positionFactorY)));
}
