/// <param name="nCode">A code that uses to determine how to process the message.</param>
/// <param name="wParam">The identifier of the mouse message.</param>
/// <param name="lParam">A pointer to an MSLLHOOKSTRUCT structure.</param>
/// <returns></returns>
public override FilterResult msg(int nCode, WPARAM wParam, LPARAM lParam)
{
if (SysMessages.Eq(wParam, SysMessages.WM_MOUSEMOVE))
{
return(FilterResult.IgnoreFilters);
}
return(FilterResult.Continue);
}
private void sendCode(TCode cmd)
{
if(SysMessages.Eq(cmd.wParam, CodeDown)) {
sendCodeDown();
}
else if(SysMessages.Eq(cmd.wParam, CodeUp)) {
sendCodeUp();
}
}
public bool isFlag(MouseState.Flags flags, WPARAM wParam, uint code1, uint code2)
{
if ((listener.Handler & flags) != 0 &&
(SysMessages.EqOr(wParam, code1, code2)))
{
return(true);
}
return(false);
}
protected bool isLMR(WPARAM wParam)
{
if (SysMessages.EqOr(wParam,
SysMessages.WM_LBUTTONDOWN,
SysMessages.WM_LBUTTONUP,
SysMessages.WM_MBUTTONDOWN,
SysMessages.WM_MBUTTONUP,
SysMessages.WM_RBUTTONDOWN,
SysMessages.WM_RBUTTONUP))
{
return(true);
}
return(false);
}
public override FilterResult process(int nCode, WPARAM wParam, LPARAM lParam)
{
if (parent.Data == null)
{
parent.Data = new TData();
}
var v = (TData)parent.Data;
lock (sync)
{
if (toAbortNext && SysMessages.Eq(wParam, CodeUp))
{
toAbortNext = false;
LSender.Send(this, $"Prevent '{wParam}' because of previous mixed code.", Message.Level.Info);
return(FilterResult.Abort);
}
if (isBtnDown && SysMessages.Eq(wParam, CodeDown))
{
toAbortNext = true;
LSender.Send(this, $"Found mixed {wParam}", Message.Level.Info);
parent.trigger();
return(FilterResult.Abort);
}
if (!v.onlyDownCodes && (isBtnUp && SysMessages.Eq(wParam, CodeUp)))
{
LSender.Send(this, $"Found mixed {wParam}", Message.Level.Info);
parent.trigger();
return(FilterResult.Abort);
}
if (SysMessages.Eq(wParam, CodeDown))
{
isBtnDown = true;
isBtnUp = false;
}
else if (SysMessages.Eq(wParam, CodeUp))
{
isBtnDown = false;
isBtnUp = true;
}
#if DEBUG
LSender.Send(this, $"Continue {wParam}", Message.Level.Trace);
#endif
return(FilterResult.Continue);
}
}
/// <param name="nCode">A code that uses to determine how to process the message.</param>
/// <param name="wParam">The identifier of the mouse message.</param>
/// <param name="lParam">A pointer to an MSLLHOOKSTRUCT structure.</param>
/// <returns></returns>
public override FilterResult msg(int nCode, WPARAM wParam, LPARAM lParam)
{
if (SysMessages.Eq(wParam, SysMessages.WM_LBUTTONDOWN))
{
LSender.Send(this, $"WM_LBUTTONDOWN", Message.Level.Info);
}
else if (SysMessages.Eq(wParam, SysMessages.WM_LBUTTONUP))
{
LSender.Send(this, $"WM_LBUTTONUP", Message.Level.Info);
}
else if (SysMessages.Eq(wParam, SysMessages.WM_RBUTTONDOWN))
{
LSender.Send(this, $"WM_RBUTTONDOWN", Message.Level.Info);
}
else if (SysMessages.Eq(wParam, SysMessages.WM_RBUTTONUP))
{
LSender.Send(this, $"WM_RBUTTONUP", Message.Level.Info);
}
else if (SysMessages.Eq(wParam, SysMessages.WM_MBUTTONDOWN))
{
LSender.Send(this, $"WM_MBUTTONDOWN", Message.Level.Info);
}
else if (SysMessages.Eq(wParam, SysMessages.WM_MBUTTONUP))
{
LSender.Send(this, $"WM_MBUTTONUP", Message.Level.Info);
}
else if (SysMessages.Eq(wParam, SysMessages.WM_MOUSEWHEEL))
{
LSender.Send(this, $"WM_MOUSEWHEEL", Message.Level.Info);
}
else if (SysMessages.Eq(wParam, SysMessages.WM_MOUSEHWHEEL))
{
LSender.Send(this, $"[WM_MOUSEHWHEEL]", Message.Level.Info);
}
//unchecked {
// ++TriggerCount;
//}
return(FilterResult.Continue);
}
public override FilterResult process(int nCode, WPARAM wParam, LPARAM lParam)
{
lock (sync)
{
var d = Delta;
//LSender.Send(this, $"{wParam} - delta {d}ms", Message.Level.Trace);
if (isPrevCodeDown && SysMessages.Eq(wParam, CodeUp))
{
isPrevCodeDown = false;
LSender.Send(this, $"Prevent '{wParam}' because of previous {CodeDown}", Message.Level.Debug);
return(FilterResult.Abort);
}
if (isPrevCodeDown && SysMessages.Eq(wParam, CodeDown))
{
isPrevCodeDown = false;
LSender.Send(this, $"Expected '{CodeUp}' was not found. Reset flag.", Message.Level.Debug);
}
if (SysMessages.Eq(wParam, CodeDown) && d < parent.Value)
{
LSender.Send(this, $"Found double-click bug of '{wParam}' because of delta {d}", Message.Level.Info);
isPrevCodeDown = true;
parent.trigger();
updateStamp();
return(FilterResult.Abort);
}
if (SysMessages.Eq(wParam, CodeDown))
{
updateStamp();
}
return(FilterResult.Continue);
}
}
/// <param name="nCode">A code that uses to determine how to process the message.</param>
/// <param name="wParam">The identifier of the mouse message.</param>
/// <param name="lParam">A pointer to an MSLLHOOKSTRUCT structure.</param>
/// <returns></returns>
public override FilterResult msg(int nCode, WPARAM wParam, LPARAM lParam)
{
if (Data == null || !SysMessages.EqOr(wParam, SysMessages.WM_MOUSEWHEEL))
{
//TODO: SysMessages.WM_MOUSEHWHEEL
return(FilterResult.Continue);
}
var llhook = getMSLLHOOKSTRUCT(lParam);
uint delta = llhook.time - prevStamp;
var v = (TData)Data;
if (delta > v.limit)
{
count = 0;
}
else
{
++count;
}
if (count > v.capacity)
{
LSender.Send(this, $"Scroll has been filtered {wParam}/{count} = {v.capacity}:{v.limit}", Message.Level.Info);
((IMouseListenerSvc)this).trigger();
return(FilterResult.Abort);
}
//if(delta < v.acceleration && count > v.capacity) {
// ++accelerationCount;
//}
LSender.Send(this, $"MouseData: count {count} - delta {delta}", Message.Level.Trace);
prevStamp = llhook.time;
return(FilterResult.Continue);
}
public override FilterResult process(int nCode, WPARAM wParam, LPARAM lParam)
{
//if(shadowClick) { // now it will be processed via ReCodes + lowLevelMouseProc
// return FilterResult.Continue;
//}
if(!raisedCodeUp && SysMessages.Eq(wParam, CodeDown)) {
stampCodeDown = DateTime.Now;
return FilterResult.Continue;
}
if(raisedCodeUp && SysMessages.Eq(wParam, CodeUp)) {
return FilterResult.Continue;
}
var delta = (DateTime.Now - stampCodeDown).TotalMilliseconds;
var v = Data;
if((delta > v.deltaMin && delta <= v.deltaMax) && SysMessages.Eq(wParam, CodeUp)) {
LSender.Send(this, $"{CodeDown} <-{delta}-> {CodeUp}-{CodeDown} :: consider as a user click", Message.Level.Debug);
return FilterResult.Continue;
}
if(SysMessages.Eq(wParam, CodeUp)) {
raisedCodeUp = true;
}
buffer.Enqueue(new TCode() {
nCode = nCode,
lParam = lParam,
wParam = wParam
});
LSender.Send(this, $"'{wParam}' has been buffered ({buffer.Count})", Message.Level.Trace);
if(lockedThread) {
return FilterResult.Abort;
}
Task.Factory.StartNew(() =>
{
lock(sync)
{
lockedThread = true;
var cmd1 = new TCode();
while(buffer.Count > 0)
{
if(!buffer.TryDequeue(out cmd1)) {
shortSleep();
continue;
}
if(SysMessages.Eq(cmd1.wParam, CodeUp)) {
// now we should look possible bug: down ... [up, down] ... up
waitNewCodes();
break;
}
if(SysMessages.Eq(cmd1.wParam, CodeDown)) {
sendCodeDown();
lockedThread = false;
return;
}
}
if(SysMessages.Eq(cmd1.wParam, 0)) {
raisedCodeUp = false;
lockedThread = false;
return;
}
TCode cmd2;
if(buffer.Count > 0)
{
while(!buffer.TryDequeue(out cmd2)) {
shortSleep();
}
LSender.Send(this, $"Buffer > 0 :: {cmd2.wParam}", Message.Level.Trace);
}
else {
cmd2 = new TCode();
}
if(SysMessages.Eq(cmd1.wParam, CodeUp)
&& SysMessages.Eq(cmd2.wParam, CodeDown))
{
LSender.Send(this, $"Found bug with recovering of codes {CodeUp} -> {CodeDown}", Message.Level.Info);
parent.trigger();
}
else {
resend(cmd1, cmd2);
}
raisedCodeUp = false;
lockedThread = false;
}
});
//stamp = DateTime.Now;
return FilterResult.Abort;
}
