public HookBinding(IBindingMethod bindingMethod, HookType hookType, BindingScope bindingScope, int hookOrder)
: base(bindingMethod)
{
HookOrder = hookOrder;
HookType = hookType;
BindingScope = bindingScope;
}
public static void SetHook(
HookType hookType,
AssemblyDefinition targetAssembly, string targetName,
AssemblyDefinition calleeAssembly, string calleeName)
{
int i0 = targetName.LastIndexOf('.');
if (i0 < 0)
{
throw new Exception(string.Format("SetHook - Error : Bad Name ({0})", targetName));
}
string targetTypeName = targetName.Substring(0, i0);
string targetMethodName = targetName.Substring(i0 + 1);
int i1 = calleeName.LastIndexOf('.');
if (i1 < 0)
{
throw new Exception(string.Format("SetHook - Error : Bad Name ({0})", calleeName));
}
string calleeTypeName = calleeName.Substring(0, i1);
string calleeMethodName = calleeName.Substring(i1 + 1);
SetHook(hookType,
targetAssembly, targetTypeName, targetMethodName,
calleeAssembly, calleeTypeName, calleeMethodName);
}
public static void AddMethod(Function func, HookType type)
{
switch (type)
{
case HookType.Update:
UpdateLoop += func;
break;
case HookType.Render:
RenderLoop += func;
break;
case HookType.GUI:
GUILoop += func;
break;
case HookType.FixedUpdate:
FixedUpdateLoop += func;
break;
case HookType.LateUpdate:
LateUpdateLoop += func;
break;
case HookType.PreRender:
PreRenderLoop += func;
break;
case HookType.PostRender:
PostRenderLoop += func;
break;
case HookType.Dispose:
DisposeFunc += func;
break;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="HookEntityMetadata" /> class.
/// </summary>
/// <param name="hookType"></param>
/// <param name="entry"></param>
/// <param name="state">The state.</param>
/// <param name="context">The optional existing context (I believe this is usable for migrations).</param>
public HookEntityMetadata(HookType hookType, HookedEntityEntry entry, EntityState state, System.Data.Entity.DbContext context = null)
{
HookType = hookType;
Entry = entry;
_state = state;
CurrentContext = context;
}
public ArrayList GetHooks (HookType hookType, HookDir dir, HookAction action, Type type, string member)
{
if (dir == HookDir.Read)
return FindHook (ReaderHooks, hookType, action, type, member);
else
return FindHook (WriterHooks, hookType, action, type, member);
}
public static void SetHook(
HookType hookType,
AssemblyDefinition targetAssembly, string targetTypeName, string targetMethodName,
AssemblyDefinition calleeAssembly, string calleeTypeName, string calleeMethodName)
{
#if DEBUG
Console.WriteLine("SetHook - {0}/{1}|{2} -> {3}/{4}|{5}", targetAssembly.Name.Name, targetTypeName, targetMethodName, calleeAssembly.Name.Name, calleeTypeName, calleeMethodName);
#endif
TypeDefinition calleeTypeDefinition = calleeAssembly.MainModule.GetType(calleeTypeName);
if (calleeTypeDefinition == null)
{
throw new Exception(string.Format("Error ({0}) : {1} is not found", calleeAssembly.Name, calleeTypeName));
}
MethodDefinition calleeMethod = GetMethod(calleeTypeDefinition, calleeMethodName);
if (calleeMethod == null)
{
throw new Exception(string.Format("Error ({0}) : {1}.{2} is not found", calleeAssembly.Name, calleeTypeName, calleeMethodName));
}
TypeDefinition targetTypeDefinition = targetAssembly.MainModule.GetType(targetTypeName);
if (targetTypeDefinition == null)
{
throw new Exception(string.Format("Error ({0}) : {1} is not found", targetAssembly.Name, targetTypeName));
}
MethodDefinition targetMethod = GetMethod(targetTypeDefinition, targetMethodName);
if (targetMethod == null)
{
throw new Exception(string.Format("Error ({0}) : {1}.{2} is not found", targetAssembly.Name, targetTypeName, targetMethodName));
}
HookMethod(hookType, targetAssembly.MainModule, targetMethod, calleeMethod);
}
/// <summary>
/// Creates a new hook.
/// </summary>
public Hook(HookType type, bool wrapCallback, bool global)
: this()
{
this.type = type;
this.wrapCallback = wrapCallback;
this.global = global;
}
private double GetConfinementModifier(HookType hookType, bool enclosingRebarIsPerpendicular, double enclosingRebarSpacing)
{
double confinementModifier=1.0;
if (hookType== HookType.Degree90 && db<=11/8)
{
// (b) For 90-degree hooks of No. 11 and smaller bars
// that are either enclosed within ties or stirrups
// perpendicular to the bar being developed, spaced
// not greater than 3db along ldh; or enclosed within
// ties or stirrups parallel to the bar being developed,
// spaced not greater than 3db along the length of the
// tail extension of the hook plus bend.................... 0.8
if (enclosingRebarIsPerpendicular == true && enclosingRebarSpacing <= 3.0 * db)
{
confinementModifier = SetConfinementModifier();
}
if (enclosingRebarIsPerpendicular ==true && enclosingRebarSpacing<3.0*db)
{
confinementModifier = SetConfinementModifier();
}
}
if (hookType== HookType.Degree180 && db<=11/8)
{
if (enclosingRebarIsPerpendicular==true && enclosingRebarSpacing<=3*db)
{
confinementModifier = SetConfinementModifier();
}
}
return confinementModifier;
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseHook"/> class.
/// </summary>
/// <param name="hookType">Type of the hook.</param>
/// <param name="install">if set to <c>true</c> [install].</param>
internal BaseHook(HookType hookType, bool install)
: this(hookType)
{
if (install)
{
this.Install();
}
}
public WM_TouchHook(IntPtr hWnd, HookType hookType) : base(hWnd, hookType)
{
this.scalingFactorX = 1f;
this.scalingFactorY = 1f;
DisableNativePressAndHoldGesture = true;
this.mdTouchInputSize = Marshal.SizeOf(new TOUCHINPUT());
this.gestureDelegate = new Win32.WndProcDelegate(this.GestureWndProc);
}
internal HookBase(HookType type)
{
_hType = type;
_hProc = new HookProc(HookProcBase);
using (Process p = Process.GetCurrentProcess())
using (ProcessModule pm = p.MainModule)
_hHook = SetWindowsHookEx((int)_hType, _hProc, GetModuleHandle(pm.ModuleName), 0);
}
public WindowsHook(IntPtr hWnd, HookType hook, HookDelegate proc)
{
this.hHook = IntPtr.Zero;
this.hWnd = IntPtr.Zero;
this.hWnd = hWnd;
this.hookType = hook;
this.hookDelegate = proc;
}
public WindowsHook(IntPtr hWnd, HookType hook)
{
this.hHook = IntPtr.Zero;
this.hWnd = IntPtr.Zero;
this.hWnd = hWnd;
this.hookType = hook;
this.hookDelegate = new HookDelegate(this.CoreHookProc);
}
private IEnumerable<IHookBinding> GetHookList(HookType bindingEvent)
{
List<IHookBinding> list;
if (hooks.TryGetValue(bindingEvent, out list))
return list;
return Enumerable.Empty<IHookBinding>();
}
internal HookHandle(HookType hookType, HookProc hookProc) : base(IntPtr.Zero, false)
{
GCHandle.Alloc(hookProc);
handle = User32.SetWindowsHookEx(hookType, hookProc, IntPtr.Zero, IntPtr.Zero);
if (handle == IntPtr.Zero)
{
IsInvalid = true;
}
}
protected override bool ValidateHook(BindingSourceMethod bindingSourceMethod, BindingSourceAttribute hookAttribute, HookType hookType)
{
//TODO: this call will be refactored when binding error detecttion will be improved in v2 - currently implemented here for backwards compatibility
if (!IsScenarioSpecificHook(hookType) &&
!bindingSourceMethod.IsStatic)
throw errorProvider.GetNonStaticEventError(bindingSourceMethod.BindingMethod);
return base.ValidateHook(bindingSourceMethod, hookAttribute, hookType);
}
public static void Install()
{
_hookDelegate = Hook;
IntPtr addr = Kernel32.GetProcAddress(Kernel32.GetModuleHandle("ws2_32.dll"), "WSAAsyncGetHostByName");
_originalDelegate = (HookType) Marshal.GetDelegateForFunctionPointer(addr, typeof (HookType));
HookHelper.Jump(_hookAddress, Marshal.GetFunctionPointerForDelegate(_hookDelegate));
}
protected bool IsScenarioSpecificHook(HookType hookType)
{
return
hookType == HookType.BeforeScenario ||
hookType == HookType.AfterScenario ||
hookType == HookType.BeforeScenarioBlock ||
hookType == HookType.AfterScenarioBlock ||
hookType == HookType.BeforeStep ||
hookType == HookType.AfterStep;
}
private List<IHookBinding> GetHookList(HookType bindingEvent)
{
List<IHookBinding> list;
if (!hooks.TryGetValue(bindingEvent, out list))
{
list = new List<IHookBinding>();
hooks.Add(bindingEvent, list);
}
return list;
}
public static int GetHookType(HookType type)
{
switch (type)
{
case HookType.Lava:
return 1150888;
case HookType.Dredging:
return 1150890;
case HookType.JunkProof:
return 1150883;
}
return 0;
}
public SvnChangeInfoEventArgsWrapper(HookType hookType, SvnChangeInfoEventArgs svnChangeInfoEventArgs)
{
this.HookType = hookType;
this.BaseRevision = svnChangeInfoEventArgs.BaseRevision;
this.Author = svnChangeInfoEventArgs.Author;
this.LogMessage = svnChangeInfoEventArgs.LogMessage;
this.Revision = svnChangeInfoEventArgs.Revision;
this.Time = svnChangeInfoEventArgs.Time;
this.AffectedItems = new List<IRepoAffectedItem>();
foreach (SvnChangeItem item in svnChangeInfoEventArgs.ChangedPaths)
{
this.AffectedItems.Add(new SvnChangeItemWrapper(item));
}
}
public static IEnumerable<Hook> CollectHooks(HookType hookType, Type type) {
if (type.BaseType != null)
foreach (var hook in CollectHooks(hookType, type.BaseType))
yield return hook;
if (HasStorableClassAttribute(type)) {
foreach (MethodInfo methodInfo in type.GetMethods(DECLARED_INSTANCE_MEMBERS)) {
if (methodInfo.ReturnType == typeof(void) && methodInfo.GetParameters().Length == 0) {
foreach (StorableHookAttribute hook in methodInfo.GetCustomAttributes(typeof(StorableHookAttribute), false)) {
if (hook != null && hook.HookType == hookType) {
yield return CreateHook(methodInfo);
}
}
}
}
}
}
public static void SetHook(
HookType hookType,
AssemblyDefinition targetAssembly, string targetName,
AssemblyDefinition calleeAssembly, string calleeName)
{
string targetTypeName;
string targetMethodName;
SplitName(targetName, out targetTypeName, out targetMethodName);
string calleeTypeName;
string calleeMethodName;
SplitName(calleeName, out calleeTypeName, out calleeMethodName);
SetHook(hookType,
targetAssembly, targetTypeName, targetMethodName,
calleeAssembly, calleeTypeName, calleeMethodName);
}
public static bool SetHookValue(HookType type, int index, Composite value, bool insert = false)
{
if (!TreeHooks.Instance.Hooks.ContainsKey(type.ToString())) return false;
if (!insert)
{
TreeHooks.Instance.Hooks[type.ToString()][index] = value;
Logger.DBLog.DebugFormat("Replaced Hook [{0}]", type.ToString());
return true;
}
else
{
TreeHooks.Instance.Hooks[type.ToString()].Insert(index, value);
Logger.DBLog.DebugFormat("Inserted composite for Hook [{0}] at index {1}", type.ToString(), index);
return true;
}
}
internal static void Install(HookType hook)
{
var hookLocation1 = new IntPtr(0x005D53B1);
var hookLocation = new IntPtr(0x005D5590);
IntPtr codeCave2 = Marshal.AllocHGlobal(4);
IntPtr codeCave1 = Marshal.AllocHGlobal(128);
byte[] code1 = FasmNet.Assemble(new[]
{
"use32",
"org " + codeCave1,
"push esi",
"push edi",
"mov esi, dword[ebx+0x10]",
"mov dword[" + codeCave2 + "],esi",
"lea esi, dword[ebx+0x78]",
"jmp " + (hookLocation1 + 5)
});
Marshal.Copy(code1, 0, codeCave1, code1.Length);
HookHelper.Jump(hookLocation1, codeCave1);
IntPtr codeCave = Marshal.AllocHGlobal(128);
byte[] code = FasmNet.Assemble(new[]
{
"use32",
"org " + codeCave,
"push dword [ebp+0x8]",
"push dword [" + codeCave2 + "]",
"call " + Marshal.GetFunctionPointerForDelegate(hook),
"pop edi",
"pop esi",
"pop ebx",
"leave",
"retn 8"
});
Marshal.Copy(code, 0, codeCave, code.Length);
HookHelper.Jump(hookLocation, codeCave);
}
internal static void Install(HookType hook)
{
var hookLocation = new IntPtr(0x0A2B2E8);
IntPtr codeCave = Marshal.AllocHGlobal(128);
byte[] code = FasmNet.Assemble(new[]
{
"use32",
"org " + codeCave,
"pushad",
"call " + Marshal.GetFunctionPointerForDelegate(hook),
"popad",
"retn"
});
Marshal.Copy(code, 0, codeCave, code.Length);
Marshal.WriteIntPtr(hookLocation, codeCave);
}
public double GetDevelopmentLength(HookType hookType, double sideCover, double barExtensionCover, bool enclosingRebarIsPerpendicular, double enclosingRebarSpacing)
{
double ldh = this.GetBasicDevelopmentLength();
//ldh modifiers per 12.5.3
// (a)
double SideCoverModifier = GetSideCoverModifier(hookType, sideCover, barExtensionCover);
// (b) & (c)
double ConfinementModifier = GetConfinementModifier(hookType, enclosingRebarIsPerpendicular, enclosingRebarSpacing);
// (d) -- see below
if (SideCoverModifier==0.0 || ConfinementModifier==0.0)
{
throw new Exception("Hook development modifiers cannot be 0");
}
ldh = ldh * SideCoverModifier * ConfinementModifier;
ldh = this.CheckDevelopmentLengthForExcessAndMinimum(ldh);
return ldh;
}
internal static void Install(HookType hook)
{
var hookLocation = new IntPtr(0x007B25F6);
IntPtr codeCave = Marshal.AllocHGlobal(128);
byte[] code = FasmNet.Assemble(new[]
{
"use32",
"org " + codeCave,
"mov dword[esi+0x88],ecx",
"pushad",
"push dword[esi+0x2C]",
"call " + Marshal.GetFunctionPointerForDelegate(hook),
"popad",
"jmp " + (hookLocation + 6)
});
Marshal.Copy(code, 0, codeCave, code.Length);
HookHelper.Jump(hookLocation, codeCave);
}
public SharpHook(HookType hookType)
{
using (Process process = Process.GetCurrentProcess())
using (ProcessModule module = process.MainModule)
{
IntPtr hModule = Win32API.GetModuleHandle(module.ModuleName);
if ((hookType & HookType.Keyboard) > 0)
{
keyboardHookProc = new Win32API.HookProc(KeyboardHookProc);
keyboardHook = Win32API.SetWindowsHookEx(Win32API.HookType.WH_KEYBOARD_LL, keyboardHookProc, hModule, 0);
}
if ((hookType & HookType.Mouse) > 0)
{
Debug.WriteLine("DoubleClickTime: " + Win32API.GetDoubleClickTime());
mouseHookProc = new Win32API.HookProc(MouseHookProc);
mouseHook = Win32API.SetWindowsHookEx(Win32API.HookType.WH_MOUSE_LL, mouseHookProc, hModule, 0);
}
}
}
public static void HookMethod(
HookType hookType,
ModuleDefinition targetModule, MethodDefinition targetMethod,
MethodDefinition calleeMethod)
{
ILProcessor l = targetMethod.Body.GetILProcessor();
Instruction instInsertPoint = targetMethod.Body.Instructions.First();
if (hookType == HookType.PostCall)
{
instInsertPoint = targetMethod.Body.Instructions.Last();
}
InsertInstDelegate o = newInst =>
{
l.InsertBefore(instInsertPoint, newInst);
};
int n = targetMethod.Parameters.Count + (targetMethod.IsStatic ? 0 : 1);
for (int i = 0; i < n; i++)
{
if (i == 0)
{
o(l.Create(OpCodes.Ldarg_0));
}
else
{
// ref 参照にしたい場合は OpCodes.Ldarga にすること
o(l.Create(OpCodes.Ldarg, i));
}
}
o(l.Create(OpCodes.Call, targetModule.Import(calleeMethod)));
// PreJumpの場合は元の処理を行わないように、そのままRetする
if (hookType == HookType.PreJump)
{
o(l.Create(OpCodes.Ret));
}
}
public static extern IntPtr SetWindowsHookEx(HookType code,
HookProc func,
IntPtr hInstance,
int threadID);
public static extern IntPtr SetWindowsHookEx(HookType hookType, HookProc callback, IntPtr hMod, uint dwThreadId);
public static extern int SetWindowsHookEx(
HookType idHook,
HookProc lpfn,
IntPtr hInstance,
int threadId
);
public LocalWindowsHook(HookType hook)
{
m_hookType = hook;
m_filterFunc = new HookProc(this.CoreHookProc);
}
public Task ExecuteAsync(HookType type, IDomainEntityContext <T> context, CancellationToken cancellationToken)
{
_logger.LogInformation($"{type}: {typeof(T).Name}");
return(Task.CompletedTask);
}
private void FireScenarioEvents(HookType bindingEvent)
{
FireEvents(bindingEvent);
}
public LocalWindowsHook(HookType hook, HookProc func)
{
m_hookType = hook;
m_filterFunc = func;
}
protected WindowsHook(HookType hookType, UserCallback userCallback)
{
this.hookType = hookType;
this.userCallback = userCallback;
this.systemCallback = Callback;
}
protected static extern IntPtr SetWindowsHookEx(HookType code,
HookProc func,
IntPtr hInstance,
int threadId);
private static extern IntPtr SetWindowsHookEx(HookType idHook, HookProc lpfn, IntPtr hMod, int dwThreadId);
private IOrderedEnumerable <IHookBinding> GetOrderedHooks(HookType bindingEvent)
{
return(bindingRegistry.GetHooks(bindingEvent).OrderBy(x => x.HookOrder));
}
protected void Install(HookType type)
{
base.m_hookType = type;
base.Install();
}
public static extern int CallNextHookEx(HookType idHook, int nCode, IntPtr wParam, IntPtr lParam);
public static extern IntPtr SetWindowsHookEx(HookType hook, WndProcDelegate callback,
IntPtr hMod, uint dwThreadId);
// passed-in routine used for call-back
public WindowsHook(HookType hookType, WindowHookProc pfnClientHookProc)
{
this.hookType = hookType;
this.pfnClientHookProc = pfnClientHookProc;
SetWindowsHook();
}
protected void InstallHook(HookType hookType, bool global)
{
lock (HookLock)
{
// If hook is installed already then return.
_hookType = hookType;
if (hook1handleRef.Handle != IntPtr.Zero)
{
return;
}
string lpModuleName = System.Diagnostics.Process.GetCurrentProcess().MainModule.ModuleName;
var hMod = NativeMethods.GetModuleHandle(lpModuleName);
// Assign Virtual function.
_Hook1Procedure = new HookProcDelegate(Hook1Procedure);
IntPtr hook1Handle;
if (hookType == HookType.WH_MOUSE)
{
uint threadId = NativeMethods.GetCurrentThreadId();
// Listen for events.
hook1Handle = NativeMethods.SetWindowsHookEx(
(uint)hookType,
_Hook1Procedure,
hMod,
// Associate hook procedure with current application/thread only.
threadId
);
if (hook1Handle == IntPtr.Zero)
{
var ex = new Win32Exception();
throw new Exception(ex.Message);
}
_Hook2Procedure = new WinEventProcDelegate(Hook2Procedure);
// Listen for name change changes across all processes/threads on current desktop...
var hook2Handle = NativeMethods.SetWinEventHook(
EVENT_OBJECT_NAMECHANGE,
EVENT_OBJECT_NAMECHANGE,
IntPtr.Zero,
_Hook2Procedure,
0,
// Associate hook procedure with current application/thread only.
global ? 0 : threadId,
WINEVENT_OUTOFCONTEXT
);
if (hook2Handle == IntPtr.Zero)
{
var ex = new Win32Exception();
throw new Exception(ex.Message);
}
hook2handleRef = new HandleRef(null, hook2Handle);
// Listen for name change changes across all processes/threads on current desktop...
var hook3Handle = NativeMethods.SetWinEventHook(
EVENT_OBJECT_SHOW,
EVENT_OBJECT_SHOW,
IntPtr.Zero,
_Hook2Procedure,
0,
// Associate hook procedure with current application/thread only.
global ? 0 : threadId,
WINEVENT_OUTOFCONTEXT
);
if (hook3Handle == IntPtr.Zero)
{
var ex = new Win32Exception();
throw new Exception(ex.Message);
}
hook3handleRef = new HandleRef(null, hook3Handle);
}
else
{
// Listen for events.
hook1Handle = NativeMethods.SetWindowsHookEx((uint)hookType, _Hook1Procedure, hMod, 0);
if (hook1Handle == IntPtr.Zero)
{
var ex = new Win32Exception();
throw new Exception(ex.Message);
}
}
hook1handleRef = new HandleRef(null, hook1Handle);
}
}
private static extern IntPtr SetWindowsHookEx(HookType code, HookProc func, IntPtr instance, int threadID);
/// <summary>
/// Use your own HookProc ?
/// </summary>
public CoreWindowsHook(HookType hookType, Win32Api.HookProc callBackFunction)
{
InternalHookType = hookType;
CallBackFunction = callBackFunction;
}
/// <summary>
/// Register to the HookInvoked event
/// </summary>
public CoreWindowsHook(HookType hookType)
{
InternalHookType = hookType;
CallBackFunction = CoreHookProc;
}
public IEnumerable <IHookBinding> GetHooks(HookType bindingEvent)
{
return(Enumerable.Empty <IHookBinding>()); //not used in VS
}
protected WindowsHook(HookType hookType)
{
this.hookType = hookType;
SetWindowsHook();
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
switch (version)
{
case 4:
m_PlayerConstructed = reader.ReadBool();
m_LowerStatReq = reader.ReadInt();
goto case 3;
case 3:
m_UsesRemaining = reader.ReadInt();
m_ShowUsesRemaining = reader.ReadBool();
goto case 2;
case 2:
m_OriginalHue = reader.ReadInt();
int idx = reader.ReadInt();
m_BaitType = FishInfo.GetTypeFromIndex(idx);
m_HookType = (HookType)reader.ReadInt();
m_HookUses = reader.ReadInt();
m_BaitUses = reader.ReadInt();
m_EnhancedBait = reader.ReadBool();
SaveFlag flags = (SaveFlag)reader.ReadInt();
if (GetSaveFlag(flags, SaveFlag.xAttributes))
{
m_AosAttributes = new AosAttributes(this, reader);
}
else
{
m_AosAttributes = new AosAttributes(this);
}
if (GetSaveFlag(flags, SaveFlag.SkillBonuses))
{
m_AosSkillBonuses = new AosSkillBonuses(this, reader);
}
else
{
m_AosSkillBonuses = new AosSkillBonuses(this);
}
break;
case 1:
m_AosAttributes = new AosAttributes(this);
m_AosSkillBonuses = new AosSkillBonuses(this);
break;
}
if (Parent is Mobile)
{
m_AosSkillBonuses.AddTo((Mobile)Parent);
}
int strBonus = m_AosAttributes.BonusStr;
int dexBonus = m_AosAttributes.BonusDex;
int intBonus = m_AosAttributes.BonusInt;
if (Parent is Mobile && (strBonus != 0 || dexBonus != 0 || intBonus != 0))
{
Mobile m = (Mobile)Parent;
string modName = Serial.ToString();
if (strBonus != 0)
{
m.AddStatMod(new StatMod(StatType.Str, modName + "Str", strBonus, TimeSpan.Zero));
}
if (dexBonus != 0)
{
m.AddStatMod(new StatMod(StatType.Dex, modName + "Dex", dexBonus, TimeSpan.Zero));
}
if (intBonus != 0)
{
m.AddStatMod(new StatMod(StatType.Int, modName + "Int", intBonus, TimeSpan.Zero));
}
}
if (Parent is Mobile)
{
((Mobile)Parent).CheckStatTimers();
}
if (m_BaitType != null && m_BaitUses <= 0)
{
BaitType = null;
}
if (m_HookType != HookType.None && m_HookUses <= 0)
{
HookType = HookType.None;
}
if (version < 3 && m_Crafter != null)
{
m_PlayerConstructed = true;
if (m_Resource == CraftResource.None)
{
Resource = CraftResource.RegularWood;
}
else
{
DistributeMaterialBonus();
}
}
}
/// <summary>
/// Call this method to monitor for certain types of events
/// </summary>
protected void Install(HookType type)
{
InternalHookType = type;
base.Install();
}
public static extern IntPtr SetWindowsHookEx(HookType idHook, HookCallbackDelegate lpfn, IntPtr hMod, uint dwThreadId);
// ************************************************************************
// ************************************************************************
// Event delegate
// ************************************************************************
// ************************************************************************
// Class constructor(s)
public LocalWindowsHook(HookType hook)
{
MHookType = hook;
MFilterFunc = CoreHookProc;
}
private static extern int SetWindowsHookEx(HookType idHook, CallbackDelegate lpfn, int hInstance, int threadId);
public LocalWindowsHook(HookType hook, HookProc func)
{
MHookType = hook;
MFilterFunc = func;
}
public static extern IntPtr SetWindowsHookEx(HookType hookType, HookProcDelegate lpfn, IntPtr hModule, uint dwThreadId);
static extern IntPtr SetWindowsHookEx(HookType hookType, HookProc lpfn, IntPtr hMod, uint dwThreadId);
public static extern IntPtr SetWindowsHookEx(HookType hookType, UIntPtr lpfn, IntPtr hMod, uint dwThreadId);
