Format RenderApi code

This commit is contained in:
Yoshi Askharoun
2021-07-11 23:04:40 -05:00
parent 9fec520340
commit f793c0c94f
451 changed files with 38065 additions and 38065 deletions
@@ -9,38 +9,38 @@ using System;
namespace Microsoft.Iris.Render.Protocols.Splash.Desktop
{
internal interface IFormWindowCallback
{
void OnRendererSuspended(RENDERHANDLE target, bool fEnabled);
internal interface IFormWindowCallback
{
void OnRendererSuspended(RENDERHANDLE target, bool fEnabled);
void OnNativeScreensave(RENDERHANDLE target, bool fStartScreensave);
void OnNativeScreensave(RENDERHANDLE target, bool fStartScreensave);
void OnShellShutdownHook(RENDERHANDLE target, ushort uIdMsg);
void OnShellShutdownHook(RENDERHANDLE target, ushort uIdMsg);
void OnSetFocus(RENDERHANDLE target, bool focused, HWND hwndFocusChange);
void OnSetFocus(RENDERHANDLE target, bool focused, HWND hwndFocusChange);
void OnDropComplete(RENDERHANDLE target);
void OnDropComplete(RENDERHANDLE target);
void OnPartialDrop(RENDERHANDLE target, string file);
void OnPartialDrop(RENDERHANDLE target, string file);
unsafe void OnStateChange(RENDERHANDLE target, Message* stateInfo);
unsafe void OnStateChange(RENDERHANDLE target, Message* stateInfo);
void OnTerminalSessionChange(RENDERHANDLE target, IntPtr wParam, IntPtr lParam);
void OnTerminalSessionChange(RENDERHANDLE target, IntPtr wParam, IntPtr lParam);
void OnPrivateSysCommand(RENDERHANDLE target, IntPtr wParam, IntPtr lParam);
void OnPrivateSysCommand(RENDERHANDLE target, IntPtr wParam, IntPtr lParam);
void OnMouseIdle(RENDERHANDLE target, bool fNewIdle);
void OnMouseIdle(RENDERHANDLE target, bool fNewIdle);
void OnCloseRequested(RENDERHANDLE target);
void OnCloseRequested(RENDERHANDLE target);
void OnLoad(RENDERHANDLE target);
void OnLoad(RENDERHANDLE target);
void OnWindowDestroyed(
RENDERHANDLE target,
uint nFinalShow,
Rectangle rcLastPosition,
Point ptFinalMaxPosition);
void OnWindowDestroyed(
RENDERHANDLE target,
uint nFinalShow,
Rectangle rcLastPosition,
Point ptFinalMaxPosition);
void OnWindowCreated(RENDERHANDLE target, HWND m_hWnd);
}
void OnWindowCreated(RENDERHANDLE target, HWND m_hWnd);
}
}
@@ -8,8 +8,8 @@ using Microsoft.Iris.Render.Protocol;
namespace Microsoft.Iris.Render.Protocols.Splash.Desktop
{
internal interface IInputCallback
{
unsafe void OnInput(RENDERHANDLE target, Message* inputInfo);
}
internal interface IInputCallback
{
unsafe void OnInput(RENDERHANDLE target, Message* inputInfo);
}
}
@@ -10,68 +10,68 @@ using System.Runtime.InteropServices;
namespace Microsoft.Iris.Render.Protocols.Splash.Desktop
{
internal class LocalInputCallback : RemoteObject
{
private static ushort[] s_priv_ByteOrder_Msg0_OnInput;
protected LocalInputCallback()
internal class LocalInputCallback : RemoteObject
{
private static ushort[] s_priv_ByteOrder_Msg0_OnInput;
protected LocalInputCallback()
{
}
internal static LocalInputCallback CreateCallbackImpl(
RenderPort port,
RENDERHANDLE callbackInstance)
{
return new LocalInputCallback(port, callbackInstance);
}
protected LocalInputCallback(RenderPort port, RENDERHANDLE handle)
: base(port, handle, false)
{
}
public override bool Equals(object other) => other is LocalInputCallback && this.m_renderHandle == ((RemoteObject)other).m_renderHandle;
public override int GetHashCode() => base.GetHashCode();
internal static RENDERHANDLE BindCallback(RenderPort port) => port.RegisterCallback(new PortCallback(LocalInputCallback.DispatchCallback), out uint _);
private static unsafe void DispatchCallback(
RenderPort port,
IRenderHandleOwner owner,
CallbackMessage* message)
{
if (!(owner is IInputCallback _priv_target) || message->nMsg != 0U)
return;
LocalInputCallback.Dispatch_OnInput(port, _priv_target, (LocalInputCallback.Msg0_OnInput*)message);
}
private static unsafe void Dispatch_OnInput(
RenderPort _priv_port,
IInputCallback _priv_target,
LocalInputCallback.Msg0_OnInput* _priv_pmsg)
{
if (_priv_port.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*)_priv_pmsg, ref LocalInputCallback.s_priv_ByteOrder_Msg0_OnInput, typeof(LocalInputCallback.Msg0_OnInput), sizeof(CallbackMessage), 0);
RENDERHANDLE target = _priv_pmsg->target;
Message* pmsgInner;
MarshalHelper.Decode(_priv_port, (Message*)_priv_pmsg, _priv_pmsg->inputInfo, out pmsgInner);
_priv_target.OnInput(target, pmsgInner);
}
[Conditional("DEBUG")]
private static unsafe void OnInvalidCallback(CallbackMessage* message, string category)
{
}
[ComVisible(false)]
private struct Msg0_OnInput
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE target;
public BLOBREF inputInfo;
}
}
internal static LocalInputCallback CreateCallbackImpl(
RenderPort port,
RENDERHANDLE callbackInstance)
{
return new LocalInputCallback(port, callbackInstance);
}
protected LocalInputCallback(RenderPort port, RENDERHANDLE handle)
: base(port, handle, false)
{
}
public override bool Equals(object other) => other is LocalInputCallback && this.m_renderHandle == ((RemoteObject) other).m_renderHandle;
public override int GetHashCode() => base.GetHashCode();
internal static RENDERHANDLE BindCallback(RenderPort port) => port.RegisterCallback(new PortCallback(LocalInputCallback.DispatchCallback), out uint _);
private static unsafe void DispatchCallback(
RenderPort port,
IRenderHandleOwner owner,
CallbackMessage* message)
{
if (!(owner is IInputCallback _priv_target) || message->nMsg != 0U)
return;
LocalInputCallback.Dispatch_OnInput(port, _priv_target, (LocalInputCallback.Msg0_OnInput*) message);
}
private static unsafe void Dispatch_OnInput(
RenderPort _priv_port,
IInputCallback _priv_target,
LocalInputCallback.Msg0_OnInput* _priv_pmsg)
{
if (_priv_port.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*) _priv_pmsg, ref LocalInputCallback.s_priv_ByteOrder_Msg0_OnInput, typeof (LocalInputCallback.Msg0_OnInput), sizeof (CallbackMessage), 0);
RENDERHANDLE target = _priv_pmsg->target;
Message* pmsgInner;
MarshalHelper.Decode(_priv_port, (Message*) _priv_pmsg, _priv_pmsg->inputInfo, out pmsgInner);
_priv_target.OnInput(target, pmsgInner);
}
[Conditional("DEBUG")]
private static unsafe void OnInvalidCallback(CallbackMessage* message, string category)
{
}
[ComVisible(false)]
private struct Msg0_OnInput
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE target;
public BLOBREF inputInfo;
}
}
}
@@ -9,18 +9,18 @@ using Microsoft.Iris.Render.Protocol;
namespace Microsoft.Iris.Render.Protocols.Splash.Desktop.Nt
{
internal interface IDesktopManagerCallback
{
void OnEndDisplayModes(RENDERHANDLE target);
internal interface IDesktopManagerCallback
{
void OnEndDisplayModes(RENDERHANDLE target);
void OnDisplayMode(RENDERHANDLE target, RenderDisplayMode mode, bool fSupported);
void OnDisplayMode(RENDERHANDLE target, RenderDisplayMode mode, bool fSupported);
void OnBeginDisplayModes(RENDERHANDLE target);
void OnBeginDisplayModes(RENDERHANDLE target);
void OnEndEnumMonitorInfo(RENDERHANDLE target);
void OnEndEnumMonitorInfo(RENDERHANDLE target);
unsafe void OnMonitorInfo(RENDERHANDLE target, Message* info);
unsafe void OnMonitorInfo(RENDERHANDLE target, Message* info);
void OnBeginEnumMonitorInfo(RENDERHANDLE target);
}
void OnBeginEnumMonitorInfo(RENDERHANDLE target);
}
}
@@ -8,8 +8,8 @@ using Microsoft.Iris.Render.Protocol;
namespace Microsoft.Iris.Render.Protocols.Splash.Desktop.Nt
{
internal interface IHwndHostWindowCallback
{
void OnHandleChanged(RENDERHANDLE target, HWND m_hWnd);
}
internal interface IHwndHostWindowCallback
{
void OnHandleChanged(RENDERHANDLE target, HWND m_hWnd);
}
}
@@ -11,197 +11,197 @@ using System.Runtime.InteropServices;
namespace Microsoft.Iris.Render.Protocols.Splash.Desktop.Nt
{
internal class LocalDesktopManagerCallback : RemoteObject
{
private static ushort[] s_priv_ByteOrder_Msg0_OnEndDisplayModes;
private static ushort[] s_priv_ByteOrder_Msg1_OnDisplayMode;
private static ushort[] s_priv_ByteOrder_Msg2_OnBeginDisplayModes;
private static ushort[] s_priv_ByteOrder_Msg3_OnEndEnumMonitorInfo;
private static ushort[] s_priv_ByteOrder_Msg4_OnMonitorInfo;
private static ushort[] s_priv_ByteOrder_Msg5_OnBeginEnumMonitorInfo;
protected LocalDesktopManagerCallback()
internal class LocalDesktopManagerCallback : RemoteObject
{
private static ushort[] s_priv_ByteOrder_Msg0_OnEndDisplayModes;
private static ushort[] s_priv_ByteOrder_Msg1_OnDisplayMode;
private static ushort[] s_priv_ByteOrder_Msg2_OnBeginDisplayModes;
private static ushort[] s_priv_ByteOrder_Msg3_OnEndEnumMonitorInfo;
private static ushort[] s_priv_ByteOrder_Msg4_OnMonitorInfo;
private static ushort[] s_priv_ByteOrder_Msg5_OnBeginEnumMonitorInfo;
protected LocalDesktopManagerCallback()
{
}
internal static LocalDesktopManagerCallback CreateCallbackImpl(
RenderPort port,
RENDERHANDLE callbackInstance)
{
return new LocalDesktopManagerCallback(port, callbackInstance);
}
protected LocalDesktopManagerCallback(RenderPort port, RENDERHANDLE handle)
: base(port, handle, false)
{
}
public override bool Equals(object other) => other is LocalDesktopManagerCallback && this.m_renderHandle == ((RemoteObject)other).m_renderHandle;
public override int GetHashCode() => base.GetHashCode();
internal static RENDERHANDLE BindCallback(RenderPort port) => port.RegisterCallback(new PortCallback(LocalDesktopManagerCallback.DispatchCallback), out uint _);
private static unsafe void DispatchCallback(
RenderPort port,
IRenderHandleOwner owner,
CallbackMessage* message)
{
if (!(owner is IDesktopManagerCallback _priv_target))
return;
switch (message->nMsg)
{
case 0:
LocalDesktopManagerCallback.Dispatch_OnEndDisplayModes(port, _priv_target, (LocalDesktopManagerCallback.Msg0_OnEndDisplayModes*)message);
break;
case 1:
LocalDesktopManagerCallback.Dispatch_OnDisplayMode(port, _priv_target, (LocalDesktopManagerCallback.Msg1_OnDisplayMode*)message);
break;
case 2:
LocalDesktopManagerCallback.Dispatch_OnBeginDisplayModes(port, _priv_target, (LocalDesktopManagerCallback.Msg2_OnBeginDisplayModes*)message);
break;
case 3:
LocalDesktopManagerCallback.Dispatch_OnEndEnumMonitorInfo(port, _priv_target, (LocalDesktopManagerCallback.Msg3_OnEndEnumMonitorInfo*)message);
break;
case 4:
LocalDesktopManagerCallback.Dispatch_OnMonitorInfo(port, _priv_target, (LocalDesktopManagerCallback.Msg4_OnMonitorInfo*)message);
break;
case 5:
LocalDesktopManagerCallback.Dispatch_OnBeginEnumMonitorInfo(port, _priv_target, (LocalDesktopManagerCallback.Msg5_OnBeginEnumMonitorInfo*)message);
break;
}
}
private static unsafe void Dispatch_OnEndDisplayModes(
RenderPort _priv_port,
IDesktopManagerCallback _priv_target,
LocalDesktopManagerCallback.Msg0_OnEndDisplayModes* _priv_pmsg)
{
if (_priv_port.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*)_priv_pmsg, ref LocalDesktopManagerCallback.s_priv_ByteOrder_Msg0_OnEndDisplayModes, typeof(LocalDesktopManagerCallback.Msg0_OnEndDisplayModes), sizeof(CallbackMessage), 0);
RENDERHANDLE target = _priv_pmsg->target;
_priv_target.OnEndDisplayModes(target);
}
private static unsafe void Dispatch_OnDisplayMode(
RenderPort _priv_port,
IDesktopManagerCallback _priv_target,
LocalDesktopManagerCallback.Msg1_OnDisplayMode* _priv_pmsg)
{
if (_priv_port.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*)_priv_pmsg, ref LocalDesktopManagerCallback.s_priv_ByteOrder_Msg1_OnDisplayMode, typeof(LocalDesktopManagerCallback.Msg1_OnDisplayMode), sizeof(CallbackMessage), 0);
RENDERHANDLE target = _priv_pmsg->target;
RenderDisplayMode mode = _priv_pmsg->mode;
bool fSupported = _priv_pmsg->fSupported != 0U;
_priv_target.OnDisplayMode(target, mode, fSupported);
}
private static unsafe void Dispatch_OnBeginDisplayModes(
RenderPort _priv_port,
IDesktopManagerCallback _priv_target,
LocalDesktopManagerCallback.Msg2_OnBeginDisplayModes* _priv_pmsg)
{
if (_priv_port.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*)_priv_pmsg, ref LocalDesktopManagerCallback.s_priv_ByteOrder_Msg2_OnBeginDisplayModes, typeof(LocalDesktopManagerCallback.Msg2_OnBeginDisplayModes), sizeof(CallbackMessage), 0);
RENDERHANDLE target = _priv_pmsg->target;
_priv_target.OnBeginDisplayModes(target);
}
private static unsafe void Dispatch_OnEndEnumMonitorInfo(
RenderPort _priv_port,
IDesktopManagerCallback _priv_target,
LocalDesktopManagerCallback.Msg3_OnEndEnumMonitorInfo* _priv_pmsg)
{
if (_priv_port.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*)_priv_pmsg, ref LocalDesktopManagerCallback.s_priv_ByteOrder_Msg3_OnEndEnumMonitorInfo, typeof(LocalDesktopManagerCallback.Msg3_OnEndEnumMonitorInfo), sizeof(CallbackMessage), 0);
RENDERHANDLE target = _priv_pmsg->target;
_priv_target.OnEndEnumMonitorInfo(target);
}
private static unsafe void Dispatch_OnMonitorInfo(
RenderPort _priv_port,
IDesktopManagerCallback _priv_target,
LocalDesktopManagerCallback.Msg4_OnMonitorInfo* _priv_pmsg)
{
if (_priv_port.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*)_priv_pmsg, ref LocalDesktopManagerCallback.s_priv_ByteOrder_Msg4_OnMonitorInfo, typeof(LocalDesktopManagerCallback.Msg4_OnMonitorInfo), sizeof(CallbackMessage), 0);
RENDERHANDLE target = _priv_pmsg->target;
Message* pmsgInner;
MarshalHelper.Decode(_priv_port, (Message*)_priv_pmsg, _priv_pmsg->info, out pmsgInner);
_priv_target.OnMonitorInfo(target, pmsgInner);
}
private static unsafe void Dispatch_OnBeginEnumMonitorInfo(
RenderPort _priv_port,
IDesktopManagerCallback _priv_target,
LocalDesktopManagerCallback.Msg5_OnBeginEnumMonitorInfo* _priv_pmsg)
{
if (_priv_port.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*)_priv_pmsg, ref LocalDesktopManagerCallback.s_priv_ByteOrder_Msg5_OnBeginEnumMonitorInfo, typeof(LocalDesktopManagerCallback.Msg5_OnBeginEnumMonitorInfo), sizeof(CallbackMessage), 0);
RENDERHANDLE target = _priv_pmsg->target;
_priv_target.OnBeginEnumMonitorInfo(target);
}
[Conditional("DEBUG")]
private static unsafe void OnInvalidCallback(CallbackMessage* message, string category)
{
}
[ComVisible(false)]
private struct Msg0_OnEndDisplayModes
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE target;
}
[ComVisible(false)]
private struct Msg1_OnDisplayMode
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE target;
public RenderDisplayMode mode;
public uint fSupported;
}
[ComVisible(false)]
private struct Msg2_OnBeginDisplayModes
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE target;
}
[ComVisible(false)]
private struct Msg3_OnEndEnumMonitorInfo
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE target;
}
[ComVisible(false)]
private struct Msg4_OnMonitorInfo
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE target;
public BLOBREF info;
}
[ComVisible(false)]
private struct Msg5_OnBeginEnumMonitorInfo
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE target;
}
}
internal static LocalDesktopManagerCallback CreateCallbackImpl(
RenderPort port,
RENDERHANDLE callbackInstance)
{
return new LocalDesktopManagerCallback(port, callbackInstance);
}
protected LocalDesktopManagerCallback(RenderPort port, RENDERHANDLE handle)
: base(port, handle, false)
{
}
public override bool Equals(object other) => other is LocalDesktopManagerCallback && this.m_renderHandle == ((RemoteObject) other).m_renderHandle;
public override int GetHashCode() => base.GetHashCode();
internal static RENDERHANDLE BindCallback(RenderPort port) => port.RegisterCallback(new PortCallback(LocalDesktopManagerCallback.DispatchCallback), out uint _);
private static unsafe void DispatchCallback(
RenderPort port,
IRenderHandleOwner owner,
CallbackMessage* message)
{
if (!(owner is IDesktopManagerCallback _priv_target))
return;
switch (message->nMsg)
{
case 0:
LocalDesktopManagerCallback.Dispatch_OnEndDisplayModes(port, _priv_target, (LocalDesktopManagerCallback.Msg0_OnEndDisplayModes*) message);
break;
case 1:
LocalDesktopManagerCallback.Dispatch_OnDisplayMode(port, _priv_target, (LocalDesktopManagerCallback.Msg1_OnDisplayMode*) message);
break;
case 2:
LocalDesktopManagerCallback.Dispatch_OnBeginDisplayModes(port, _priv_target, (LocalDesktopManagerCallback.Msg2_OnBeginDisplayModes*) message);
break;
case 3:
LocalDesktopManagerCallback.Dispatch_OnEndEnumMonitorInfo(port, _priv_target, (LocalDesktopManagerCallback.Msg3_OnEndEnumMonitorInfo*) message);
break;
case 4:
LocalDesktopManagerCallback.Dispatch_OnMonitorInfo(port, _priv_target, (LocalDesktopManagerCallback.Msg4_OnMonitorInfo*) message);
break;
case 5:
LocalDesktopManagerCallback.Dispatch_OnBeginEnumMonitorInfo(port, _priv_target, (LocalDesktopManagerCallback.Msg5_OnBeginEnumMonitorInfo*) message);
break;
}
}
private static unsafe void Dispatch_OnEndDisplayModes(
RenderPort _priv_port,
IDesktopManagerCallback _priv_target,
LocalDesktopManagerCallback.Msg0_OnEndDisplayModes* _priv_pmsg)
{
if (_priv_port.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*) _priv_pmsg, ref LocalDesktopManagerCallback.s_priv_ByteOrder_Msg0_OnEndDisplayModes, typeof (LocalDesktopManagerCallback.Msg0_OnEndDisplayModes), sizeof (CallbackMessage), 0);
RENDERHANDLE target = _priv_pmsg->target;
_priv_target.OnEndDisplayModes(target);
}
private static unsafe void Dispatch_OnDisplayMode(
RenderPort _priv_port,
IDesktopManagerCallback _priv_target,
LocalDesktopManagerCallback.Msg1_OnDisplayMode* _priv_pmsg)
{
if (_priv_port.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*) _priv_pmsg, ref LocalDesktopManagerCallback.s_priv_ByteOrder_Msg1_OnDisplayMode, typeof (LocalDesktopManagerCallback.Msg1_OnDisplayMode), sizeof (CallbackMessage), 0);
RENDERHANDLE target = _priv_pmsg->target;
RenderDisplayMode mode = _priv_pmsg->mode;
bool fSupported = _priv_pmsg->fSupported != 0U;
_priv_target.OnDisplayMode(target, mode, fSupported);
}
private static unsafe void Dispatch_OnBeginDisplayModes(
RenderPort _priv_port,
IDesktopManagerCallback _priv_target,
LocalDesktopManagerCallback.Msg2_OnBeginDisplayModes* _priv_pmsg)
{
if (_priv_port.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*) _priv_pmsg, ref LocalDesktopManagerCallback.s_priv_ByteOrder_Msg2_OnBeginDisplayModes, typeof (LocalDesktopManagerCallback.Msg2_OnBeginDisplayModes), sizeof (CallbackMessage), 0);
RENDERHANDLE target = _priv_pmsg->target;
_priv_target.OnBeginDisplayModes(target);
}
private static unsafe void Dispatch_OnEndEnumMonitorInfo(
RenderPort _priv_port,
IDesktopManagerCallback _priv_target,
LocalDesktopManagerCallback.Msg3_OnEndEnumMonitorInfo* _priv_pmsg)
{
if (_priv_port.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*) _priv_pmsg, ref LocalDesktopManagerCallback.s_priv_ByteOrder_Msg3_OnEndEnumMonitorInfo, typeof (LocalDesktopManagerCallback.Msg3_OnEndEnumMonitorInfo), sizeof (CallbackMessage), 0);
RENDERHANDLE target = _priv_pmsg->target;
_priv_target.OnEndEnumMonitorInfo(target);
}
private static unsafe void Dispatch_OnMonitorInfo(
RenderPort _priv_port,
IDesktopManagerCallback _priv_target,
LocalDesktopManagerCallback.Msg4_OnMonitorInfo* _priv_pmsg)
{
if (_priv_port.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*) _priv_pmsg, ref LocalDesktopManagerCallback.s_priv_ByteOrder_Msg4_OnMonitorInfo, typeof (LocalDesktopManagerCallback.Msg4_OnMonitorInfo), sizeof (CallbackMessage), 0);
RENDERHANDLE target = _priv_pmsg->target;
Message* pmsgInner;
MarshalHelper.Decode(_priv_port, (Message*) _priv_pmsg, _priv_pmsg->info, out pmsgInner);
_priv_target.OnMonitorInfo(target, pmsgInner);
}
private static unsafe void Dispatch_OnBeginEnumMonitorInfo(
RenderPort _priv_port,
IDesktopManagerCallback _priv_target,
LocalDesktopManagerCallback.Msg5_OnBeginEnumMonitorInfo* _priv_pmsg)
{
if (_priv_port.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*) _priv_pmsg, ref LocalDesktopManagerCallback.s_priv_ByteOrder_Msg5_OnBeginEnumMonitorInfo, typeof (LocalDesktopManagerCallback.Msg5_OnBeginEnumMonitorInfo), sizeof (CallbackMessage), 0);
RENDERHANDLE target = _priv_pmsg->target;
_priv_target.OnBeginEnumMonitorInfo(target);
}
[Conditional("DEBUG")]
private static unsafe void OnInvalidCallback(CallbackMessage* message, string category)
{
}
[ComVisible(false)]
private struct Msg0_OnEndDisplayModes
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE target;
}
[ComVisible(false)]
private struct Msg1_OnDisplayMode
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE target;
public RenderDisplayMode mode;
public uint fSupported;
}
[ComVisible(false)]
private struct Msg2_OnBeginDisplayModes
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE target;
}
[ComVisible(false)]
private struct Msg3_OnEndEnumMonitorInfo
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE target;
}
[ComVisible(false)]
private struct Msg4_OnMonitorInfo
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE target;
public BLOBREF info;
}
[ComVisible(false)]
private struct Msg5_OnBeginEnumMonitorInfo
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE target;
}
}
}
@@ -10,63 +10,63 @@ using System.Runtime.InteropServices;
namespace Microsoft.Iris.Render.Protocols.Splash.Desktop.Nt
{
internal class LocalHwndHostWindowCallback : RemoteObject
{
protected LocalHwndHostWindowCallback()
internal class LocalHwndHostWindowCallback : RemoteObject
{
protected LocalHwndHostWindowCallback()
{
}
internal static LocalHwndHostWindowCallback CreateCallbackImpl(
RenderPort port,
RENDERHANDLE callbackInstance)
{
return new LocalHwndHostWindowCallback(port, callbackInstance);
}
protected LocalHwndHostWindowCallback(RenderPort port, RENDERHANDLE handle)
: base(port, handle, false)
{
}
public override bool Equals(object other) => other is LocalHwndHostWindowCallback && this.m_renderHandle == ((RemoteObject)other).m_renderHandle;
public override int GetHashCode() => base.GetHashCode();
internal static RENDERHANDLE BindCallback(RenderPort port) => port.RegisterCallback(new PortCallback(LocalHwndHostWindowCallback.DispatchCallback), out uint _);
private static unsafe void DispatchCallback(
RenderPort port,
IRenderHandleOwner owner,
CallbackMessage* message)
{
if (!(owner is IHwndHostWindowCallback _priv_target) || message->nMsg != 0U)
return;
LocalHwndHostWindowCallback.Dispatch_OnHandleChanged(port, _priv_target, (LocalHwndHostWindowCallback.Msg0_OnHandleChanged*)message);
}
private static unsafe void Dispatch_OnHandleChanged(
RenderPort _priv_port,
IHwndHostWindowCallback _priv_target,
LocalHwndHostWindowCallback.Msg0_OnHandleChanged* _priv_pmsg)
{
RENDERHANDLE target = _priv_pmsg->target;
HWND hWnd = _priv_pmsg->m_hWnd;
_priv_target.OnHandleChanged(target, hWnd);
}
[Conditional("DEBUG")]
private static unsafe void OnInvalidCallback(CallbackMessage* message, string category)
{
}
[ComVisible(false)]
private struct Msg0_OnHandleChanged
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE target;
public HWND m_hWnd;
}
}
internal static LocalHwndHostWindowCallback CreateCallbackImpl(
RenderPort port,
RENDERHANDLE callbackInstance)
{
return new LocalHwndHostWindowCallback(port, callbackInstance);
}
protected LocalHwndHostWindowCallback(RenderPort port, RENDERHANDLE handle)
: base(port, handle, false)
{
}
public override bool Equals(object other) => other is LocalHwndHostWindowCallback && this.m_renderHandle == ((RemoteObject) other).m_renderHandle;
public override int GetHashCode() => base.GetHashCode();
internal static RENDERHANDLE BindCallback(RenderPort port) => port.RegisterCallback(new PortCallback(LocalHwndHostWindowCallback.DispatchCallback), out uint _);
private static unsafe void DispatchCallback(
RenderPort port,
IRenderHandleOwner owner,
CallbackMessage* message)
{
if (!(owner is IHwndHostWindowCallback _priv_target) || message->nMsg != 0U)
return;
LocalHwndHostWindowCallback.Dispatch_OnHandleChanged(port, _priv_target, (LocalHwndHostWindowCallback.Msg0_OnHandleChanged*) message);
}
private static unsafe void Dispatch_OnHandleChanged(
RenderPort _priv_port,
IHwndHostWindowCallback _priv_target,
LocalHwndHostWindowCallback.Msg0_OnHandleChanged* _priv_pmsg)
{
RENDERHANDLE target = _priv_pmsg->target;
HWND hWnd = _priv_pmsg->m_hWnd;
_priv_target.OnHandleChanged(target, hWnd);
}
[Conditional("DEBUG")]
private static unsafe void OnInvalidCallback(CallbackMessage* message, string category)
{
}
[ComVisible(false)]
private struct Msg0_OnHandleChanged
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE target;
public HWND m_hWnd;
}
}
}
@@ -10,80 +10,80 @@ using System;
namespace Microsoft.Iris.Render.Protocols.Splash.Desktop.Nt
{
internal sealed class ProtocolSplashDesktopNt : ProtocolInstance
{
private RENDERHANDLE _priv_remoteClass_FormWindow;
private RENDERHANDLE _priv_remoteClass_HwndHostWindow;
private RENDERHANDLE _priv_remoteClass_DesktopManager;
private RENDERHANDLE _priv_callbackInstance_HwndHostWindowCallback;
private RENDERHANDLE _priv_callbackInstance_DesktopManagerCallback;
public static ProtocolSplashDesktopNt Bind(RenderPort port)
internal sealed class ProtocolSplashDesktopNt : ProtocolInstance
{
Debug2.Validate(port != null, typeof (ArgumentNullException), nameof (port));
ProtocolInstance protocolInstance = port.LookUpProtocol("Splash::Desktop::Nt");
if (protocolInstance != null)
{
ProtocolSplashDesktopNt protocolSplashDesktopNt = protocolInstance as ProtocolSplashDesktopNt;
Debug2.Validate(protocolSplashDesktopNt != null, typeof (InvalidOperationException), "protocol name collision");
return protocolSplashDesktopNt;
}
ProtocolSplashDesktopNt protocolSplashDesktopNt1 = new ProtocolSplashDesktopNt(port);
port.BindProtocol((ProtocolInstance) protocolSplashDesktopNt1);
return protocolSplashDesktopNt1;
private RENDERHANDLE _priv_remoteClass_FormWindow;
private RENDERHANDLE _priv_remoteClass_HwndHostWindow;
private RENDERHANDLE _priv_remoteClass_DesktopManager;
private RENDERHANDLE _priv_callbackInstance_HwndHostWindowCallback;
private RENDERHANDLE _priv_callbackInstance_DesktopManagerCallback;
public static ProtocolSplashDesktopNt Bind(RenderPort port)
{
Debug2.Validate(port != null, typeof(ArgumentNullException), nameof(port));
ProtocolInstance protocolInstance = port.LookUpProtocol("Splash::Desktop::Nt");
if (protocolInstance != null)
{
ProtocolSplashDesktopNt protocolSplashDesktopNt = protocolInstance as ProtocolSplashDesktopNt;
Debug2.Validate(protocolSplashDesktopNt != null, typeof(InvalidOperationException), "protocol name collision");
return protocolSplashDesktopNt;
}
ProtocolSplashDesktopNt protocolSplashDesktopNt1 = new ProtocolSplashDesktopNt(port);
port.BindProtocol((ProtocolInstance)protocolSplashDesktopNt1);
return protocolSplashDesktopNt1;
}
public LocalHwndHostWindowCallback LocalHwndHostWindowCallbackHandle => LocalHwndHostWindowCallback.CreateCallbackImpl(this.Port, this._priv_callbackInstance_HwndHostWindowCallback);
public LocalDesktopManagerCallback LocalDesktopManagerCallbackHandle => LocalDesktopManagerCallback.CreateCallbackImpl(this.Port, this._priv_callbackInstance_DesktopManagerCallback);
private ProtocolSplashDesktopNt(RenderPort port)
: base(port, "Splash::Desktop::Nt")
{
}
protected override void Init()
{
RenderPort port = this.Port;
this._priv_remoteClass_FormWindow = port.InitRemoteClass("Splash::Desktop::Nt::FormWindow");
this._priv_remoteClass_HwndHostWindow = port.InitRemoteClass("Splash::Desktop::Nt::HwndHostWindow");
this._priv_remoteClass_DesktopManager = port.InitRemoteClass("Splash::Desktop::Nt::DesktopManager");
this._priv_callbackInstance_HwndHostWindowCallback = LocalHwndHostWindowCallback.BindCallback(port);
this._priv_callbackInstance_DesktopManagerCallback = LocalDesktopManagerCallback.BindCallback(port);
}
internal RENDERHANDLE FormWindow_ClassHandle => this._priv_remoteClass_FormWindow;
internal RENDERHANDLE HwndHostWindow_ClassHandle => this._priv_remoteClass_HwndHostWindow;
internal RENDERHANDLE DesktopManager_ClassHandle => this._priv_remoteClass_DesktopManager;
internal RENDERHANDLE HwndHostWindowCallback_CallbackInstance => this._priv_callbackInstance_HwndHostWindowCallback;
internal RENDERHANDLE DesktopManagerCallback_CallbackInstance => this._priv_callbackInstance_DesktopManagerCallback;
internal RemoteFormWindow BuildRemoteFormWindow(
IRenderHandleOwner _priv_owner,
RemoteDesktopManager manager,
LocalFormWindowCallback cb)
{
return RemoteFormWindow.Create(this, _priv_owner, manager, cb);
}
internal RemoteHwndHostWindow BuildRemoteHwndHostWindow(
IRenderHandleOwner _priv_owner,
RemoteFormWindow winParent,
LocalHwndHostWindowCallback cb)
{
return RemoteHwndHostWindow.Create(this, _priv_owner, winParent, cb);
}
internal RemoteDesktopManager BuildRemoteDesktopManager(
IRenderHandleOwner _priv_owner,
LocalDesktopManagerCallback cb,
bool fEnumDisplayModes)
{
return RemoteDesktopManager.Create(this, _priv_owner, cb, fEnumDisplayModes);
}
}
public LocalHwndHostWindowCallback LocalHwndHostWindowCallbackHandle => LocalHwndHostWindowCallback.CreateCallbackImpl(this.Port, this._priv_callbackInstance_HwndHostWindowCallback);
public LocalDesktopManagerCallback LocalDesktopManagerCallbackHandle => LocalDesktopManagerCallback.CreateCallbackImpl(this.Port, this._priv_callbackInstance_DesktopManagerCallback);
private ProtocolSplashDesktopNt(RenderPort port)
: base(port, "Splash::Desktop::Nt")
{
}
protected override void Init()
{
RenderPort port = this.Port;
this._priv_remoteClass_FormWindow = port.InitRemoteClass("Splash::Desktop::Nt::FormWindow");
this._priv_remoteClass_HwndHostWindow = port.InitRemoteClass("Splash::Desktop::Nt::HwndHostWindow");
this._priv_remoteClass_DesktopManager = port.InitRemoteClass("Splash::Desktop::Nt::DesktopManager");
this._priv_callbackInstance_HwndHostWindowCallback = LocalHwndHostWindowCallback.BindCallback(port);
this._priv_callbackInstance_DesktopManagerCallback = LocalDesktopManagerCallback.BindCallback(port);
}
internal RENDERHANDLE FormWindow_ClassHandle => this._priv_remoteClass_FormWindow;
internal RENDERHANDLE HwndHostWindow_ClassHandle => this._priv_remoteClass_HwndHostWindow;
internal RENDERHANDLE DesktopManager_ClassHandle => this._priv_remoteClass_DesktopManager;
internal RENDERHANDLE HwndHostWindowCallback_CallbackInstance => this._priv_callbackInstance_HwndHostWindowCallback;
internal RENDERHANDLE DesktopManagerCallback_CallbackInstance => this._priv_callbackInstance_DesktopManagerCallback;
internal RemoteFormWindow BuildRemoteFormWindow(
IRenderHandleOwner _priv_owner,
RemoteDesktopManager manager,
LocalFormWindowCallback cb)
{
return RemoteFormWindow.Create(this, _priv_owner, manager, cb);
}
internal RemoteHwndHostWindow BuildRemoteHwndHostWindow(
IRenderHandleOwner _priv_owner,
RemoteFormWindow winParent,
LocalHwndHostWindowCallback cb)
{
return RemoteHwndHostWindow.Create(this, _priv_owner, winParent, cb);
}
internal RemoteDesktopManager BuildRemoteDesktopManager(
IRenderHandleOwner _priv_owner,
LocalDesktopManagerCallback cb,
bool fEnumDisplayModes)
{
return RemoteDesktopManager.Create(this, _priv_owner, cb, fEnumDisplayModes);
}
}
}
@@ -11,158 +11,158 @@ using System.Runtime.InteropServices;
namespace Microsoft.Iris.Render.Protocols.Splash.Desktop.Nt
{
internal class RemoteDesktopManager : RemoteObject
{
private static ushort[] s_priv_ByteOrder_Msg2_Create;
private static ushort[] s_priv_ByteOrder_Msg0_RebuildMonitorCache;
private static ushort[] s_priv_ByteOrder_Msg1_ChangeFullScreenMode;
protected RemoteDesktopManager()
internal class RemoteDesktopManager : RemoteObject
{
private static ushort[] s_priv_ByteOrder_Msg2_Create;
private static ushort[] s_priv_ByteOrder_Msg0_RebuildMonitorCache;
private static ushort[] s_priv_ByteOrder_Msg1_ChangeFullScreenMode;
protected RemoteDesktopManager()
{
}
public static unsafe RemoteDesktopManager Create(
ProtocolSplashDesktopNt _priv_protocolInstance,
IRenderHandleOwner _priv_owner,
LocalDesktopManagerCallback cb,
bool fEnumDisplayModes)
{
RenderPort port = _priv_protocolInstance.Port;
RENDERHANDLE managerClassHandle = _priv_protocolInstance.DesktopManager_ClassHandle;
RemoteDesktopManager remoteDesktopManager = new RemoteDesktopManager(port, _priv_owner);
uint num = (uint)sizeof(RemoteDesktopManager.Msg2_Create);
// ISSUE: untyped stack allocation
byte* pMem = (byte*)__untypedstackalloc(1 * (int)num);
RemoteDesktopManager.Msg2_Create* msg2CreatePtr = (RemoteDesktopManager.Msg2_Create*)pMem;
msg2CreatePtr->_priv_size = num;
msg2CreatePtr->_priv_msgid = 2U;
msg2CreatePtr->_priv_objcb = cb.RenderHandle;
msg2CreatePtr->_priv_ctxcb = port.Session.LocalContext;
msg2CreatePtr->fEnumDisplayModes = fEnumDisplayModes ? uint.MaxValue : 0U;
msg2CreatePtr->_priv_idObjectSubject = remoteDesktopManager.m_renderHandle;
if (port.ForeignByteOrder)
MarshalHelper.SwapByteOrder(pMem, ref RemoteDesktopManager.s_priv_ByteOrder_Msg2_Create, typeof(RemoteDesktopManager.Msg2_Create), 0, 0);
port.CreateRemoteObject(managerClassHandle, remoteDesktopManager.m_renderHandle, (Message*)msg2CreatePtr);
return remoteDesktopManager;
}
public unsafe void BuildRebuildMonitorCache(
out RenderPort _priv_portUse,
out Message* _priv_pmsgUse)
{
Debug2.Throw(this.IsValid, "Non-static method call requires an instance");
_priv_portUse = this.m_renderPort;
_priv_portUse.ValidateHandle(this.m_renderHandle);
uint size = (uint)sizeof(RemoteDesktopManager.Msg0_RebuildMonitorCache);
RemoteDesktopManager.Msg0_RebuildMonitorCache* rebuildMonitorCachePtr = (RemoteDesktopManager.Msg0_RebuildMonitorCache*)_priv_portUse.AllocMessageBuffer(size);
rebuildMonitorCachePtr->_priv_size = size;
rebuildMonitorCachePtr->_priv_msgid = 0U;
rebuildMonitorCachePtr->_priv_idObjectSubject = this.m_renderHandle;
if (_priv_portUse.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*)rebuildMonitorCachePtr, ref RemoteDesktopManager.s_priv_ByteOrder_Msg0_RebuildMonitorCache, typeof(RemoteDesktopManager.Msg0_RebuildMonitorCache), 0, 0);
_priv_pmsgUse = (Message*)rebuildMonitorCachePtr;
}
public unsafe void SendRebuildMonitorCache()
{
RenderPort _priv_portUse;
Message* _priv_pmsgUse;
this.BuildRebuildMonitorCache(out _priv_portUse, out _priv_pmsgUse);
_priv_portUse.SendRemoteMessage(_priv_pmsgUse);
}
public unsafe void BuildChangeFullScreenMode(
out RenderPort _priv_portUse,
out Message* _priv_pmsgUse,
uint idDisplay,
RenderDisplayMode mode,
bool fTvMode)
{
Debug2.Throw(this.IsValid, "Non-static method call requires an instance");
_priv_portUse = this.m_renderPort;
_priv_portUse.ValidateHandle(this.m_renderHandle);
uint size = (uint)sizeof(RemoteDesktopManager.Msg1_ChangeFullScreenMode);
RemoteDesktopManager.Msg1_ChangeFullScreenMode* changeFullScreenModePtr = (RemoteDesktopManager.Msg1_ChangeFullScreenMode*)_priv_portUse.AllocMessageBuffer(size);
changeFullScreenModePtr->_priv_size = size;
changeFullScreenModePtr->_priv_msgid = 1U;
changeFullScreenModePtr->idDisplay = idDisplay;
changeFullScreenModePtr->mode = mode;
changeFullScreenModePtr->fTvMode = fTvMode ? uint.MaxValue : 0U;
changeFullScreenModePtr->_priv_idObjectSubject = this.m_renderHandle;
if (_priv_portUse.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*)changeFullScreenModePtr, ref RemoteDesktopManager.s_priv_ByteOrder_Msg1_ChangeFullScreenMode, typeof(RemoteDesktopManager.Msg1_ChangeFullScreenMode), 0, 0);
_priv_pmsgUse = (Message*)changeFullScreenModePtr;
}
public unsafe void SendChangeFullScreenMode(
uint idDisplay,
RenderDisplayMode mode,
bool fTvMode)
{
RenderPort _priv_portUse;
Message* _priv_pmsgUse;
this.BuildChangeFullScreenMode(out _priv_portUse, out _priv_pmsgUse, idDisplay, mode, fTvMode);
_priv_portUse.SendRemoteMessage(_priv_pmsgUse);
}
public static RemoteDesktopManager CreateFromHandle(
RenderPort port,
RENDERHANDLE handle)
{
return new RemoteDesktopManager(port, handle, true);
}
public static RemoteDesktopManager CreateFromExternalHandle(
RenderPort port,
RENDERHANDLE handle,
IRenderHandleOwner owner)
{
port.RegisterKnownHandle(owner, handle);
return new RemoteDesktopManager(port, handle, false);
}
protected RemoteDesktopManager(RenderPort port, RENDERHANDLE handle, bool fFreeOnDispose)
: base(port, handle, fFreeOnDispose)
{
}
protected RemoteDesktopManager(RenderPort port, IRenderHandleOwner owner)
: base(port, owner)
{
}
public override bool Equals(object other) => other is RemoteDesktopManager && this.m_renderHandle == ((RemoteObject)other).m_renderHandle;
public override int GetHashCode() => base.GetHashCode();
[ComVisible(false)]
private struct Msg2_Create
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE _priv_objcb;
public ContextID _priv_ctxcb;
public uint fEnumDisplayModes;
}
[ComVisible(false)]
private struct Msg0_RebuildMonitorCache
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
}
[ComVisible(false)]
private struct Msg1_ChangeFullScreenMode
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public uint idDisplay;
public RenderDisplayMode mode;
public uint fTvMode;
}
}
public static unsafe RemoteDesktopManager Create(
ProtocolSplashDesktopNt _priv_protocolInstance,
IRenderHandleOwner _priv_owner,
LocalDesktopManagerCallback cb,
bool fEnumDisplayModes)
{
RenderPort port = _priv_protocolInstance.Port;
RENDERHANDLE managerClassHandle = _priv_protocolInstance.DesktopManager_ClassHandle;
RemoteDesktopManager remoteDesktopManager = new RemoteDesktopManager(port, _priv_owner);
uint num = (uint) sizeof (RemoteDesktopManager.Msg2_Create);
// ISSUE: untyped stack allocation
byte* pMem = (byte*) __untypedstackalloc(1 * (int) num);
RemoteDesktopManager.Msg2_Create* msg2CreatePtr = (RemoteDesktopManager.Msg2_Create*) pMem;
msg2CreatePtr->_priv_size = num;
msg2CreatePtr->_priv_msgid = 2U;
msg2CreatePtr->_priv_objcb = cb.RenderHandle;
msg2CreatePtr->_priv_ctxcb = port.Session.LocalContext;
msg2CreatePtr->fEnumDisplayModes = fEnumDisplayModes ? uint.MaxValue : 0U;
msg2CreatePtr->_priv_idObjectSubject = remoteDesktopManager.m_renderHandle;
if (port.ForeignByteOrder)
MarshalHelper.SwapByteOrder(pMem, ref RemoteDesktopManager.s_priv_ByteOrder_Msg2_Create, typeof (RemoteDesktopManager.Msg2_Create), 0, 0);
port.CreateRemoteObject(managerClassHandle, remoteDesktopManager.m_renderHandle, (Message*) msg2CreatePtr);
return remoteDesktopManager;
}
public unsafe void BuildRebuildMonitorCache(
out RenderPort _priv_portUse,
out Message* _priv_pmsgUse)
{
Debug2.Throw(this.IsValid, "Non-static method call requires an instance");
_priv_portUse = this.m_renderPort;
_priv_portUse.ValidateHandle(this.m_renderHandle);
uint size = (uint) sizeof (RemoteDesktopManager.Msg0_RebuildMonitorCache);
RemoteDesktopManager.Msg0_RebuildMonitorCache* rebuildMonitorCachePtr = (RemoteDesktopManager.Msg0_RebuildMonitorCache*) _priv_portUse.AllocMessageBuffer(size);
rebuildMonitorCachePtr->_priv_size = size;
rebuildMonitorCachePtr->_priv_msgid = 0U;
rebuildMonitorCachePtr->_priv_idObjectSubject = this.m_renderHandle;
if (_priv_portUse.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*) rebuildMonitorCachePtr, ref RemoteDesktopManager.s_priv_ByteOrder_Msg0_RebuildMonitorCache, typeof (RemoteDesktopManager.Msg0_RebuildMonitorCache), 0, 0);
_priv_pmsgUse = (Message*) rebuildMonitorCachePtr;
}
public unsafe void SendRebuildMonitorCache()
{
RenderPort _priv_portUse;
Message* _priv_pmsgUse;
this.BuildRebuildMonitorCache(out _priv_portUse, out _priv_pmsgUse);
_priv_portUse.SendRemoteMessage(_priv_pmsgUse);
}
public unsafe void BuildChangeFullScreenMode(
out RenderPort _priv_portUse,
out Message* _priv_pmsgUse,
uint idDisplay,
RenderDisplayMode mode,
bool fTvMode)
{
Debug2.Throw(this.IsValid, "Non-static method call requires an instance");
_priv_portUse = this.m_renderPort;
_priv_portUse.ValidateHandle(this.m_renderHandle);
uint size = (uint) sizeof (RemoteDesktopManager.Msg1_ChangeFullScreenMode);
RemoteDesktopManager.Msg1_ChangeFullScreenMode* changeFullScreenModePtr = (RemoteDesktopManager.Msg1_ChangeFullScreenMode*) _priv_portUse.AllocMessageBuffer(size);
changeFullScreenModePtr->_priv_size = size;
changeFullScreenModePtr->_priv_msgid = 1U;
changeFullScreenModePtr->idDisplay = idDisplay;
changeFullScreenModePtr->mode = mode;
changeFullScreenModePtr->fTvMode = fTvMode ? uint.MaxValue : 0U;
changeFullScreenModePtr->_priv_idObjectSubject = this.m_renderHandle;
if (_priv_portUse.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*) changeFullScreenModePtr, ref RemoteDesktopManager.s_priv_ByteOrder_Msg1_ChangeFullScreenMode, typeof (RemoteDesktopManager.Msg1_ChangeFullScreenMode), 0, 0);
_priv_pmsgUse = (Message*) changeFullScreenModePtr;
}
public unsafe void SendChangeFullScreenMode(
uint idDisplay,
RenderDisplayMode mode,
bool fTvMode)
{
RenderPort _priv_portUse;
Message* _priv_pmsgUse;
this.BuildChangeFullScreenMode(out _priv_portUse, out _priv_pmsgUse, idDisplay, mode, fTvMode);
_priv_portUse.SendRemoteMessage(_priv_pmsgUse);
}
public static RemoteDesktopManager CreateFromHandle(
RenderPort port,
RENDERHANDLE handle)
{
return new RemoteDesktopManager(port, handle, true);
}
public static RemoteDesktopManager CreateFromExternalHandle(
RenderPort port,
RENDERHANDLE handle,
IRenderHandleOwner owner)
{
port.RegisterKnownHandle(owner, handle);
return new RemoteDesktopManager(port, handle, false);
}
protected RemoteDesktopManager(RenderPort port, RENDERHANDLE handle, bool fFreeOnDispose)
: base(port, handle, fFreeOnDispose)
{
}
protected RemoteDesktopManager(RenderPort port, IRenderHandleOwner owner)
: base(port, owner)
{
}
public override bool Equals(object other) => other is RemoteDesktopManager && this.m_renderHandle == ((RemoteObject) other).m_renderHandle;
public override int GetHashCode() => base.GetHashCode();
[ComVisible(false)]
private struct Msg2_Create
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE _priv_objcb;
public ContextID _priv_ctxcb;
public uint fEnumDisplayModes;
}
[ComVisible(false)]
private struct Msg0_RebuildMonitorCache
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
}
[ComVisible(false)]
private struct Msg1_ChangeFullScreenMode
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public uint idDisplay;
public RenderDisplayMode mode;
public uint fTvMode;
}
}
}
@@ -9,78 +9,78 @@ using System.Runtime.InteropServices;
namespace Microsoft.Iris.Render.Protocols.Splash.Desktop.Nt
{
internal class RemoteFormWindow : RemoteFormWindowBase
{
private static ushort[] s_priv_ByteOrder_Msg41_Create;
protected RemoteFormWindow()
internal class RemoteFormWindow : RemoteFormWindowBase
{
private static ushort[] s_priv_ByteOrder_Msg41_Create;
protected RemoteFormWindow()
{
}
public static unsafe RemoteFormWindow Create(
ProtocolSplashDesktopNt _priv_protocolInstance,
IRenderHandleOwner _priv_owner,
RemoteDesktopManager manager,
LocalFormWindowCallback cb)
{
RenderPort port = _priv_protocolInstance.Port;
RENDERHANDLE windowClassHandle = _priv_protocolInstance.FormWindow_ClassHandle;
RemoteFormWindow remoteFormWindow = new RemoteFormWindow(port, _priv_owner);
uint num = (uint)sizeof(RemoteFormWindow.Msg41_Create);
// ISSUE: untyped stack allocation
byte* pMem = (byte*)__untypedstackalloc(1 * (int)num);
RemoteFormWindow.Msg41_Create* msg41CreatePtr = (RemoteFormWindow.Msg41_Create*)pMem;
msg41CreatePtr->_priv_size = num;
msg41CreatePtr->_priv_msgid = 41U;
msg41CreatePtr->manager = manager != null ? manager.RenderHandle : RENDERHANDLE.NULL;
msg41CreatePtr->_priv_objcb = cb.RenderHandle;
msg41CreatePtr->_priv_ctxcb = port.Session.LocalContext;
msg41CreatePtr->_priv_idObjectSubject = remoteFormWindow.m_renderHandle;
if (port.ForeignByteOrder)
MarshalHelper.SwapByteOrder(pMem, ref RemoteFormWindow.s_priv_ByteOrder_Msg41_Create, typeof(RemoteFormWindow.Msg41_Create), 0, 0);
port.CreateRemoteObject(windowClassHandle, remoteFormWindow.m_renderHandle, (Message*)msg41CreatePtr);
return remoteFormWindow;
}
public static RemoteFormWindow CreateFromHandle(
RenderPort port,
RENDERHANDLE handle)
{
return new RemoteFormWindow(port, handle, true);
}
public static RemoteFormWindow CreateFromExternalHandle(
RenderPort port,
RENDERHANDLE handle,
IRenderHandleOwner owner)
{
port.RegisterKnownHandle(owner, handle);
return new RemoteFormWindow(port, handle, false);
}
protected RemoteFormWindow(RenderPort port, RENDERHANDLE handle, bool fFreeOnDispose)
: base(port, handle, fFreeOnDispose)
{
}
protected RemoteFormWindow(RenderPort port, IRenderHandleOwner owner)
: base(port, owner)
{
}
public override bool Equals(object other) => other is RemoteFormWindow && this.m_renderHandle == ((RemoteObject)other).m_renderHandle;
public override int GetHashCode() => base.GetHashCode();
[ComVisible(false)]
private struct Msg41_Create
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE manager;
public RENDERHANDLE _priv_objcb;
public ContextID _priv_ctxcb;
}
}
public static unsafe RemoteFormWindow Create(
ProtocolSplashDesktopNt _priv_protocolInstance,
IRenderHandleOwner _priv_owner,
RemoteDesktopManager manager,
LocalFormWindowCallback cb)
{
RenderPort port = _priv_protocolInstance.Port;
RENDERHANDLE windowClassHandle = _priv_protocolInstance.FormWindow_ClassHandle;
RemoteFormWindow remoteFormWindow = new RemoteFormWindow(port, _priv_owner);
uint num = (uint) sizeof (RemoteFormWindow.Msg41_Create);
// ISSUE: untyped stack allocation
byte* pMem = (byte*) __untypedstackalloc(1 * (int) num);
RemoteFormWindow.Msg41_Create* msg41CreatePtr = (RemoteFormWindow.Msg41_Create*) pMem;
msg41CreatePtr->_priv_size = num;
msg41CreatePtr->_priv_msgid = 41U;
msg41CreatePtr->manager = manager != null ? manager.RenderHandle : RENDERHANDLE.NULL;
msg41CreatePtr->_priv_objcb = cb.RenderHandle;
msg41CreatePtr->_priv_ctxcb = port.Session.LocalContext;
msg41CreatePtr->_priv_idObjectSubject = remoteFormWindow.m_renderHandle;
if (port.ForeignByteOrder)
MarshalHelper.SwapByteOrder(pMem, ref RemoteFormWindow.s_priv_ByteOrder_Msg41_Create, typeof (RemoteFormWindow.Msg41_Create), 0, 0);
port.CreateRemoteObject(windowClassHandle, remoteFormWindow.m_renderHandle, (Message*) msg41CreatePtr);
return remoteFormWindow;
}
public static RemoteFormWindow CreateFromHandle(
RenderPort port,
RENDERHANDLE handle)
{
return new RemoteFormWindow(port, handle, true);
}
public static RemoteFormWindow CreateFromExternalHandle(
RenderPort port,
RENDERHANDLE handle,
IRenderHandleOwner owner)
{
port.RegisterKnownHandle(owner, handle);
return new RemoteFormWindow(port, handle, false);
}
protected RemoteFormWindow(RenderPort port, RENDERHANDLE handle, bool fFreeOnDispose)
: base(port, handle, fFreeOnDispose)
{
}
protected RemoteFormWindow(RenderPort port, IRenderHandleOwner owner)
: base(port, owner)
{
}
public override bool Equals(object other) => other is RemoteFormWindow && this.m_renderHandle == ((RemoteObject) other).m_renderHandle;
public override int GetHashCode() => base.GetHashCode();
[ComVisible(false)]
private struct Msg41_Create
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE manager;
public RENDERHANDLE _priv_objcb;
public ContextID _priv_ctxcb;
}
}
}
@@ -10,226 +10,226 @@ using System.Runtime.InteropServices;
namespace Microsoft.Iris.Render.Protocols.Splash.Desktop.Nt
{
internal class RemoteHwndHostWindow : RemoteObject
{
private static ushort[] s_priv_ByteOrder_Msg4_Create;
private static ushort[] s_priv_ByteOrder_Msg0_SetVisible;
private static ushort[] s_priv_ByteOrder_Msg1_SetSize;
private static ushort[] s_priv_ByteOrder_Msg2_SetPosition;
private static ushort[] s_priv_ByteOrder_Msg3_SetBackgroundColor;
protected RemoteHwndHostWindow()
internal class RemoteHwndHostWindow : RemoteObject
{
private static ushort[] s_priv_ByteOrder_Msg4_Create;
private static ushort[] s_priv_ByteOrder_Msg0_SetVisible;
private static ushort[] s_priv_ByteOrder_Msg1_SetSize;
private static ushort[] s_priv_ByteOrder_Msg2_SetPosition;
private static ushort[] s_priv_ByteOrder_Msg3_SetBackgroundColor;
protected RemoteHwndHostWindow()
{
}
public static unsafe RemoteHwndHostWindow Create(
ProtocolSplashDesktopNt _priv_protocolInstance,
IRenderHandleOwner _priv_owner,
RemoteFormWindow winParent,
LocalHwndHostWindowCallback cb)
{
RenderPort port = _priv_protocolInstance.Port;
RENDERHANDLE windowClassHandle = _priv_protocolInstance.HwndHostWindow_ClassHandle;
RemoteHwndHostWindow remoteHwndHostWindow = new RemoteHwndHostWindow(port, _priv_owner);
uint num = (uint)sizeof(RemoteHwndHostWindow.Msg4_Create);
// ISSUE: untyped stack allocation
byte* pMem = (byte*)__untypedstackalloc(1 * (int)num);
RemoteHwndHostWindow.Msg4_Create* msg4CreatePtr = (RemoteHwndHostWindow.Msg4_Create*)pMem;
msg4CreatePtr->_priv_size = num;
msg4CreatePtr->_priv_msgid = 4U;
msg4CreatePtr->winParent = winParent != null ? winParent.RenderHandle : RENDERHANDLE.NULL;
msg4CreatePtr->_priv_objcb = cb.RenderHandle;
msg4CreatePtr->_priv_ctxcb = port.Session.LocalContext;
msg4CreatePtr->_priv_idObjectSubject = remoteHwndHostWindow.m_renderHandle;
if (port.ForeignByteOrder)
MarshalHelper.SwapByteOrder(pMem, ref RemoteHwndHostWindow.s_priv_ByteOrder_Msg4_Create, typeof(RemoteHwndHostWindow.Msg4_Create), 0, 0);
port.CreateRemoteObject(windowClassHandle, remoteHwndHostWindow.m_renderHandle, (Message*)msg4CreatePtr);
return remoteHwndHostWindow;
}
public unsafe void BuildSetVisible(
out RenderPort _priv_portUse,
out Message* _priv_pmsgUse,
bool fVisible)
{
Debug2.Throw(this.IsValid, "Non-static method call requires an instance");
_priv_portUse = this.m_renderPort;
_priv_portUse.ValidateHandle(this.m_renderHandle);
uint size = (uint)sizeof(RemoteHwndHostWindow.Msg0_SetVisible);
RemoteHwndHostWindow.Msg0_SetVisible* msg0SetVisiblePtr = (RemoteHwndHostWindow.Msg0_SetVisible*)_priv_portUse.AllocMessageBuffer(size);
msg0SetVisiblePtr->_priv_size = size;
msg0SetVisiblePtr->_priv_msgid = 0U;
msg0SetVisiblePtr->fVisible = fVisible ? uint.MaxValue : 0U;
msg0SetVisiblePtr->_priv_idObjectSubject = this.m_renderHandle;
if (_priv_portUse.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*)msg0SetVisiblePtr, ref RemoteHwndHostWindow.s_priv_ByteOrder_Msg0_SetVisible, typeof(RemoteHwndHostWindow.Msg0_SetVisible), 0, 0);
_priv_pmsgUse = (Message*)msg0SetVisiblePtr;
}
public unsafe void SendSetVisible(bool fVisible)
{
RenderPort _priv_portUse;
Message* _priv_pmsgUse;
this.BuildSetVisible(out _priv_portUse, out _priv_pmsgUse, fVisible);
_priv_portUse.SendRemoteMessage(_priv_pmsgUse);
}
public unsafe void BuildSetSize(
out RenderPort _priv_portUse,
out Message* _priv_pmsgUse,
Size sizeWindowPxl)
{
Debug2.Throw(this.IsValid, "Non-static method call requires an instance");
_priv_portUse = this.m_renderPort;
_priv_portUse.ValidateHandle(this.m_renderHandle);
uint size = (uint)sizeof(RemoteHwndHostWindow.Msg1_SetSize);
RemoteHwndHostWindow.Msg1_SetSize* msg1SetSizePtr = (RemoteHwndHostWindow.Msg1_SetSize*)_priv_portUse.AllocMessageBuffer(size);
msg1SetSizePtr->_priv_size = size;
msg1SetSizePtr->_priv_msgid = 1U;
msg1SetSizePtr->sizeWindowPxl = sizeWindowPxl;
msg1SetSizePtr->_priv_idObjectSubject = this.m_renderHandle;
if (_priv_portUse.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*)msg1SetSizePtr, ref RemoteHwndHostWindow.s_priv_ByteOrder_Msg1_SetSize, typeof(RemoteHwndHostWindow.Msg1_SetSize), 0, 0);
_priv_pmsgUse = (Message*)msg1SetSizePtr;
}
public unsafe void SendSetSize(Size sizeWindowPxl)
{
RenderPort _priv_portUse;
Message* _priv_pmsgUse;
this.BuildSetSize(out _priv_portUse, out _priv_pmsgUse, sizeWindowPxl);
_priv_portUse.SendRemoteMessage(_priv_pmsgUse);
}
public unsafe void BuildSetPosition(
out RenderPort _priv_portUse,
out Message* _priv_pmsgUse,
Point ptClientPxl)
{
Debug2.Throw(this.IsValid, "Non-static method call requires an instance");
_priv_portUse = this.m_renderPort;
_priv_portUse.ValidateHandle(this.m_renderHandle);
uint size = (uint)sizeof(RemoteHwndHostWindow.Msg2_SetPosition);
RemoteHwndHostWindow.Msg2_SetPosition* msg2SetPositionPtr = (RemoteHwndHostWindow.Msg2_SetPosition*)_priv_portUse.AllocMessageBuffer(size);
msg2SetPositionPtr->_priv_size = size;
msg2SetPositionPtr->_priv_msgid = 2U;
msg2SetPositionPtr->ptClientPxl = ptClientPxl;
msg2SetPositionPtr->_priv_idObjectSubject = this.m_renderHandle;
if (_priv_portUse.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*)msg2SetPositionPtr, ref RemoteHwndHostWindow.s_priv_ByteOrder_Msg2_SetPosition, typeof(RemoteHwndHostWindow.Msg2_SetPosition), 0, 0);
_priv_pmsgUse = (Message*)msg2SetPositionPtr;
}
public unsafe void SendSetPosition(Point ptClientPxl)
{
RenderPort _priv_portUse;
Message* _priv_pmsgUse;
this.BuildSetPosition(out _priv_portUse, out _priv_pmsgUse, ptClientPxl);
_priv_portUse.SendRemoteMessage(_priv_pmsgUse);
}
public unsafe void BuildSetBackgroundColor(
out RenderPort _priv_portUse,
out Message* _priv_pmsgUse,
ColorF clrBackground)
{
Debug2.Throw(this.IsValid, "Non-static method call requires an instance");
_priv_portUse = this.m_renderPort;
_priv_portUse.ValidateHandle(this.m_renderHandle);
uint size = (uint)sizeof(RemoteHwndHostWindow.Msg3_SetBackgroundColor);
RemoteHwndHostWindow.Msg3_SetBackgroundColor* setBackgroundColorPtr = (RemoteHwndHostWindow.Msg3_SetBackgroundColor*)_priv_portUse.AllocMessageBuffer(size);
setBackgroundColorPtr->_priv_size = size;
setBackgroundColorPtr->_priv_msgid = 3U;
setBackgroundColorPtr->clrBackground = clrBackground;
setBackgroundColorPtr->_priv_idObjectSubject = this.m_renderHandle;
if (_priv_portUse.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*)setBackgroundColorPtr, ref RemoteHwndHostWindow.s_priv_ByteOrder_Msg3_SetBackgroundColor, typeof(RemoteHwndHostWindow.Msg3_SetBackgroundColor), 0, 0);
_priv_pmsgUse = (Message*)setBackgroundColorPtr;
}
public unsafe void SendSetBackgroundColor(ColorF clrBackground)
{
RenderPort _priv_portUse;
Message* _priv_pmsgUse;
this.BuildSetBackgroundColor(out _priv_portUse, out _priv_pmsgUse, clrBackground);
_priv_portUse.SendRemoteMessage(_priv_pmsgUse);
}
public static RemoteHwndHostWindow CreateFromHandle(
RenderPort port,
RENDERHANDLE handle)
{
return new RemoteHwndHostWindow(port, handle, true);
}
public static RemoteHwndHostWindow CreateFromExternalHandle(
RenderPort port,
RENDERHANDLE handle,
IRenderHandleOwner owner)
{
port.RegisterKnownHandle(owner, handle);
return new RemoteHwndHostWindow(port, handle, false);
}
protected RemoteHwndHostWindow(RenderPort port, RENDERHANDLE handle, bool fFreeOnDispose)
: base(port, handle, fFreeOnDispose)
{
}
protected RemoteHwndHostWindow(RenderPort port, IRenderHandleOwner owner)
: base(port, owner)
{
}
public override bool Equals(object other) => other is RemoteHwndHostWindow && this.m_renderHandle == ((RemoteObject)other).m_renderHandle;
public override int GetHashCode() => base.GetHashCode();
[ComVisible(false)]
private struct Msg4_Create
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE winParent;
public RENDERHANDLE _priv_objcb;
public ContextID _priv_ctxcb;
}
[ComVisible(false)]
private struct Msg0_SetVisible
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public uint fVisible;
}
[ComVisible(false)]
private struct Msg1_SetSize
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public Size sizeWindowPxl;
}
[ComVisible(false)]
private struct Msg2_SetPosition
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public Point ptClientPxl;
}
[ComVisible(false)]
private struct Msg3_SetBackgroundColor
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public ColorF clrBackground;
}
}
public static unsafe RemoteHwndHostWindow Create(
ProtocolSplashDesktopNt _priv_protocolInstance,
IRenderHandleOwner _priv_owner,
RemoteFormWindow winParent,
LocalHwndHostWindowCallback cb)
{
RenderPort port = _priv_protocolInstance.Port;
RENDERHANDLE windowClassHandle = _priv_protocolInstance.HwndHostWindow_ClassHandle;
RemoteHwndHostWindow remoteHwndHostWindow = new RemoteHwndHostWindow(port, _priv_owner);
uint num = (uint) sizeof (RemoteHwndHostWindow.Msg4_Create);
// ISSUE: untyped stack allocation
byte* pMem = (byte*) __untypedstackalloc(1 * (int) num);
RemoteHwndHostWindow.Msg4_Create* msg4CreatePtr = (RemoteHwndHostWindow.Msg4_Create*) pMem;
msg4CreatePtr->_priv_size = num;
msg4CreatePtr->_priv_msgid = 4U;
msg4CreatePtr->winParent = winParent != null ? winParent.RenderHandle : RENDERHANDLE.NULL;
msg4CreatePtr->_priv_objcb = cb.RenderHandle;
msg4CreatePtr->_priv_ctxcb = port.Session.LocalContext;
msg4CreatePtr->_priv_idObjectSubject = remoteHwndHostWindow.m_renderHandle;
if (port.ForeignByteOrder)
MarshalHelper.SwapByteOrder(pMem, ref RemoteHwndHostWindow.s_priv_ByteOrder_Msg4_Create, typeof (RemoteHwndHostWindow.Msg4_Create), 0, 0);
port.CreateRemoteObject(windowClassHandle, remoteHwndHostWindow.m_renderHandle, (Message*) msg4CreatePtr);
return remoteHwndHostWindow;
}
public unsafe void BuildSetVisible(
out RenderPort _priv_portUse,
out Message* _priv_pmsgUse,
bool fVisible)
{
Debug2.Throw(this.IsValid, "Non-static method call requires an instance");
_priv_portUse = this.m_renderPort;
_priv_portUse.ValidateHandle(this.m_renderHandle);
uint size = (uint) sizeof (RemoteHwndHostWindow.Msg0_SetVisible);
RemoteHwndHostWindow.Msg0_SetVisible* msg0SetVisiblePtr = (RemoteHwndHostWindow.Msg0_SetVisible*) _priv_portUse.AllocMessageBuffer(size);
msg0SetVisiblePtr->_priv_size = size;
msg0SetVisiblePtr->_priv_msgid = 0U;
msg0SetVisiblePtr->fVisible = fVisible ? uint.MaxValue : 0U;
msg0SetVisiblePtr->_priv_idObjectSubject = this.m_renderHandle;
if (_priv_portUse.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*) msg0SetVisiblePtr, ref RemoteHwndHostWindow.s_priv_ByteOrder_Msg0_SetVisible, typeof (RemoteHwndHostWindow.Msg0_SetVisible), 0, 0);
_priv_pmsgUse = (Message*) msg0SetVisiblePtr;
}
public unsafe void SendSetVisible(bool fVisible)
{
RenderPort _priv_portUse;
Message* _priv_pmsgUse;
this.BuildSetVisible(out _priv_portUse, out _priv_pmsgUse, fVisible);
_priv_portUse.SendRemoteMessage(_priv_pmsgUse);
}
public unsafe void BuildSetSize(
out RenderPort _priv_portUse,
out Message* _priv_pmsgUse,
Size sizeWindowPxl)
{
Debug2.Throw(this.IsValid, "Non-static method call requires an instance");
_priv_portUse = this.m_renderPort;
_priv_portUse.ValidateHandle(this.m_renderHandle);
uint size = (uint) sizeof (RemoteHwndHostWindow.Msg1_SetSize);
RemoteHwndHostWindow.Msg1_SetSize* msg1SetSizePtr = (RemoteHwndHostWindow.Msg1_SetSize*) _priv_portUse.AllocMessageBuffer(size);
msg1SetSizePtr->_priv_size = size;
msg1SetSizePtr->_priv_msgid = 1U;
msg1SetSizePtr->sizeWindowPxl = sizeWindowPxl;
msg1SetSizePtr->_priv_idObjectSubject = this.m_renderHandle;
if (_priv_portUse.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*) msg1SetSizePtr, ref RemoteHwndHostWindow.s_priv_ByteOrder_Msg1_SetSize, typeof (RemoteHwndHostWindow.Msg1_SetSize), 0, 0);
_priv_pmsgUse = (Message*) msg1SetSizePtr;
}
public unsafe void SendSetSize(Size sizeWindowPxl)
{
RenderPort _priv_portUse;
Message* _priv_pmsgUse;
this.BuildSetSize(out _priv_portUse, out _priv_pmsgUse, sizeWindowPxl);
_priv_portUse.SendRemoteMessage(_priv_pmsgUse);
}
public unsafe void BuildSetPosition(
out RenderPort _priv_portUse,
out Message* _priv_pmsgUse,
Point ptClientPxl)
{
Debug2.Throw(this.IsValid, "Non-static method call requires an instance");
_priv_portUse = this.m_renderPort;
_priv_portUse.ValidateHandle(this.m_renderHandle);
uint size = (uint) sizeof (RemoteHwndHostWindow.Msg2_SetPosition);
RemoteHwndHostWindow.Msg2_SetPosition* msg2SetPositionPtr = (RemoteHwndHostWindow.Msg2_SetPosition*) _priv_portUse.AllocMessageBuffer(size);
msg2SetPositionPtr->_priv_size = size;
msg2SetPositionPtr->_priv_msgid = 2U;
msg2SetPositionPtr->ptClientPxl = ptClientPxl;
msg2SetPositionPtr->_priv_idObjectSubject = this.m_renderHandle;
if (_priv_portUse.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*) msg2SetPositionPtr, ref RemoteHwndHostWindow.s_priv_ByteOrder_Msg2_SetPosition, typeof (RemoteHwndHostWindow.Msg2_SetPosition), 0, 0);
_priv_pmsgUse = (Message*) msg2SetPositionPtr;
}
public unsafe void SendSetPosition(Point ptClientPxl)
{
RenderPort _priv_portUse;
Message* _priv_pmsgUse;
this.BuildSetPosition(out _priv_portUse, out _priv_pmsgUse, ptClientPxl);
_priv_portUse.SendRemoteMessage(_priv_pmsgUse);
}
public unsafe void BuildSetBackgroundColor(
out RenderPort _priv_portUse,
out Message* _priv_pmsgUse,
ColorF clrBackground)
{
Debug2.Throw(this.IsValid, "Non-static method call requires an instance");
_priv_portUse = this.m_renderPort;
_priv_portUse.ValidateHandle(this.m_renderHandle);
uint size = (uint) sizeof (RemoteHwndHostWindow.Msg3_SetBackgroundColor);
RemoteHwndHostWindow.Msg3_SetBackgroundColor* setBackgroundColorPtr = (RemoteHwndHostWindow.Msg3_SetBackgroundColor*) _priv_portUse.AllocMessageBuffer(size);
setBackgroundColorPtr->_priv_size = size;
setBackgroundColorPtr->_priv_msgid = 3U;
setBackgroundColorPtr->clrBackground = clrBackground;
setBackgroundColorPtr->_priv_idObjectSubject = this.m_renderHandle;
if (_priv_portUse.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*) setBackgroundColorPtr, ref RemoteHwndHostWindow.s_priv_ByteOrder_Msg3_SetBackgroundColor, typeof (RemoteHwndHostWindow.Msg3_SetBackgroundColor), 0, 0);
_priv_pmsgUse = (Message*) setBackgroundColorPtr;
}
public unsafe void SendSetBackgroundColor(ColorF clrBackground)
{
RenderPort _priv_portUse;
Message* _priv_pmsgUse;
this.BuildSetBackgroundColor(out _priv_portUse, out _priv_pmsgUse, clrBackground);
_priv_portUse.SendRemoteMessage(_priv_pmsgUse);
}
public static RemoteHwndHostWindow CreateFromHandle(
RenderPort port,
RENDERHANDLE handle)
{
return new RemoteHwndHostWindow(port, handle, true);
}
public static RemoteHwndHostWindow CreateFromExternalHandle(
RenderPort port,
RENDERHANDLE handle,
IRenderHandleOwner owner)
{
port.RegisterKnownHandle(owner, handle);
return new RemoteHwndHostWindow(port, handle, false);
}
protected RemoteHwndHostWindow(RenderPort port, RENDERHANDLE handle, bool fFreeOnDispose)
: base(port, handle, fFreeOnDispose)
{
}
protected RemoteHwndHostWindow(RenderPort port, IRenderHandleOwner owner)
: base(port, owner)
{
}
public override bool Equals(object other) => other is RemoteHwndHostWindow && this.m_renderHandle == ((RemoteObject) other).m_renderHandle;
public override int GetHashCode() => base.GetHashCode();
[ComVisible(false)]
private struct Msg4_Create
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE winParent;
public RENDERHANDLE _priv_objcb;
public ContextID _priv_ctxcb;
}
[ComVisible(false)]
private struct Msg0_SetVisible
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public uint fVisible;
}
[ComVisible(false)]
private struct Msg1_SetSize
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public Size sizeWindowPxl;
}
[ComVisible(false)]
private struct Msg2_SetPosition
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public Point ptClientPxl;
}
[ComVisible(false)]
private struct Msg3_SetBackgroundColor
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public ColorF clrBackground;
}
}
}
@@ -10,59 +10,59 @@ using System;
namespace Microsoft.Iris.Render.Protocols.Splash.Desktop
{
internal sealed class ProtocolSplashDesktop : ProtocolInstance
{
private RENDERHANDLE _priv_remoteClass_InputRouter;
private RENDERHANDLE _priv_remoteClass_FormWindowBase;
private RENDERHANDLE _priv_callbackInstance_InputCallback;
private RENDERHANDLE _priv_callbackInstance_FormWindowCallback;
public static ProtocolSplashDesktop Bind(RenderPort port)
internal sealed class ProtocolSplashDesktop : ProtocolInstance
{
Debug2.Validate(port != null, typeof (ArgumentNullException), nameof (port));
ProtocolInstance protocolInstance = port.LookUpProtocol("Splash::Desktop");
if (protocolInstance != null)
{
ProtocolSplashDesktop protocolSplashDesktop = protocolInstance as ProtocolSplashDesktop;
Debug2.Validate(protocolSplashDesktop != null, typeof (InvalidOperationException), "protocol name collision");
return protocolSplashDesktop;
}
ProtocolSplashDesktop protocolSplashDesktop1 = new ProtocolSplashDesktop(port);
port.BindProtocol((ProtocolInstance) protocolSplashDesktop1);
return protocolSplashDesktop1;
private RENDERHANDLE _priv_remoteClass_InputRouter;
private RENDERHANDLE _priv_remoteClass_FormWindowBase;
private RENDERHANDLE _priv_callbackInstance_InputCallback;
private RENDERHANDLE _priv_callbackInstance_FormWindowCallback;
public static ProtocolSplashDesktop Bind(RenderPort port)
{
Debug2.Validate(port != null, typeof(ArgumentNullException), nameof(port));
ProtocolInstance protocolInstance = port.LookUpProtocol("Splash::Desktop");
if (protocolInstance != null)
{
ProtocolSplashDesktop protocolSplashDesktop = protocolInstance as ProtocolSplashDesktop;
Debug2.Validate(protocolSplashDesktop != null, typeof(InvalidOperationException), "protocol name collision");
return protocolSplashDesktop;
}
ProtocolSplashDesktop protocolSplashDesktop1 = new ProtocolSplashDesktop(port);
port.BindProtocol((ProtocolInstance)protocolSplashDesktop1);
return protocolSplashDesktop1;
}
public LocalInputCallback LocalInputCallbackHandle => LocalInputCallback.CreateCallbackImpl(this.Port, this._priv_callbackInstance_InputCallback);
public LocalFormWindowCallback LocalFormWindowCallbackHandle => LocalFormWindowCallback.CreateCallbackImpl(this.Port, this._priv_callbackInstance_FormWindowCallback);
private ProtocolSplashDesktop(RenderPort port)
: base(port, "Splash::Desktop")
{
}
protected override void Init()
{
RenderPort port = this.Port;
this._priv_remoteClass_InputRouter = port.InitRemoteClass("Splash::Desktop::InputRouter");
this._priv_remoteClass_FormWindowBase = port.InitRemoteClass("Splash::Desktop::FormWindowBase");
this._priv_callbackInstance_InputCallback = LocalInputCallback.BindCallback(port);
this._priv_callbackInstance_FormWindowCallback = LocalFormWindowCallback.BindCallback(port);
}
internal RENDERHANDLE InputRouter_ClassHandle => this._priv_remoteClass_InputRouter;
internal RENDERHANDLE FormWindowBase_ClassHandle => this._priv_remoteClass_FormWindowBase;
internal RENDERHANDLE InputCallback_CallbackInstance => this._priv_callbackInstance_InputCallback;
internal RENDERHANDLE FormWindowCallback_CallbackInstance => this._priv_callbackInstance_FormWindowCallback;
internal RemoteInputRouter BuildRemoteInputRouter(
IRenderHandleOwner _priv_owner,
LocalInputCallback ic)
{
return RemoteInputRouter.Create(this, _priv_owner, ic);
}
}
public LocalInputCallback LocalInputCallbackHandle => LocalInputCallback.CreateCallbackImpl(this.Port, this._priv_callbackInstance_InputCallback);
public LocalFormWindowCallback LocalFormWindowCallbackHandle => LocalFormWindowCallback.CreateCallbackImpl(this.Port, this._priv_callbackInstance_FormWindowCallback);
private ProtocolSplashDesktop(RenderPort port)
: base(port, "Splash::Desktop")
{
}
protected override void Init()
{
RenderPort port = this.Port;
this._priv_remoteClass_InputRouter = port.InitRemoteClass("Splash::Desktop::InputRouter");
this._priv_remoteClass_FormWindowBase = port.InitRemoteClass("Splash::Desktop::FormWindowBase");
this._priv_callbackInstance_InputCallback = LocalInputCallback.BindCallback(port);
this._priv_callbackInstance_FormWindowCallback = LocalFormWindowCallback.BindCallback(port);
}
internal RENDERHANDLE InputRouter_ClassHandle => this._priv_remoteClass_InputRouter;
internal RENDERHANDLE FormWindowBase_ClassHandle => this._priv_remoteClass_FormWindowBase;
internal RENDERHANDLE InputCallback_CallbackInstance => this._priv_callbackInstance_InputCallback;
internal RENDERHANDLE FormWindowCallback_CallbackInstance => this._priv_callbackInstance_FormWindowCallback;
internal RemoteInputRouter BuildRemoteInputRouter(
IRenderHandleOwner _priv_owner,
LocalInputCallback ic)
{
return RemoteInputRouter.Create(this, _priv_owner, ic);
}
}
}
File diff suppressed because it is too large Load Diff
@@ -10,149 +10,149 @@ using System.Runtime.InteropServices;
namespace Microsoft.Iris.Render.Protocols.Splash.Desktop
{
internal class RemoteInputRouter : RemoteObject
{
private static ushort[] s_priv_ByteOrder_Msg2_Create;
private static ushort[] s_priv_ByteOrder_Msg0_UnRegisterWithInputSource;
private static ushort[] s_priv_ByteOrder_Msg1_RegisterWithInputSource;
protected RemoteInputRouter()
internal class RemoteInputRouter : RemoteObject
{
private static ushort[] s_priv_ByteOrder_Msg2_Create;
private static ushort[] s_priv_ByteOrder_Msg0_UnRegisterWithInputSource;
private static ushort[] s_priv_ByteOrder_Msg1_RegisterWithInputSource;
protected RemoteInputRouter()
{
}
public static unsafe RemoteInputRouter Create(
ProtocolSplashDesktop _priv_protocolInstance,
IRenderHandleOwner _priv_owner,
LocalInputCallback ic)
{
RenderPort port = _priv_protocolInstance.Port;
RENDERHANDLE routerClassHandle = _priv_protocolInstance.InputRouter_ClassHandle;
RemoteInputRouter remoteInputRouter = new RemoteInputRouter(port, _priv_owner);
uint num = (uint)sizeof(RemoteInputRouter.Msg2_Create);
// ISSUE: untyped stack allocation
byte* pMem = (byte*)__untypedstackalloc(1 * (int)num);
RemoteInputRouter.Msg2_Create* msg2CreatePtr = (RemoteInputRouter.Msg2_Create*)pMem;
msg2CreatePtr->_priv_size = num;
msg2CreatePtr->_priv_msgid = 2U;
msg2CreatePtr->_priv_objic = ic.RenderHandle;
msg2CreatePtr->_priv_ctxic = port.Session.LocalContext;
msg2CreatePtr->_priv_idObjectSubject = remoteInputRouter.m_renderHandle;
if (port.ForeignByteOrder)
MarshalHelper.SwapByteOrder(pMem, ref RemoteInputRouter.s_priv_ByteOrder_Msg2_Create, typeof(RemoteInputRouter.Msg2_Create), 0, 0);
port.CreateRemoteObject(routerClassHandle, remoteInputRouter.m_renderHandle, (Message*)msg2CreatePtr);
return remoteInputRouter;
}
public unsafe void BuildUnRegisterWithInputSource(
out RenderPort _priv_portUse,
out Message* _priv_pmsgUse)
{
Debug2.Throw(this.IsValid, "Non-static method call requires an instance");
_priv_portUse = this.m_renderPort;
_priv_portUse.ValidateHandle(this.m_renderHandle);
uint size = (uint)sizeof(RemoteInputRouter.Msg0_UnRegisterWithInputSource);
RemoteInputRouter.Msg0_UnRegisterWithInputSource* registerWithInputSourcePtr = (RemoteInputRouter.Msg0_UnRegisterWithInputSource*)_priv_portUse.AllocMessageBuffer(size);
registerWithInputSourcePtr->_priv_size = size;
registerWithInputSourcePtr->_priv_msgid = 0U;
registerWithInputSourcePtr->_priv_idObjectSubject = this.m_renderHandle;
if (_priv_portUse.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*)registerWithInputSourcePtr, ref RemoteInputRouter.s_priv_ByteOrder_Msg0_UnRegisterWithInputSource, typeof(RemoteInputRouter.Msg0_UnRegisterWithInputSource), 0, 0);
_priv_pmsgUse = (Message*)registerWithInputSourcePtr;
}
public unsafe void SendUnRegisterWithInputSource()
{
RenderPort _priv_portUse;
Message* _priv_pmsgUse;
this.BuildUnRegisterWithInputSource(out _priv_portUse, out _priv_pmsgUse);
_priv_portUse.SendRemoteMessage(_priv_pmsgUse);
}
public unsafe void BuildRegisterWithInputSource(
out RenderPort _priv_portUse,
out Message* _priv_pmsgUse,
uint idGroup,
RENDERHANDLE idSource)
{
Debug2.Throw(this.IsValid, "Non-static method call requires an instance");
_priv_portUse = this.m_renderPort;
_priv_portUse.ValidateHandle(this.m_renderHandle);
uint size = (uint)sizeof(RemoteInputRouter.Msg1_RegisterWithInputSource);
RemoteInputRouter.Msg1_RegisterWithInputSource* registerWithInputSourcePtr = (RemoteInputRouter.Msg1_RegisterWithInputSource*)_priv_portUse.AllocMessageBuffer(size);
registerWithInputSourcePtr->_priv_size = size;
registerWithInputSourcePtr->_priv_msgid = 1U;
registerWithInputSourcePtr->idGroup = idGroup;
registerWithInputSourcePtr->idSource = idSource;
registerWithInputSourcePtr->_priv_idObjectSubject = this.m_renderHandle;
if (_priv_portUse.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*)registerWithInputSourcePtr, ref RemoteInputRouter.s_priv_ByteOrder_Msg1_RegisterWithInputSource, typeof(RemoteInputRouter.Msg1_RegisterWithInputSource), 0, 0);
_priv_pmsgUse = (Message*)registerWithInputSourcePtr;
}
public unsafe void SendRegisterWithInputSource(uint idGroup, RENDERHANDLE idSource)
{
RenderPort _priv_portUse;
Message* _priv_pmsgUse;
this.BuildRegisterWithInputSource(out _priv_portUse, out _priv_pmsgUse, idGroup, idSource);
_priv_portUse.SendRemoteMessage(_priv_pmsgUse);
}
public static RemoteInputRouter CreateFromHandle(
RenderPort port,
RENDERHANDLE handle)
{
return new RemoteInputRouter(port, handle, true);
}
public static RemoteInputRouter CreateFromExternalHandle(
RenderPort port,
RENDERHANDLE handle,
IRenderHandleOwner owner)
{
port.RegisterKnownHandle(owner, handle);
return new RemoteInputRouter(port, handle, false);
}
protected RemoteInputRouter(RenderPort port, RENDERHANDLE handle, bool fFreeOnDispose)
: base(port, handle, fFreeOnDispose)
{
}
protected RemoteInputRouter(RenderPort port, IRenderHandleOwner owner)
: base(port, owner)
{
}
public override bool Equals(object other) => other is RemoteInputRouter && this.m_renderHandle == ((RemoteObject)other).m_renderHandle;
public override int GetHashCode() => base.GetHashCode();
[ComVisible(false)]
private struct Msg2_Create
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE _priv_objic;
public ContextID _priv_ctxic;
}
[ComVisible(false)]
private struct Msg0_UnRegisterWithInputSource
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
}
[ComVisible(false)]
private struct Msg1_RegisterWithInputSource
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public uint idGroup;
public RENDERHANDLE idSource;
}
}
public static unsafe RemoteInputRouter Create(
ProtocolSplashDesktop _priv_protocolInstance,
IRenderHandleOwner _priv_owner,
LocalInputCallback ic)
{
RenderPort port = _priv_protocolInstance.Port;
RENDERHANDLE routerClassHandle = _priv_protocolInstance.InputRouter_ClassHandle;
RemoteInputRouter remoteInputRouter = new RemoteInputRouter(port, _priv_owner);
uint num = (uint) sizeof (RemoteInputRouter.Msg2_Create);
// ISSUE: untyped stack allocation
byte* pMem = (byte*) __untypedstackalloc(1 * (int) num);
RemoteInputRouter.Msg2_Create* msg2CreatePtr = (RemoteInputRouter.Msg2_Create*) pMem;
msg2CreatePtr->_priv_size = num;
msg2CreatePtr->_priv_msgid = 2U;
msg2CreatePtr->_priv_objic = ic.RenderHandle;
msg2CreatePtr->_priv_ctxic = port.Session.LocalContext;
msg2CreatePtr->_priv_idObjectSubject = remoteInputRouter.m_renderHandle;
if (port.ForeignByteOrder)
MarshalHelper.SwapByteOrder(pMem, ref RemoteInputRouter.s_priv_ByteOrder_Msg2_Create, typeof (RemoteInputRouter.Msg2_Create), 0, 0);
port.CreateRemoteObject(routerClassHandle, remoteInputRouter.m_renderHandle, (Message*) msg2CreatePtr);
return remoteInputRouter;
}
public unsafe void BuildUnRegisterWithInputSource(
out RenderPort _priv_portUse,
out Message* _priv_pmsgUse)
{
Debug2.Throw(this.IsValid, "Non-static method call requires an instance");
_priv_portUse = this.m_renderPort;
_priv_portUse.ValidateHandle(this.m_renderHandle);
uint size = (uint) sizeof (RemoteInputRouter.Msg0_UnRegisterWithInputSource);
RemoteInputRouter.Msg0_UnRegisterWithInputSource* registerWithInputSourcePtr = (RemoteInputRouter.Msg0_UnRegisterWithInputSource*) _priv_portUse.AllocMessageBuffer(size);
registerWithInputSourcePtr->_priv_size = size;
registerWithInputSourcePtr->_priv_msgid = 0U;
registerWithInputSourcePtr->_priv_idObjectSubject = this.m_renderHandle;
if (_priv_portUse.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*) registerWithInputSourcePtr, ref RemoteInputRouter.s_priv_ByteOrder_Msg0_UnRegisterWithInputSource, typeof (RemoteInputRouter.Msg0_UnRegisterWithInputSource), 0, 0);
_priv_pmsgUse = (Message*) registerWithInputSourcePtr;
}
public unsafe void SendUnRegisterWithInputSource()
{
RenderPort _priv_portUse;
Message* _priv_pmsgUse;
this.BuildUnRegisterWithInputSource(out _priv_portUse, out _priv_pmsgUse);
_priv_portUse.SendRemoteMessage(_priv_pmsgUse);
}
public unsafe void BuildRegisterWithInputSource(
out RenderPort _priv_portUse,
out Message* _priv_pmsgUse,
uint idGroup,
RENDERHANDLE idSource)
{
Debug2.Throw(this.IsValid, "Non-static method call requires an instance");
_priv_portUse = this.m_renderPort;
_priv_portUse.ValidateHandle(this.m_renderHandle);
uint size = (uint) sizeof (RemoteInputRouter.Msg1_RegisterWithInputSource);
RemoteInputRouter.Msg1_RegisterWithInputSource* registerWithInputSourcePtr = (RemoteInputRouter.Msg1_RegisterWithInputSource*) _priv_portUse.AllocMessageBuffer(size);
registerWithInputSourcePtr->_priv_size = size;
registerWithInputSourcePtr->_priv_msgid = 1U;
registerWithInputSourcePtr->idGroup = idGroup;
registerWithInputSourcePtr->idSource = idSource;
registerWithInputSourcePtr->_priv_idObjectSubject = this.m_renderHandle;
if (_priv_portUse.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*) registerWithInputSourcePtr, ref RemoteInputRouter.s_priv_ByteOrder_Msg1_RegisterWithInputSource, typeof (RemoteInputRouter.Msg1_RegisterWithInputSource), 0, 0);
_priv_pmsgUse = (Message*) registerWithInputSourcePtr;
}
public unsafe void SendRegisterWithInputSource(uint idGroup, RENDERHANDLE idSource)
{
RenderPort _priv_portUse;
Message* _priv_pmsgUse;
this.BuildRegisterWithInputSource(out _priv_portUse, out _priv_pmsgUse, idGroup, idSource);
_priv_portUse.SendRemoteMessage(_priv_pmsgUse);
}
public static RemoteInputRouter CreateFromHandle(
RenderPort port,
RENDERHANDLE handle)
{
return new RemoteInputRouter(port, handle, true);
}
public static RemoteInputRouter CreateFromExternalHandle(
RenderPort port,
RENDERHANDLE handle,
IRenderHandleOwner owner)
{
port.RegisterKnownHandle(owner, handle);
return new RemoteInputRouter(port, handle, false);
}
protected RemoteInputRouter(RenderPort port, RENDERHANDLE handle, bool fFreeOnDispose)
: base(port, handle, fFreeOnDispose)
{
}
protected RemoteInputRouter(RenderPort port, IRenderHandleOwner owner)
: base(port, owner)
{
}
public override bool Equals(object other) => other is RemoteInputRouter && this.m_renderHandle == ((RemoteObject) other).m_renderHandle;
public override int GetHashCode() => base.GetHashCode();
[ComVisible(false)]
private struct Msg2_Create
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE _priv_objic;
public ContextID _priv_ctxic;
}
[ComVisible(false)]
private struct Msg0_UnRegisterWithInputSource
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
}
[ComVisible(false)]
private struct Msg1_RegisterWithInputSource
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public uint idGroup;
public RENDERHANDLE idSource;
}
}
}
@@ -10,39 +10,39 @@ using System;
namespace Microsoft.Iris.Render.Protocols.Splash.Desktop.Xenon
{
internal sealed class ProtocolSplashDesktopXenon : ProtocolInstance
{
private RENDERHANDLE _priv_remoteClass_FormWindow;
public static ProtocolSplashDesktopXenon Bind(RenderPort port)
internal sealed class ProtocolSplashDesktopXenon : ProtocolInstance
{
Debug2.Validate(port != null, typeof (ArgumentNullException), nameof (port));
ProtocolInstance protocolInstance = port.LookUpProtocol("Splash::Desktop::Xenon");
if (protocolInstance != null)
{
ProtocolSplashDesktopXenon splashDesktopXenon = protocolInstance as ProtocolSplashDesktopXenon;
Debug2.Validate(splashDesktopXenon != null, typeof (InvalidOperationException), "protocol name collision");
return splashDesktopXenon;
}
ProtocolSplashDesktopXenon splashDesktopXenon1 = new ProtocolSplashDesktopXenon(port);
port.BindProtocol((ProtocolInstance) splashDesktopXenon1);
return splashDesktopXenon1;
private RENDERHANDLE _priv_remoteClass_FormWindow;
public static ProtocolSplashDesktopXenon Bind(RenderPort port)
{
Debug2.Validate(port != null, typeof(ArgumentNullException), nameof(port));
ProtocolInstance protocolInstance = port.LookUpProtocol("Splash::Desktop::Xenon");
if (protocolInstance != null)
{
ProtocolSplashDesktopXenon splashDesktopXenon = protocolInstance as ProtocolSplashDesktopXenon;
Debug2.Validate(splashDesktopXenon != null, typeof(InvalidOperationException), "protocol name collision");
return splashDesktopXenon;
}
ProtocolSplashDesktopXenon splashDesktopXenon1 = new ProtocolSplashDesktopXenon(port);
port.BindProtocol((ProtocolInstance)splashDesktopXenon1);
return splashDesktopXenon1;
}
private ProtocolSplashDesktopXenon(RenderPort port)
: base(port, "Splash::Desktop::Xenon")
{
}
protected override void Init() => this._priv_remoteClass_FormWindow = this.Port.InitRemoteClass("Splash::Desktop::Xenon::FormWindow");
internal RENDERHANDLE FormWindow_ClassHandle => this._priv_remoteClass_FormWindow;
internal RemoteFormWindow BuildRemoteFormWindow(
IRenderHandleOwner _priv_owner,
LocalFormWindowCallback cb)
{
return RemoteFormWindow.Create(this, _priv_owner, cb);
}
}
private ProtocolSplashDesktopXenon(RenderPort port)
: base(port, "Splash::Desktop::Xenon")
{
}
protected override void Init() => this._priv_remoteClass_FormWindow = this.Port.InitRemoteClass("Splash::Desktop::Xenon::FormWindow");
internal RENDERHANDLE FormWindow_ClassHandle => this._priv_remoteClass_FormWindow;
internal RemoteFormWindow BuildRemoteFormWindow(
IRenderHandleOwner _priv_owner,
LocalFormWindowCallback cb)
{
return RemoteFormWindow.Create(this, _priv_owner, cb);
}
}
}
@@ -9,75 +9,75 @@ using System.Runtime.InteropServices;
namespace Microsoft.Iris.Render.Protocols.Splash.Desktop.Xenon
{
internal class RemoteFormWindow : RemoteFormWindowBase
{
private static ushort[] s_priv_ByteOrder_Msg41_Create;
protected RemoteFormWindow()
internal class RemoteFormWindow : RemoteFormWindowBase
{
private static ushort[] s_priv_ByteOrder_Msg41_Create;
protected RemoteFormWindow()
{
}
public static unsafe RemoteFormWindow Create(
ProtocolSplashDesktopXenon _priv_protocolInstance,
IRenderHandleOwner _priv_owner,
LocalFormWindowCallback cb)
{
RenderPort port = _priv_protocolInstance.Port;
RENDERHANDLE windowClassHandle = _priv_protocolInstance.FormWindow_ClassHandle;
RemoteFormWindow remoteFormWindow = new RemoteFormWindow(port, _priv_owner);
uint num = (uint)sizeof(RemoteFormWindow.Msg41_Create);
// ISSUE: untyped stack allocation
byte* pMem = (byte*)__untypedstackalloc(1 * (int)num);
RemoteFormWindow.Msg41_Create* msg41CreatePtr = (RemoteFormWindow.Msg41_Create*)pMem;
msg41CreatePtr->_priv_size = num;
msg41CreatePtr->_priv_msgid = 41U;
msg41CreatePtr->_priv_objcb = cb.RenderHandle;
msg41CreatePtr->_priv_ctxcb = port.Session.LocalContext;
msg41CreatePtr->_priv_idObjectSubject = remoteFormWindow.m_renderHandle;
if (port.ForeignByteOrder)
MarshalHelper.SwapByteOrder(pMem, ref RemoteFormWindow.s_priv_ByteOrder_Msg41_Create, typeof(RemoteFormWindow.Msg41_Create), 0, 0);
port.CreateRemoteObject(windowClassHandle, remoteFormWindow.m_renderHandle, (Message*)msg41CreatePtr);
return remoteFormWindow;
}
public static RemoteFormWindow CreateFromHandle(
RenderPort port,
RENDERHANDLE handle)
{
return new RemoteFormWindow(port, handle, true);
}
public static RemoteFormWindow CreateFromExternalHandle(
RenderPort port,
RENDERHANDLE handle,
IRenderHandleOwner owner)
{
port.RegisterKnownHandle(owner, handle);
return new RemoteFormWindow(port, handle, false);
}
protected RemoteFormWindow(RenderPort port, RENDERHANDLE handle, bool fFreeOnDispose)
: base(port, handle, fFreeOnDispose)
{
}
protected RemoteFormWindow(RenderPort port, IRenderHandleOwner owner)
: base(port, owner)
{
}
public override bool Equals(object other) => other is RemoteFormWindow && this.m_renderHandle == ((RemoteObject)other).m_renderHandle;
public override int GetHashCode() => base.GetHashCode();
[ComVisible(false)]
private struct Msg41_Create
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE _priv_objcb;
public ContextID _priv_ctxcb;
}
}
public static unsafe RemoteFormWindow Create(
ProtocolSplashDesktopXenon _priv_protocolInstance,
IRenderHandleOwner _priv_owner,
LocalFormWindowCallback cb)
{
RenderPort port = _priv_protocolInstance.Port;
RENDERHANDLE windowClassHandle = _priv_protocolInstance.FormWindow_ClassHandle;
RemoteFormWindow remoteFormWindow = new RemoteFormWindow(port, _priv_owner);
uint num = (uint) sizeof (RemoteFormWindow.Msg41_Create);
// ISSUE: untyped stack allocation
byte* pMem = (byte*) __untypedstackalloc(1 * (int) num);
RemoteFormWindow.Msg41_Create* msg41CreatePtr = (RemoteFormWindow.Msg41_Create*) pMem;
msg41CreatePtr->_priv_size = num;
msg41CreatePtr->_priv_msgid = 41U;
msg41CreatePtr->_priv_objcb = cb.RenderHandle;
msg41CreatePtr->_priv_ctxcb = port.Session.LocalContext;
msg41CreatePtr->_priv_idObjectSubject = remoteFormWindow.m_renderHandle;
if (port.ForeignByteOrder)
MarshalHelper.SwapByteOrder(pMem, ref RemoteFormWindow.s_priv_ByteOrder_Msg41_Create, typeof (RemoteFormWindow.Msg41_Create), 0, 0);
port.CreateRemoteObject(windowClassHandle, remoteFormWindow.m_renderHandle, (Message*) msg41CreatePtr);
return remoteFormWindow;
}
public static RemoteFormWindow CreateFromHandle(
RenderPort port,
RENDERHANDLE handle)
{
return new RemoteFormWindow(port, handle, true);
}
public static RemoteFormWindow CreateFromExternalHandle(
RenderPort port,
RENDERHANDLE handle,
IRenderHandleOwner owner)
{
port.RegisterKnownHandle(owner, handle);
return new RemoteFormWindow(port, handle, false);
}
protected RemoteFormWindow(RenderPort port, RENDERHANDLE handle, bool fFreeOnDispose)
: base(port, handle, fFreeOnDispose)
{
}
protected RemoteFormWindow(RenderPort port, IRenderHandleOwner owner)
: base(port, owner)
{
}
public override bool Equals(object other) => other is RemoteFormWindow && this.m_renderHandle == ((RemoteObject) other).m_renderHandle;
public override int GetHashCode() => base.GetHashCode();
[ComVisible(false)]
private struct Msg41_Create
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE _priv_objcb;
public ContextID _priv_ctxcb;
}
}
}
@@ -8,8 +8,8 @@ using Microsoft.Iris.Render.Protocol;
namespace Microsoft.Iris.Render.Protocols.Splash.Messaging
{
internal interface IDataBufferCallback
{
void OnComplete(RENDERHANDLE target);
}
internal interface IDataBufferCallback
{
void OnComplete(RENDERHANDLE target);
}
}
@@ -8,10 +8,10 @@ using Microsoft.Iris.Render.Protocol;
namespace Microsoft.Iris.Render.Protocols.Splash.Messaging
{
internal interface IRenderPortCallback
{
void OnBatchProcessed(RENDERHANDLE target, uint uBatchCompleted);
internal interface IRenderPortCallback
{
void OnBatchProcessed(RENDERHANDLE target, uint uBatchCompleted);
void OnPingReply(RENDERHANDLE target);
}
void OnPingReply(RENDERHANDLE target);
}
}
@@ -10,65 +10,65 @@ using System.Runtime.InteropServices;
namespace Microsoft.Iris.Render.Protocols.Splash.Messaging
{
internal class LocalDataBufferCallback : RemoteObject
{
private static ushort[] s_priv_ByteOrder_Msg0_OnComplete;
protected LocalDataBufferCallback()
internal class LocalDataBufferCallback : RemoteObject
{
private static ushort[] s_priv_ByteOrder_Msg0_OnComplete;
protected LocalDataBufferCallback()
{
}
internal static LocalDataBufferCallback CreateCallbackImpl(
RenderPort port,
RENDERHANDLE callbackInstance)
{
return new LocalDataBufferCallback(port, callbackInstance);
}
protected LocalDataBufferCallback(RenderPort port, RENDERHANDLE handle)
: base(port, handle, false)
{
}
public override bool Equals(object other) => other is LocalDataBufferCallback && this.m_renderHandle == ((RemoteObject)other).m_renderHandle;
public override int GetHashCode() => base.GetHashCode();
internal static RENDERHANDLE BindCallback(RenderPort port) => port.RegisterCallback(new PortCallback(LocalDataBufferCallback.DispatchCallback), out uint _);
private static unsafe void DispatchCallback(
RenderPort port,
IRenderHandleOwner owner,
CallbackMessage* message)
{
if (!(owner is IDataBufferCallback _priv_target) || message->nMsg != 0U)
return;
LocalDataBufferCallback.Dispatch_OnComplete(port, _priv_target, (LocalDataBufferCallback.Msg0_OnComplete*)message);
}
private static unsafe void Dispatch_OnComplete(
RenderPort _priv_port,
IDataBufferCallback _priv_target,
LocalDataBufferCallback.Msg0_OnComplete* _priv_pmsg)
{
if (_priv_port.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*)_priv_pmsg, ref LocalDataBufferCallback.s_priv_ByteOrder_Msg0_OnComplete, typeof(LocalDataBufferCallback.Msg0_OnComplete), sizeof(CallbackMessage), 0);
RENDERHANDLE target = _priv_pmsg->target;
_priv_target.OnComplete(target);
}
[Conditional("DEBUG")]
private static unsafe void OnInvalidCallback(CallbackMessage* message, string category)
{
}
[ComVisible(false)]
private struct Msg0_OnComplete
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE target;
}
}
internal static LocalDataBufferCallback CreateCallbackImpl(
RenderPort port,
RENDERHANDLE callbackInstance)
{
return new LocalDataBufferCallback(port, callbackInstance);
}
protected LocalDataBufferCallback(RenderPort port, RENDERHANDLE handle)
: base(port, handle, false)
{
}
public override bool Equals(object other) => other is LocalDataBufferCallback && this.m_renderHandle == ((RemoteObject) other).m_renderHandle;
public override int GetHashCode() => base.GetHashCode();
internal static RENDERHANDLE BindCallback(RenderPort port) => port.RegisterCallback(new PortCallback(LocalDataBufferCallback.DispatchCallback), out uint _);
private static unsafe void DispatchCallback(
RenderPort port,
IRenderHandleOwner owner,
CallbackMessage* message)
{
if (!(owner is IDataBufferCallback _priv_target) || message->nMsg != 0U)
return;
LocalDataBufferCallback.Dispatch_OnComplete(port, _priv_target, (LocalDataBufferCallback.Msg0_OnComplete*) message);
}
private static unsafe void Dispatch_OnComplete(
RenderPort _priv_port,
IDataBufferCallback _priv_target,
LocalDataBufferCallback.Msg0_OnComplete* _priv_pmsg)
{
if (_priv_port.ForeignByteOrder)
MarshalHelper.SwapByteOrder((byte*) _priv_pmsg, ref LocalDataBufferCallback.s_priv_ByteOrder_Msg0_OnComplete, typeof (LocalDataBufferCallback.Msg0_OnComplete), sizeof (CallbackMessage), 0);
RENDERHANDLE target = _priv_pmsg->target;
_priv_target.OnComplete(target);
}
[Conditional("DEBUG")]
private static unsafe void OnInvalidCallback(CallbackMessage* message, string category)
{
}
[ComVisible(false)]
private struct Msg0_OnComplete
{
public uint _priv_size;
public uint _priv_msgid;
public RENDERHANDLE _priv_idObjectSubject;
public RENDERHANDLE target;
}
}
}

Some files were not shown because too many files have changed in this diff Show More