protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
產生手寫軌跡的測試資料();
solidColorBrush1 = new SolidColorBrush(ColorsHelper.Parse("ff1a1a1a"));
solidColorBrush2 = new SolidColorBrush(ColorsHelper.Parse("ff999999"));
solidColorBrush3 = new SolidColorBrush(ColorsHelper.Parse("ffff0000"));
solidColorBrush4 = new SolidColorBrush(ColorsHelper.Parse("ff006cff"));
solidColorBrush5 = new SolidColorBrush(ColorsHelper.Parse("ff0da522"));
wbContentImage = BitmapFactory.New(768, 1024);
wbContentImage.Clear(Colors.Transparent);
cnUsingWriteableBitmap.Source = wbContentImage;
d2dBrush = new ImageBrush();
cnUsingGeometries.Background = d2dBrush;
// Safely dispose any previous instance
// Creates a new DeviceManager (Direct3D, Direct2D, DirectWrite, WIC)
deviceManager = new DeviceManager();
shapeRenderer = new ShapeRenderer();
DisplayInformation DisplayInformation = Windows.Graphics.Display.DisplayInformation.GetForCurrentView();
int pixelWidth = (int)(cnUsingGeometries.Width * DisplayInformation.LogicalDpi / 96.0);
int pixelHeight = (int)(cnUsingGeometries.Height * DisplayInformation.LogicalDpi / 96.0);
d2dTarget = new SurfaceImageSourceTarget(pixelWidth, pixelHeight);
d2dBrush.ImageSource = d2dTarget.ImageSource;
imgUsingInkManager.Source = d2dTarget.ImageSource;
// Add Initializer to device manager
deviceManager.OnInitialize += d2dTarget.Initialize;
deviceManager.OnInitialize += shapeRenderer.Initialize;
// Render the cube within the CoreWindow
d2dTarget.OnRender += shapeRenderer.Render;
// Initialize the device manager and all registered deviceManager.OnInitialize
deviceManager.Initialize(DisplayProperties.LogicalDpi);
// Setup rendering callback
//CompositionTarget.Rendering += CompositionTarget_Rendering;
// Callback on DpiChanged
DisplayProperties.LogicalDpiChanged += DisplayProperties_LogicalDpiChanged;
#region Scenario1
Scenario1Drawing = new Scenario1ImageSource((int)cnUsingDirectXs.Width, (int)cnUsingDirectXs.Height, true);
// Use Scenario1Drawing as a source for the Ellipse shape's fill
cnUsingDirectXs.Background = new ImageBrush() { ImageSource = Scenario1Drawing };
#endregion
}
public NetworkManager ()
{
ConManager = new ConnectionManager ();
DevManager = new DeviceManager ();
DevManager.NetworkDevices.ForEach (dev => dev.StateChanged += OnDevStateChanged);
}
/// <summary>
/// Initializes the Device Driver System.
/// </summary>
public static void Initialize()
{
// Create Device Manager
deviceManager = new DeviceManager();
// Create Interrupt Manager
interruptManager = new InterruptManager();
// Create the Device Driver Manager
deviceDriverRegistry = new DeviceDriverRegistry(PlatformArchitecture.X86);
// Create the PCI Controller Manager
pciControllerManager = new PCIControllerManager(deviceManager);
// Setup hardware abstraction interface
var hardware = new Mosa.CoolWorld.x86.HAL.Hardware();
// Set device driver system to the hardware HAL
Mosa.HardwareSystem.HAL.SetHardwareAbstraction(hardware);
// Set the interrupt handler
Mosa.HardwareSystem.HAL.SetInterruptHandler(InterruptManager.ProcessInterrupt);
partitionManager = new PartitionManager(deviceManager);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="_LogFileName">Log file name</param>
public ScannerControl(string _LogFileName)
{
DeviceManager = new DeviceManager();
DeviceInfoCollection = DeviceManager.DeviceInfos ;
objScannerPowerManager = new ScannerPowerManager(_LogFileName);
scnMngrLog = new ScnMngrLog(_LogFileName);
}
protected void Page_Load(object sender, EventArgs e)
{
this.Page.Title = "Contact Your " + ConfigurationManager.AppSettings["ApplicationWord"].ToString();
if (!this.IsPostBack)
{
//code for YT Mobile redirections
string redirctMobileUrl = string.Empty;
DeviceManager deviceManager = new DeviceManager
{
UserAgent = Request.UserAgent,
IsMobileBrowser = Request.Browser.IsMobileDevice
};
// Added by Varun Goel on 25 Jan 2013 for NoRedirection functionality
TributesPortal.Utilities.StateManager stateManager = StateManager.Instance;
objSessionValue = (SessionValue)stateManager.Get("objSessionvalue", StateManager.State.Session);
if (objSessionValue == null || objSessionValue.NoRedirection == null || objSessionValue.NoRedirection == false)
{
if (deviceManager.IsMobileDevice())
{
// Redirection URL
redirctMobileUrl = string.Format("{0}{1}{2}", "https://www.", WebConfig.TopLevelDomain, "/mobile/ContactUs.html");
Response.Redirect(redirctMobileUrl, false);
}
}
}
}
public frmDigitalizacao()
{
TwainGlobalSettings ts = new TwainGlobalSettings();
ts.Register("Afranio de Carvalho Freire Filho", "*****@*****.**", "MKhP0tHkOo03FOTYCC/vNUjr9wmoknf4+479sZoIPV5JIEuUkpfv1Ou8Vz+jblAxAzzqG+s8za1oMuTn9Pql6QcSHb92gzJNPu5joE4URLT4BfBw/R1M6WpwfuTtsPDqfhVfX2O2btRsKlDYK77WfU6+bkImymve8Xm7KHPeGtyw");
InitializeComponent();
lGerenciadorDispositivos = new DeviceManager();
}
/// <summary>
/// Constructor.
/// </summary>
public ScannerControl()
{
//System.Diagnostics.Debug.WriteLine(@"DeviceManager = new DeviceManager();");
DeviceManager = new DeviceManager();
DeviceInfoCollection = DeviceManager.DeviceInfos ;
objScannerPowerManager = new ScannerPowerManager();
scnMngrLog = new ScnMngrLog();
}
public static Device GetFirstScannerDevice()
{
DeviceManager deviceManager = new DeviceManager();
foreach (DeviceInfo deviceInfo in deviceManager.DeviceInfos)
if (deviceInfo.Type == WiaDeviceType.ScannerDeviceType)
return deviceInfo.Connect();
throw new ArgumentException("The Scanner is unavailable.");
}
public static Device FromDeviceId(string deviceID)
{
DeviceManager deviceManager = new DeviceManager();
foreach (DeviceInfo deviceInfo in deviceManager.DeviceInfos)
if (deviceInfo.DeviceID == deviceID)
return deviceInfo.Connect();
throw new ArgumentException("The Device with '" + deviceID + "' is unfound.");
}
public DepthBuffer(DeviceManager deviceManager, int width, int height)
{
_deviceManager = deviceManager;
Width = width;
Height = height;
SampleCount = 4;
SampleQuality = 4;
}
public SettingsDialog(DeviceManager manager, Settings settings)
{
InitializeComponent();
tabControl.Selected += tabControl_Selected;
_deviceManager = manager;
_settings = settings;
}
public virtual void Initialize(DeviceManager deviceManager)
{
sceneColorBrush = new SolidColorBrush(deviceManager.ContextDirect2D, SharpDX.Color.Red);
sceneColorBrush1 = new SolidColorBrush(deviceManager.ContextDirect2D, SharpDX.Color.GreenYellow);
sceneColorBrush2 = new SolidColorBrush(deviceManager.ContextDirect2D, SharpDX.Color.White);
sceneColorBrush3 = new SolidColorBrush(deviceManager.ContextDirect2D, SharpDX.Color.Transparent);
clock = Stopwatch.StartNew();
}
public SessionData(LoginComposite inParm, String sessionID, int securityLevel)
{
SmartCardParams sParams = new SmartCardParams(inParm.PinCode, inParm.CredID, inParm.GroupID, inParm.ProverID);
_securityLevel = securityLevel;
_parameterSet = SecurityLevelUtils.getRecommendedSet(securityLevel);
deviceManager = new DeviceManager(sParams, parameterSet, inParm.UseVirtualDevice);
lastAccessed = DateTime.Now;
this.sessionID = sessionID;
}
public WindowTextureBuffer(DeviceManager deviceManager, IntPtr windowHandle, int width, int height)
{
_deviceManager = deviceManager;
_windowHandle = windowHandle;
Width = width;
Height = height;
SampleCount = 4;
SampleQuality = 4;
}
/// <summary>
/// 创建指定类型的拼图渲染器。
/// </summary>
/// <param name="rendererType">拼图渲染器的类型。</param>
/// <param name="deviceManager">设备管理器。</param>
public static JigsawRenderer CreateRenderer(JigsawRendererType rendererType, DeviceManager deviceManager)
{
switch (rendererType)
{
case JigsawRendererType.Effect:
return new JigsawEffectRenderer(deviceManager);
default:
return new JigsawSimpleRenderer(deviceManager);
}
}
public StagingPipeline(DeviceManager deviceManager, RenderTarget presentationTarget, StagingPipelineSettings settings)
{
if (deviceManager == null) throw new ArgumentNullException("deviceManager");
if (presentationTarget == null) throw new ArgumentNullException("presentationTarget");
if (settings == null) throw new ArgumentNullException("settings");
_settings = settings;
_deviceManager = deviceManager;
_presentationTarget = presentationTarget;
}
public DeviceDialogViewModel()
{
DeviceManager dm = new DeviceManager();
var infos = dm.DeviceInfos;
foreach(DeviceInfo i in infos)
{
if (i.Type == WiaDeviceType.ScannerDeviceType)
Devices.Add(i);
}
}
public frmDigitalizacao_2(frmPrincipal form)
{
InitializeComponent();
formPrincipal = form;
lblIdCliente.Text = formPrincipal.lblIdCliente.Text;
lblNomeCliente.Text = formPrincipal.lblCliente.Text;
TwainGlobalSettings tgs = new TwainGlobalSettings();
tgs.Register("Afranio de Carvalho Freire Filho", "*****@*****.**", "MKhP0tHkOo03FOTYCC/vNUjr9wmoknf4+479sZoIPV5JIEuUkpfv1Ou8Vz+jblAxAzzqG+s8za1oMuTn9Pql6QcSHb92gzJNPu5joE4URLT4BfBw/R1M6WpwfuTtsPDqfhVfX2O2btRsKlDYK77WfU6+bkImymve8Xm7KHPeGtyw");
_deviceManager = new DeviceManager(this);
openDeviceManager();
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
_deviceManager = new DeviceManager();
_gameEngine = new GameEngine(_deviceManager);
await _deviceManager.SetupSensors();
while (true)
{
await _gameEngine.Run();
}
}
public ScanDevice(string deviceId)
{
var manager = new DeviceManager();
this.device = null;
foreach (DeviceInfo info in manager.DeviceInfos)
{
if (info.DeviceID == deviceId)
{
this.device = info.Connect();
this.item = device.Items[1];
break;
}
}
}
private void MainForm_Load(object sender, EventArgs e)
{
mgr = DeviceManager.Instance;
if (mgr.Count == 0)
{
MessageBox.Show("Diese Anwendung funktioniert nur, wenn Sie einen Novint Falcon an Ihren Computer angeschlossen haben. Stellen Sie sicher das dem so ist und die benötigten Treiber installiert sind! Starten Sie dann die Anwendung erneut", "Falcon nicht gefunden", MessageBoxButtons.OK);
Close();
}
else
{
dev = mgr[0];
UpdateDeviceDisplay();
}
}
internal HapticDevice(DeviceManager mgr, int deviceId)
{
this.deviceId = deviceId;
this.deviceHandle = NativeMethods.hdlInitIndexedDevice(deviceId);
if (this.deviceHandle == -1)
throw new DeviceInitializationFailedException(deviceId, NativeMethods.hdlGetError());
double[] wsValues = new double[6];
NativeMethods.hdlMakeCurrent(deviceHandle);
NativeMethods.hdlDeviceWorkspace(wsValues);
IntPtr modelPtr;
modelPtr = NativeMethods.hdlDeviceModel();
this.model = Marshal.PtrToStringAnsi(modelPtr);
workspace = new DeviceWorkspace(wsValues);
this.force = new DeviceForce(this);
this.loopOps = new HashSet<DeviceLoopOperation>();
}
public void TestSwitchOnCoolingWhilstReceivingData()
{
// Create an instance of a faked external hardware device
FakeExternalDevice device = new FakeExternalDevice();
device.Open();
DeviceManager manager = new DeviceManager(new[] { device });
// Force a data received from the device.
// Locks external device lock then try to lock on syncObject in manager.
device.TriggerDataReceived();
// This should lock on Manager syncObject, try to lock on the external device lock.
manager.EnableCooling();
// Either the TriggerDataReceived call should fail to lock on the managers syncObject
// or EnableCooling should fail to lock on the external Device's hardware lock as the other thread should
// already have acquired the lock.
}
private IEnumerable<GetScannerListResponse.Scanner> GetScanners()
{
DeviceManager manager = new DeviceManager();
foreach (DeviceInfo info in manager.DeviceInfos)
{
if (info.Type == WiaDeviceType.ScannerDeviceType)
{
string deviceId = info.DeviceID;
string deviceName = null;
foreach (Property item in info.Properties)
{
if (item.Name == "Description")
deviceName = item.get_Value();
}
if (deviceName != null)
yield return new GetScannerListResponse.Scanner() {DeviceId = deviceId, DeviceName = deviceName};
}
}
}
public CameraDeviceManager()
{
UseExperimentalDrivers = true;
SelectedCameraDevice = new NotConnectedCameraDevice();
ConnectedDevices = new AsyncObservableCollection<ICameraDevice>();
_deviceEnumerator = new DeviceDescriptorEnumerator();
LiveViewImage = new Dictionary<ICameraDevice, byte[]>();
// prevent program crash in something wrong with wia
try
{
WiaDeviceManager = new DeviceManager();
WiaDeviceManager.RegisterEvent(Conts.wiaEventDeviceConnected, "*");
WiaDeviceManager.RegisterEvent(Conts.wiaEventDeviceDisconnected, "*");
WiaDeviceManager.OnEvent += DeviceManager_OnEvent;
}
catch (Exception exception)
{
Log.Error("Error initialize WIA", exception);
}
}
/// <summary>
/// Gets the list of available WIA devices.
/// </summary>
/// <returns></returns>
public static Hashtable GetDevices()
{
Hashtable devices = new Hashtable();
DeviceManager manager = null;
try
{
manager = new DeviceManager();
}
catch (Exception)
{
throw new Exception("Cannot initialize WIA device manager.\nMake sure wiaaut.dll is present in your system32 directory and that it is registered (run 'regsvr32 wiaaut.dll').");
}
foreach (DeviceInfo info in manager.DeviceInfos)
{
String name = info.Properties["Name"].get_Value().ToString();
devices.Add(info.DeviceID, name);
}
return devices;
}
protected override void CreateDeviceDependentResources(DeviceManager deviceManager)
{
base.CreateDeviceDependentResources(deviceManager);
// Release all resources
RemoveAndDispose(ref vertexShader);
RemoveAndDispose(ref pixelShader);
RemoveAndDispose(ref depthPixelShader);
RemoveAndDispose(ref lambertShader);
RemoveAndDispose(ref blinnPhongShader);
RemoveAndDispose(ref phongShader);
RemoveAndDispose(ref vertexLayout);
RemoveAndDispose(ref perObjectBuffer);
RemoveAndDispose(ref perFrameBuffer);
RemoveAndDispose(ref perMaterialBuffer);
RemoveAndDispose(ref perArmatureBuffer);
RemoveAndDispose(ref depthStencilState);
// Get a reference to the Device1 instance and immediate context
var device = deviceManager.Direct3DDevice;
var context = deviceManager.Direct3DContext;
// Compile and create the vertex shader and input layout
using (var vertexShaderBytecode = HLSLCompiler.CompileFromFile(@"Shaders\VS.hlsl", "VSMain", "vs_5_0"))
{
vertexShader = ToDispose(new VertexShader(device, vertexShaderBytecode));
// Layout from VertexShader input signature
vertexLayout = ToDispose(new InputLayout(device,
vertexShaderBytecode.GetPart(ShaderBytecodePart.InputSignatureBlob),
new[]
{
// "SV_Position" = vertex coordinate in object space
new InputElement("SV_Position", 0, Format.R32G32B32_Float, 0, 0),
// "NORMAL" = the vertex normal
new InputElement("NORMAL", 0, Format.R32G32B32_Float, 12, 0),
// "COLOR"
new InputElement("COLOR", 0, Format.R8G8B8A8_UNorm, 24, 0),
// "UV"
new InputElement("TEXCOORD", 0, Format.R32G32_Float, 28, 0),
// "SkinIndices"
new InputElement("BLENDINDICES", 0, Format.R32G32B32A32_UInt, 36, 0),
// "SkinWeights"
new InputElement("BLENDWEIGHT", 0, Format.R32G32B32A32_Float, 52, 0),
}));
}
// Compile and create the pixel shader
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\SimplePS.hlsl", "PSMain", "ps_5_0"))
pixelShader = ToDispose(new PixelShader(device, bytecode));
// Compile and create the depth vertex and pixel shaders
// This shader is for checking what the depth buffer would look like
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\DepthPS.hlsl", "PSMain", "ps_5_0"))
depthPixelShader = ToDispose(new PixelShader(device, bytecode));
// Compile and create the Lambert pixel shader
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\DiffusePS.hlsl", "PSMain", "ps_5_0"))
lambertShader = ToDispose(new PixelShader(device, bytecode));
// Compile and create the Lambert pixel shader
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\BlinnPhongPS.hlsl", "PSMain", "ps_5_0"))
blinnPhongShader = ToDispose(new PixelShader(device, bytecode));
// Compile and create the Lambert pixel shader
using (var bytecode = HLSLCompiler.CompileFromFile(@"Shaders\PhongPS.hlsl", "PSMain", "ps_5_0"))
phongShader = ToDispose(new PixelShader(device, bytecode));
// IMPORTANT: A constant buffer's size must be a multiple of 16-bytes
// use LayoutKind.Explicit and an explicit Size= to force this for structures
// or alternatively add padding fields and use a LayoutKind.Sequential and Pack=1
// Create the constant buffer that will
// store our worldViewProjection matrix
perObjectBuffer = ToDispose(new SharpDX.Direct3D11.Buffer(device, Utilities.SizeOf <ConstantBuffers.PerObject>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
// Create the per frame constant buffer
// lighting / camera position
perFrameBuffer = ToDispose(new Buffer(device, Utilities.SizeOf <ConstantBuffers.PerFrame>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
// Create the per material constant buffer
perMaterialBuffer = ToDispose(new Buffer(device, Utilities.SizeOf <ConstantBuffers.PerMaterial>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
// Create the per armature/skeletong constant buffer
perArmatureBuffer = ToDispose(new Buffer(device, ConstantBuffers.PerArmature.Size(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
// Configure the depth buffer to discard pixels that are
// further than the current pixel.
depthStencilState = ToDispose(new DepthStencilState(device,
new DepthStencilStateDescription()
{
IsDepthEnabled = true, // enable depth?
DepthComparison = Comparison.Less,
DepthWriteMask = SharpDX.Direct3D11.DepthWriteMask.All,
IsStencilEnabled = false, // enable stencil?
StencilReadMask = 0xff, // 0xff (no mask)
StencilWriteMask = 0xff, // 0xff (no mask)
// Configure FrontFace depth/stencil operations
FrontFace = new DepthStencilOperationDescription()
{
Comparison = Comparison.Always,
PassOperation = StencilOperation.Keep,
FailOperation = StencilOperation.Keep,
DepthFailOperation = StencilOperation.Increment
},
// Configure BackFace depth/stencil operations
BackFace = new DepthStencilOperationDescription()
{
Comparison = Comparison.Always,
PassOperation = StencilOperation.Keep,
FailOperation = StencilOperation.Keep,
DepthFailOperation = StencilOperation.Decrement
},
}));
// Tell the IA what the vertices will look like
// in this case two 4-component 32bit floats
// (32 bytes in total)
context.InputAssembler.InputLayout = vertexLayout;
// Set our constant buffer (to store worldViewProjection)
context.VertexShader.SetConstantBuffer(0, perObjectBuffer);
context.VertexShader.SetConstantBuffer(1, perFrameBuffer);
context.VertexShader.SetConstantBuffer(2, perMaterialBuffer);
context.VertexShader.SetConstantBuffer(3, perArmatureBuffer);
// Set the vertex shader to run
context.VertexShader.Set(vertexShader);
// Set our pixel constant buffers
context.PixelShader.SetConstantBuffer(1, perFrameBuffer);
context.PixelShader.SetConstantBuffer(2, perMaterialBuffer);
// Set the pixel shader to run
context.PixelShader.Set(blinnPhongShader);
// Set our depth stencil state
context.OutputMerger.DepthStencilState = depthStencilState;
// Back-face culling
context.Rasterizer.State = ToDispose(new RasterizerState(device, new RasterizerStateDescription()
{
FillMode = FillMode.Solid,
CullMode = CullMode.Back,
}));
}
public TrayApplicationContext()
{
_components = new System.ComponentModel.Container();
// Clean old files if they exist
if (File.Exists("settings.dat"))
{
File.Delete("settings.dat");
MessageBox.Show("All stored preferences were cleared during the update.\nPlease set your preferences again by right-clicking the tray icon and selecting settings.");
}
if (File.Exists("devices.dat"))
{
File.Delete("devices.dat");
}
// Load settings
Boolean first_time = false;
if (File.Exists("settings.json"))
{
try {
_settings = JsonConvert.DeserializeObject <Settings>(File.ReadAllText("settings.json"));
} catch (Exception e) {
MessageBox.Show("Could not load settings. Default values will be used.");
_settings = new Settings();
File.WriteAllText("settings.json", JsonConvert.SerializeObject(_settings));
}
}
else
{
_settings = new Settings();
_settings.Save();
first_time = true;
}
// Create history directory if needed
if (!Directory.Exists("History"))
{
Directory.CreateDirectory("History");
}
// Load devices
_deviceManager = new DeviceManager(_settings);
_deviceManager.SaveData();
// Prepare notification system
_notificationManager = new NotificationManager(_settings.ComputerName);
// Create the icon
_notifyIcon = new NotifyIcon(this._components);
_notifyIcon.Icon = Resources.icon_app;
_notifyIcon.Text = "Icy Monitor Server";
_notifyIcon.DoubleClick += mSettings_Click;
_notifyIcon.Visible = true;
// Prepare context menu
PrepareContextMenu();
// Create computer object for data
_computer = new Computer();
_visitor = new UpdateVisitor();
_computer.CPUEnabled = true;
_computer.FanControllerEnabled = true;
_computer.GPUEnabled = true;
_computer.MainboardEnabled = true;
_computer.HDDEnabled = true;
_computer.Open();
_computer.Accept(_visitor);
// Collect sensors (for history and notifications)
CollectSensors();
// Create notifications timer
StartNotificationsTimer();
// Create history timer
if (_settings.History)
{
StartHistoryTimer();
}
// Create server
CreateServer();
// Create the multicast timer
if (_settings.Multicast)
{
try {
StartMulticasting();
} catch (SocketException e) {
MessageBox.Show("Could not open socket for multicasting. Autodetection will be disabled.\n(Is another copy of Icy Monitor running?)");
}
}
if (first_time)
{
DialogResult dialogResult = MessageBox.Show("It is essential that you open a port for the server to use, would you want to open the preferences window?\n\nYou can do this at any moment by double-clicking the tray icon.",
"Icy Monitor Server", MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.Yes)
{
mSettings_Click(null, null);
}
}
// Start the server
if (_server.Start() == false)
{
if (_multicastSocket != null)
{
_multicastSocket.Close();
}
base.ExitThreadCore();
}
}
public override void AddDevice(IRunDevice dev)
{
if (dev == null)
{
throw new ArgumentNullException("设备驱动", "参数为空");
}
if (dev.DeviceParameter.DeviceID != dev.DeviceDynamic.DeviceID)
{
throw new NotEqualException("参数和动态数据的设备ID不相等");
}
int devid = -1;
if (dev.DeviceParameter.DeviceID == -1 || dev.DeviceDynamic.DeviceID == -1)
{
devid = this.DeviceManager.BuildDeviceID();
dev.DeviceParameter.DeviceID = devid;
dev.DeviceDynamic.DeviceID = devid;
try
{
dev.Initialize(devid);
}
catch { throw; }
}
if (DeviceManager.ContainDevice(devid))
{
throw new ArgumentException("已经有相同的设备ID存在");
}
if (Config.ControlMode == ControlMode.Singleton)
{
IRunDevice[] netDevices = DeviceManager.GetDevices(CommunicateType.NET);
if (dev.CommunicateType == CommunicateType.NET && netDevices.Length >= 1)//如果是Singleton模式只能有一个网络设备驱动
{
throw new IndexOutOfRangeException("当为Singleton模式时，不能增加多个网络设备驱动");
}
}
string desc = String.Empty;
if (this.DeviceManager.AddDevice(dev.DeviceParameter.DeviceID, dev))
{
this.BindDeviceHandler(dev, dev.DeviceType, true);
if (dev.DeviceType == DeviceType.Virtual)
{
desc = "增加虚拟设备";
}
else
{
IController controller = null;
if (dev.CommunicateType == CommunicateType.COM)
{
#region 串口
string key = ComUtils.PortToString(dev.DeviceParameter.COM.Port);
IChannel channel = ChannelManager.GetChannel(key);
if (channel == null)
{
IComSession comChannel = new ComSession(dev.DeviceParameter.COM.Port, dev.DeviceParameter.COM.Baud);
comChannel.Setup(this);
comChannel.Initialize();
comChannel.COMOpen += ComChannel_COMOpen;
comChannel.COMClose += ComChannel_COMClose;
comChannel.COMError += ComChannel_COMError;
comChannel.Open();
channel = (IChannel)comChannel;
ChannelManager.AddChannel(key, channel);
}
controller = ControllerManager.GetController(key);
if (controller == null)
{
controller = new ComController((IComSession)channel);
controller.Setup(this);
if (ControllerManager.AddController(controller.Key, controller))
{
controller.StartController();
}
}
else
{
IComController comController = (IComController)controller;
if (comController.ComChannel.GetHashCode() != channel.GetHashCode())
{
comController.ComChannel = (IComSession)channel;
}
}
desc = String.Format("增加'{0}'串口设备，串口:{1} 波特率:{2}", dev.DeviceParameter.DeviceName, dev.DeviceParameter.COM.Port.ToString(), dev.DeviceParameter.COM.Baud.ToString());
#endregion
}
else if (dev.CommunicateType == CommunicateType.NET)
{
#region 网络
controller = ControllerManager.GetController(SocketController.ConstantKey);
if (controller == null)
{
controller = new SocketController();
controller.Setup(this);
if (ControllerManager.AddController(controller.Key, controller))
{
controller.StartController();
}
}
desc = String.Format("增加'{0}'网络设备，IP地址:{1} 端口:{2}", dev.DeviceParameter.DeviceName, dev.DeviceParameter.NET.RemoteIP, dev.DeviceParameter.NET.RemotePort.ToString());
#endregion
}
else
{
desc = "无法识别设备的通讯类型";
}
}
desc += ",成功";
OnAddDeviceCompleted(dev.DeviceParameter.DeviceID, dev.DeviceParameter.DeviceName, true);
}
else
{
desc += ",失败";
OnAddDeviceCompleted(dev.DeviceParameter.DeviceID, dev.DeviceParameter.DeviceName, false);
}
this.Logger.Info(true, desc);
}
public DebugViewModel(DeviceManager deviceManager)
{
_deviceManager = deviceManager;
}
public override void Issue(DeviceManager manager)
{
RenderTrace.ImmediateMarker(Text);
base.Issue(manager);
}
private void clearDevicesToolStripMenuItem_Click(object sender, EventArgs e)
{
DeviceManager.Clear();
RefreshUsbDevices();
}
private void AddDeviceFromEvent(UsbEvent e)
{
DeviceManager.AddDeviceFromEvent(e);
}
//-----------------------------------------------------------
private static void ListScanners()
{
var deviceManager = new DeviceManager();
var devices = deviceManager.DeviceInfos !
.Cast <DeviceInfo>()
.Where(d => d != null && d.Type == WiaDeviceType.ScannerDeviceType)
.ToArray();
foreach (var d in devices)
{
Console.WriteLine(d.Properties["Name"].get_Value());
}
Device device = devices[0].Connect();
var pHandlingCaps = device.Properties[WIAConst.DPS_DOCUMENT_HANDLING_CAPABILITIES_STR];
// pHandlingCaps.SetValue( WIADocumentHandlingCaps.FEED );
var pHandlingSelect = device.Properties[WIAConst.IPS_DOCUMENT_HANDLING_SELECT_STR];
pHandlingSelect.SetValue(WIAIPSHandlingSelect.FEEDER);
var scanner = device.Items[1] !;
// var dpsPages = device.Properties.Get( WIAPropID.DPS_PAGE_SIZE );
var pPageSize = device.Properties.Get(WIAPropID.IPS_PAGE_SIZE);
var pPages = device.Properties.Get(WIAPropID.IPS_PAGES);
var pPageWidth = device.Properties.Get(WIAPropID.IPS_PAGE_WIDTH);
var pPageHeight = device.Properties.Get(WIAPropID.IPS_PAGE_HEIGHT);
int iPages = pPages.GetValue <int>();
pPageSize.SetValue(WIAPageSize.LETTER);
Console.WriteLine($"Page Size : {pPageSize .GetValue<int>()}");
Console.WriteLine($"Page Width : {pPageWidth .GetValue<int>()}");
Console.WriteLine($"Page Height: {pPageHeight.GetValue<int>()}");
// if( handlingSelect != null )
// {
// Console.WriteLine( "Handling Selected:" );
// Console.WriteLine( handlingSelect.PropertyID );
//
// var mode = (WIAIPSHandlingSelect)handlingSelect.get_Value();
// Console.WriteLine( $"MOde: {mode} | {mode:X}" );
//
// // mode = WIAIPSHandlingSelect.FEEDER;
// // object value = mode;
// // handlingSelect.set_Value( ref value );
// handlingSelect.SetValue( WIAIPSHandlingSelect.FEEDER );
//
// mode = (WIAIPSHandlingSelect)handlingSelect.get_Value();
// Console.WriteLine( $"Mode now: {mode} | {mode:X}" );
// }
// foreach( WIA.Property prop in scanner.Properties )
// {
// int id = prop.PropertyID;
// Console.WriteLine( $"PROP: {id} | 0x{id:X} = '{WIAPropMap.TryGetName(id)}'" );
// }
// return;
// Get props
var pDataType = scanner.Properties.Get(WIAPropID.IPA_DATATYPE);
// var pPages = scanner.Properties.Get( WIAPropID.IPS_PAGES );
// var pPageSize = scanner.Properties.Get( WIAPropID.IPS_PAGE_SIZE );
var pIntent = scanner.Properties.Get(WIAPropID.IPS_CUR_INTENT);
var pDepth = scanner.Properties.Get(WIAPropID.IPA_DEPTH);
var pChansPerPix = scanner.Properties.Get(WIAPropID.IPA_CHANNELS_PER_PIXEL);
var pBitsPerChan = scanner.Properties.Get(WIAPropID.IPA_BITS_PER_CHANNEL);
var pFormat = scanner.Properties.Get(WIAPropID.IPA_FORMAT);
var pResX = scanner.Properties.Get(WIAPropID.IPS_XRES);
var pResY = scanner.Properties.Get(WIAPropID.IPS_YRES);
// var pRawBitsPerChan = scanner.Properties[WIAConst.IPA_RAW_BITS_PER_CHANNEL_STR];
var dataType = pDataType.GetValue <WIADataType>();
// var pageSize = pPageSize ?.GetValue<WIAPageSize>();
var intent = pIntent.GetValue <WIAIntent>();
var depth = pDepth.GetValue <int>();
var chansPerPix = pChansPerPix.GetValue <int>();
var bitsPerChan = pBitsPerChan.GetValue <int>();
// var rawBitsPerChan = pRawBitsPerChan .get_Value();
var format = pFormat.GetValue <string>();
var resX = pResX.GetValue <int>();
var resY = pResY.GetValue <int>();
pFormat.SetValue(FormatID.wiaFormatPNG);
pPageSize.SetValue(WIAPageSize.LETTER);
// pIntent.SetValue( WIAIntent.IMAGE_TYPE_GRAYSCALE );
// pDataType.SetValue( (int)WIADataType.GRAYSCALE );
// pDepth.SetValue( 8 );
// pDataType.SetValue( WIADataType.GRAYSCALE );
//
// var pIntent = scanner.Properties[WIAConst.IPS_CUR_INTENT_STR];
// var intent = pIntent.GetValue<WIACurrentIntent>();
// pIntent.SetValue(
// WIACurrentIntent.MAXIMIZE_QUALITY |
// WIACurrentIntent.IMAGE_TYPE_GRAYSCALE
// );
// Configure Props
pResX.SetValue(300);
pResY.SetValue(300);
// var resolutions = pResX.SubTypeValues;
// foreach( var res in resolutions )
// {
// Console.WriteLine( res );
// }
// device.Properties!.Cast<Property>()
// .FirstOrDefault( p => p.PropertyID == WIAConst.DPS_DOCUMENT_HANDLING_CAPABILITIES );
// foreach( WIA.Property prop in device.Properties )
// {
// int id = prop.PropertyID;
// Console.WriteLine( id );
// }
// scanner.Properties["WIA_DPS_DOCUMENT_HANDLING_CAPABILITIES"];
string scanFolder = Path.Combine(Path.GetTempPath(), "scan-" + Guid.NewGuid());
int imgCount = 1;
Console.WriteLine($"Scanning image #{imgCount}...");
ImageFile img = null !;
try
{
img = (ImageFile)scanner.Transfer(FormatID.wiaFormatBMP);
}
catch (COMException ex)
{
var code = (WIAComErrorCode)ex.ErrorCode;
// if( code == WIAComErrorCode.)
// Environment.Exit( 0 );
ErrorExit($"Error while scanning page (0x{code:X}) : {code.ToMessage()}");
}
Console.WriteLine("Saving File...");
string name = $"img_{imgCount:D4}.bmp";
string path = Path.Combine(scanFolder, name);
imgCount++;
img.SaveFile(path);
}
public RenderController(DeviceManager deviceManager)
{
_deviceManager = deviceManager;
}
public async Task Run(Target target)
{
Devices = new List <Device> {
};
var logger = Logger.Instance();
if (target == Target.stm32)
{
var deviceFactory = new FilterDeviceDefinition(0x0483, 0xDF11) // STM32 Bootloader
.CreateWindowsUsbDeviceFactory(classGuid: WindowsDeviceConstants.GUID_DEVINTERFACE_USB_DEVICE);
var devices = await deviceFactory.GetConnectedDeviceDefinitionsAsync();
var device = devices.FirstOrDefault();
if (device != null)
{
Devices.Add(new Device(device));
}
}
if (target == Target.teensy)
{
var deviceFactory = new FilterDeviceDefinition(0x16C0, 0x0478) // Teensy Bootloader
.CreateWindowsHidDeviceFactory(classGuid: WindowsDeviceConstants.GUID_DEVINTERFACE_HID);
var devices = await deviceFactory.GetConnectedDeviceDefinitionsAsync();
var device = devices.FirstOrDefault();
if (device != null)
{
Devices.Add(new Device(device));
}
}
if (target == Target.all)
{
var hidGuid = WindowsDeviceConstants.GUID_DEVINTERFACE_HID;
var usbGuid = WindowsDeviceConstants.GUID_DEVINTERFACE_USB_DEVICE;
var deviceFactories = new List <IDeviceFactory>
{
new FilterDeviceDefinition(0x16C0, 0x0478) // Teensy Bootloader
.CreateWindowsHidDeviceFactory(classGuid: hidGuid),
new FilterDeviceDefinition(0x0483, 0xDF11) // STM32 Bootloader
.CreateWindowsUsbDeviceFactory(classGuid: usbGuid),
new FilterDeviceDefinition(0xFEED, 0x1307) // Legacy Ids Ergodox EZ
.CreateWindowsHidDeviceFactory(classGuid: hidGuid),
new FilterDeviceDefinition(0xFEED, 0x6060) // Legacy Ids Planck EZ
.CreateWindowsHidDeviceFactory(classGuid: hidGuid),
new FilterDeviceDefinition(0x3297, 0x1969) // Moonlander MK1
.CreateWindowsHidDeviceFactory(classGuid: hidGuid),
new FilterDeviceDefinition(0x3297, 0x4974) // Ergodox EZ Standard
.CreateWindowsHidDeviceFactory(classGuid: hidGuid),
new FilterDeviceDefinition(0x3297, 0x4975) // Ergodox EZ Shine
.CreateWindowsHidDeviceFactory(classGuid: hidGuid),
new FilterDeviceDefinition(0x3297, 0x4976) // Ergodox EZ Glow
.CreateWindowsHidDeviceFactory(classGuid: hidGuid),
new FilterDeviceDefinition(0x3297, 0xC6CE) // Planck EZ Standard
.CreateWindowsHidDeviceFactory(classGuid: hidGuid),
new FilterDeviceDefinition(0x3297, 0xC6CF) // Planck EZ Glow
.CreateWindowsHidDeviceFactory(classGuid: hidGuid),
};
var deviceManager = new DeviceManager(deviceFactories, null);
var devices = await deviceManager.GetConnectedDeviceDefinitionsAsync();
// The device manager returns an entry for each endpoints
// as a result duplicates are removed by checking against
// the pid / vid of previously enumerated devices.
foreach (var device in devices)
{
var match = Devices.FindIndex((_dev) => _dev.Info.VendorId == device.VendorId && _dev.Info.ProductId == device.ProductId);
if (match == -1)
{
Devices.Add(new Device(device));
}
}
}
}
public TestUtil()
{
DeviceManager = new DeviceManager();
ServiceManager = new ServiceManager();
}
// Use this for initialization
private void Awake()
{
Application.runInBackground = true;
deviceManager = DeviceManager.getInstance();
}
/// <summary>
/// Initializes the element.
/// </summary>
/// <param name="deviceManager">The device manager.</param>
public virtual void Initialize(DeviceManager deviceManager)
{
}
public static IKeyed GetUiDevice(DeviceConfig config)
{
var comm = CommFactory.GetControlPropertiesConfig(config);
var typeName = config.Type.ToLower();
EssentialsTouchpanelController panelController = null;
var props = JsonConvert.DeserializeObject <CrestronTouchpanelPropertiesConfig>(config.Properties.ToString());
if (typeName.Contains("dge"))
{
Dge100 dgeDevice = null;
if (typeName == "dge100")
{
dgeDevice = new Dge100(comm.IpIdInt, Global.ControlSystem);
}
else if (typeName == "dmdge200c")
{
dgeDevice = new DmDge200C(comm.IpIdInt, Global.ControlSystem);
}
if (dgeDevice == null)
{
Debug.Console(1, "Unable to create DGE device");
return(null);
}
var dgeController = new DgeController(config.Key + "-comPorts", config.Name, dgeDevice, config, props);
DeviceManager.AddDevice(dgeController);
panelController = new EssentialsTouchpanelController(config.Key, config.Name, dgeController.DigitalGraphicsEngine,
props.ProjectName, props.SgdFile);
}
else
{
panelController = new EssentialsTouchpanelController(config.Key, config.Name, config.Type, props, comm.IpIdInt);
}
panelController.AddPostActivationAction(() =>
{
var mainDriver = new EssentialsPanelMainInterfaceDriver(panelController.Panel, props);
// Then the sub drivers
// spin up different room drivers depending on room type
var room = DeviceManager.GetDeviceForKey(props.DefaultRoomKey);
if (room is EssentialsHuddleSpaceRoom)
{
// Header Driver
Debug.Console(0, panelController, "Adding header driver");
mainDriver.HeaderDriver = new EssentialsHeaderDriver(mainDriver, props);
// AV Driver
Debug.Console(0, panelController, "Adding huddle space AV driver");
var avDriver = new EssentialsHuddlePanelAvFunctionsDriver(mainDriver, props);
avDriver.DefaultRoomKey = props.DefaultRoomKey;
mainDriver.AvDriver = avDriver;
avDriver.CurrentRoom = room as EssentialsHuddleSpaceRoom;
// Environment Driver
if (avDriver.CurrentRoom.PropertiesConfig.Environment != null && avDriver.CurrentRoom.PropertiesConfig.Environment.DeviceKeys.Count > 0)
{
Debug.Console(0, panelController, "Adding environment driver");
mainDriver.EnvironmentDriver = new EssentialsEnvironmentDriver(mainDriver, props);
mainDriver.EnvironmentDriver.GetDevicesFromConfig(avDriver.CurrentRoom.PropertiesConfig.Environment);
}
mainDriver.HeaderDriver.SetupHeaderButtons(avDriver, avDriver.CurrentRoom);
panelController.LoadAndShowDriver(mainDriver); // This is a little convoluted.
if (panelController.Panel is TswFt5ButtonSystem)
{
var tsw = panelController.Panel as TswFt5ButtonSystem;
// Wire up hard keys
tsw.Power.UserObject = new Action <bool>(b => { if (!b)
{
avDriver.PowerButtonPressed();
}
});
//tsw.Home.UserObject = new Action<bool>(b => { if (!b) HomePressed(); });
if (mainDriver.EnvironmentDriver != null)
{
tsw.Lights.UserObject = new Action <bool>(b =>
{
if (!b)
{
//mainDriver.AvDriver.PopupInterlock.ShowInterlockedWithToggle(mainDriver.EnvironmentDriver.BackgroundSubpageJoin);
mainDriver.EnvironmentDriver.Toggle();
}
});
}
tsw.Up.UserObject = new Action <bool>(avDriver.VolumeUpPress);
tsw.Down.UserObject = new Action <bool>(avDriver.VolumeDownPress);
}
}
//else if (room is EssentialsPresentationRoom)
//{
// Debug.Console(0, panelController, "Adding presentation room driver");
// var avDriver = new EssentialsPresentationPanelAvFunctionsDriver(mainDriver, props);
// avDriver.CurrentRoom = room as EssentialsPresentationRoom;
// avDriver.DefaultRoomKey = props.DefaultRoomKey;
// mainDriver.AvDriver = avDriver ;
// mainDriver.HeaderDriver = new EssentialsHeaderDriver(mainDriver, props);
// panelController.LoadAndShowDriver(mainDriver);
// if (panelController.Panel is TswFt5ButtonSystem)
// {
// var tsw = panelController.Panel as TswFt5ButtonSystem;
// // Wire up hard keys
// tsw.Power.UserObject = new Action<bool>(b => { if (!b) avDriver.PowerButtonPressed(); });
// //tsw.Home.UserObject = new Action<bool>(b => { if (!b) HomePressed(); });
// tsw.Up.UserObject = new Action<bool>(avDriver.VolumeUpPress);
// tsw.Down.UserObject = new Action<bool>(avDriver.VolumeDownPress);
// }
//}
else if (room is EssentialsHuddleVtc1Room)
{
Debug.Console(0, panelController, "Adding huddle space VTC AV driver");
// Header Driver
mainDriver.HeaderDriver = new EssentialsHeaderDriver(mainDriver, props);
// AV Driver
var avDriver = new EssentialsHuddleVtc1PanelAvFunctionsDriver(mainDriver, props);
var codecDriver = new PepperDash.Essentials.UIDrivers.VC.EssentialsVideoCodecUiDriver(panelController.Panel, avDriver,
(room as EssentialsHuddleVtc1Room).VideoCodec, mainDriver.HeaderDriver);
avDriver.SetVideoCodecDriver(codecDriver);
avDriver.DefaultRoomKey = props.DefaultRoomKey;
mainDriver.AvDriver = avDriver;
avDriver.CurrentRoom = room as EssentialsHuddleVtc1Room;
// Environment Driver
if (avDriver.CurrentRoom.PropertiesConfig.Environment != null && avDriver.CurrentRoom.PropertiesConfig.Environment.DeviceKeys.Count > 0)
{
Debug.Console(0, panelController, "Adding environment driver");
mainDriver.EnvironmentDriver = new EssentialsEnvironmentDriver(mainDriver, props);
mainDriver.EnvironmentDriver.GetDevicesFromConfig(avDriver.CurrentRoom.PropertiesConfig.Environment);
}
mainDriver.HeaderDriver.SetupHeaderButtons(avDriver, avDriver.CurrentRoom);
panelController.LoadAndShowDriver(mainDriver); // This is a little convoluted.
if (panelController.Panel is TswFt5ButtonSystem)
{
var tsw = panelController.Panel as TswFt5ButtonSystem;
// Wire up hard keys
tsw.Power.UserObject = new Action <bool>(b => { if (!b)
{
avDriver.EndMeetingPress();
}
});
//tsw.Home.UserObject = new Action<bool>(b => { if (!b) HomePressed(); });
if (mainDriver.EnvironmentDriver != null)
{
tsw.Lights.UserObject = new Action <bool>(b =>
{
if (!b)
{
//mainDriver.AvDriver.PopupInterlock.ShowInterlockedWithToggle(mainDriver.EnvironmentDriver.BackgroundSubpageJoin);
mainDriver.EnvironmentDriver.Toggle();
}
});
}
tsw.Up.UserObject = new Action <bool>(avDriver.VolumeUpPress);
tsw.Down.UserObject = new Action <bool>(avDriver.VolumeDownPress);
}
}
else
{
Debug.Console(0, panelController, "ERROR: Cannot load AvFunctionsDriver for room '{0}'", props.DefaultRoomKey);
}
});
return(panelController);
}
public Monitor(DeviceManager deviceManager)
{
_deviceManager = deviceManager;
}
//-----------------------------------------------------------
private void Run(Options opts)
{
// ListScanners();
// For now just assume there's 1 scanner
var deviceManager = new DeviceManager();
var devices = deviceManager.DeviceInfos !
.Cast <DeviceInfo>()
.Where(d => d != null && d.Type == WiaDeviceType.ScannerDeviceType)
.ToArray();
Device device = devices[0].Connect();
// Use the feeder
var pHandlingCaps = device.Properties.Get(WIAPropID.DPS_DOCUMENT_HANDLING_CAPABILITIES);
var pHandlingSelect = device.Properties.Get(WIAPropID.DPS_DOCUMENT_HANDLING_SELECT);
var pPageSize = device.Properties.Get(WIAPropID.IPS_PAGE_SIZE);
pHandlingSelect.SetValue(WIAIPSHandlingSelect.FEEDER);
pPageSize.SetValue(WIAPageSize.LETTER);
// Grab the scanner item
var scanner = device.Items[1] !;
// DumpDeviceProps( device );
// DumpScannerProps( scanner );
// Start scanning
string scanFolder = Path.Combine(Path.GetTempPath(), "scan-" + Guid.NewGuid());
new DirectoryInfo(scanFolder).Create();
int imgCount = 1;
StrList imgPaths = new();
Log($"Scan path: {scanFolder}");
for ( ;;)
{
ConfigScanner(device, scanner, opts.Resolution);
Log($"Scanning image #{imgCount}...");
string path = Path.Combine(scanFolder, $"img_{imgCount:D4}.png");
imgCount++;
if (!ScanNextImage(scanner, path))
{
break;
}
imgPaths.Add(path);
}
if (imgPaths.Count < 1)
{
ErrorExit("No images to scan.");
}
// Load images and convert to PDF
Log("Generating PDF...");
ToPdf(imgPaths, Path.Combine(scanFolder, "scan.pdf"), opts);
Log("Done.");
Log($"PDF file at: {opts.OutPath}");
}
private void reloadDevicesToolStripMenuItem_Click(object sender, EventArgs e)
{
DeviceManager.LoadDevicesFromFile();
RefreshUsbDevices();
}
/// <summary>
/// Get all Devices of current Frame-Grabber
/// </summary>
/// <returns></returns>
public static DeviceInformations[] GetAttachedDevices(DeviceIdentity id)
{
return(DeviceManager.GetAttachedDevices(id));
}
public virtual JObject Login(HttpContext context)
{
YZRequest request = new YZRequest(context);
string lang = request.GetString("lang", "zh-chs");
string uid = request.GetString("uid");
string pwd = request.GetString("pwd", null);
bool isapp = request.GetBool("isapp");
string cordova = request.GetString("cordova");
string model = request.GetString("model");
string name = request.GetString("name", model);
string platform = request.GetString("platform");
string uuid = request.GetString("uuid");
string version = request.GetString("version");
string manufacturer = request.GetString("manufacturer");
bool isVirtual = request.GetBool("isVirtual", false);
string serial = request.GetString("serial");
bool validationPanelShow = request.GetBool("validationPanelShow");
string smsGuid = request.GetString("smsGuid", null);
string vcode = request.GetString("vcode", null);
string keystore = request.GetString("keystore", null);
//用私钥解密
if (!String.IsNullOrEmpty(keystore))
{
string privateKey = (string)YZTempStorageManager.CurrentStore.Load(keystore);
RSACryptoServiceProvider rsaProvider = new RSACryptoServiceProvider(1024);
rsaProvider.FromXmlString(privateKey);
uid = System.Text.Encoding.UTF8.GetString(rsaProvider.Decrypt(Convert.FromBase64String(uid), false));
pwd = System.Text.Encoding.UTF8.GetString(rsaProvider.Decrypt(Convert.FromBase64String(pwd), false));
}
Device device = null;
SMS sms = null;
JObject rv;
if (isapp)
{
using (IYZDbProvider provider = YZDbProviderManager.DefaultProvider)
{
using (IDbConnection cn = provider.OpenConnection())
{
device = DeviceManager.TryGetDevice(provider, cn, uid, uuid);
}
}
//设备禁用
if (device != null && device.Disabled)
{
rv = new JObject();
rv[YZJsonProperty.success] = false;
rv["prompt"] = true;
rv[YZJsonProperty.errorMessage] = Resources.YZMobile.Aspx_Auth_DeviceDisabled;
return(rv);
}
//账号保护
if (device == null)
{
bool IsAppLoginProtected;
using (BPMConnection cn = new BPMConnection())
{
cn.WebOpenAnonymous();
IsAppLoginProtected = User.IsAppLoginProtected(cn, uid);
}
if (IsAppLoginProtected)
{
if (!validationPanelShow)
{
rv = new JObject();
rv[YZJsonProperty.success] = false;
rv["needSmsValidation"] = true;
rv[YZJsonProperty.errorMessage] = Resources.YZMobile.Aspx_Auth_StrangerDevice;
return(rv);
}
if (String.IsNullOrEmpty(smsGuid))
{
throw new Exception(Resources.YZMobile.Aspx_Auth_GetValidationCodeFirst);
}
using (IYZDbProvider provider = YZDbProviderManager.DefaultProvider)
{
using (IDbConnection cn = provider.OpenConnection())
{
sms = SMSManager.TryGetSMS(provider, cn, smsGuid);
}
}
if (sms == null)
{
throw new Exception(Resources.YZMobile.Aspx_Auth_GetValidationCodeAgain);
}
if (sms.ValidationCode != vcode)
{
throw new Exception(Resources.YZMobile.Aspx_Auth_IncorrectValidationCode);
}
if (sms.ExpireDate < DateTime.Now)
{
throw new Exception(Resources.YZMobile.Aspx_Auth_GetValidationCodeAgain);
}
}
}
}
if (String.IsNullOrEmpty(uid) /*|| String.IsNullOrEmpty(password)*/)
{
throw new Exception(Resources.YZStrings.Aspx_Login_EnterAccountTip);
}
string realAccount = null;
string token = null;
if (!BPMConnection.Authenticate(YZAuthHelper.BPMServerName, YZAuthHelper.BPMServerPort, uid, pwd, out realAccount, out token))
{
throw new Exception(Resources.YZStrings.Aspx_Login_Fail);
}
YZAuthHelper.SetAuthCookie(realAccount, token);
YZAuthHelper.SetLangSession(YZCultureInfoParse.Parse(lang, YZCultureInfoParse.DefauleCultureInfo).LCID);
YZAuthHelper.ClearLogoutFlag();
rv = this.GenLoginResult(realAccount, false);
//登录成功后处理
if (isapp)
{
using (IYZDbProvider provider = YZDbProviderManager.DefaultProvider)
{
using (IDbConnection cn = provider.OpenConnection())
{
if (device != null)
{
device.LastLogin = DateTime.Now;
DeviceManager.Update(provider, cn, device);
}
else
{
device = new Device();
device.Account = realAccount;
device.UUID = uuid;
device.Name = name;
device.Model = model;
device.Description = String.Format("{0} {1} {2} {3}", manufacturer, model, platform, version);
device.Disabled = false;
device.RegisterAt = DateTime.Now;
device.LastLogin = device.RegisterAt;
DeviceManager.Insert(provider, cn, device);
}
if (sms != null)
{
SMSManager.DeleteSMS(provider, cn, sms.ItemGUID);
}
}
}
}
return(rv);
}
public override void ChangeDeviceComInfo(int devid, int oldCom, int oldBaud, int newCom, int newBaud)
{
IRunDevice dev = DeviceManager.GetDevice(devid);
if (dev == null)
{
Logger.Info(true, String.Format("{0}号设备，改变串口信息不存在", devid.ToString()));
}
else
{
int oldComPort = oldCom;
int oldComBaud = oldBaud;
int newComPort = newCom;
int newComBaud = newBaud;
bool success = true;
if (dev.CommunicateType == CommunicateType.COM)
{
if (oldComPort != newComPort)
{
#region 对旧串口进行处理
//--------------对旧串口进行处理----------------//
IRunDevice[] oldComDevList = DeviceManager.GetDevices(oldComPort.ToString(), CommunicateType.COM);
int oldComDevCount = oldComDevList.Count((d) => d.GetHashCode() != dev.GetHashCode()); //当前串口不等于当前设备的设备数
if (oldComDevCount <= 0) //先修改设备的串口参数，该串口没有可用的设备
{
string oldKey = ComUtils.PortToString(oldComPort);
IController oldComController = ControllerManager.GetController(oldKey);
if (oldComController != null)
{
if (ControllerManager.RemoveController(oldComController.Key))
{
oldComController.StopController();
oldComController.Dispose();
IComSession comChannel = (IComSession)((IComController)oldComController).ComChannel;
comChannel.Close();
comChannel.COMOpen -= ComChannel_COMOpen;
comChannel.COMClose -= ComChannel_COMClose;
comChannel.COMError -= ComChannel_COMError;
if (ChannelManager.RemoveChannel(comChannel.Key))
{
comChannel.Close();
comChannel.Dispose();
}
}
else
{
success = false;
}
}
else
{
Logger.Info(true, "该设备的串口控制器为空");
}
}
#endregion
#region 对新串口进行处理
string newKey = ComUtils.PortToString(newComPort);
//--------------对新串口进行处理----------------//
bool newComControllerExist = ControllerManager.ContainController(newKey);
if (!newComControllerExist)
{
IChannel channel = ChannelManager.GetChannel(newKey);
if (channel == null)
{
IComSession comChannel = new ComSession(newComPort, newComBaud);
comChannel.Setup(this);
comChannel.Initialize();
comChannel.COMOpen += ComChannel_COMOpen;
comChannel.COMClose += ComChannel_COMClose;
comChannel.COMError += ComChannel_COMError;
comChannel.Open();
channel = (IChannel)comChannel;
ChannelManager.AddChannel(comChannel.Key, channel);
}
IController controller = ControllerManager.GetController(newKey);
if (controller == null)
{
controller = new ComController((IComSession)channel);
controller.Setup(this);
if (ControllerManager.AddController(controller.Key, controller))
{
controller.StartController();
}
}
else
{
IComController comController = (IComController)controller;
if (comController.ComChannel.GetHashCode() != channel.GetHashCode())
{
comController.ComChannel = (IComSession)channel;
}
}
}
if (success)
{
dev.DeviceParameter.COM.Port = newComPort;
Logger.Info(true, String.Format("{0},串口从{1}改为{2},成功", dev.DeviceParameter.DeviceName, oldComPort.ToString(), newComPort.ToString()));
}
else
{
Logger.Info(true, String.Format("{0},串口从{1}改为{2},失败", dev.DeviceParameter.DeviceName, oldComPort.ToString(), newComPort.ToString()));
}
#endregion
}
else
{
#region 波特率
if (oldComBaud != newComBaud)
{
IComSession comIO = (IComSession)ChannelManager.GetChannel(ComUtils.PortToString(oldComPort));
if (comIO != null)
{
success = comIO.Settings(newComBaud);
if (success)
{
dev.DeviceParameter.COM.Baud = newComBaud;
Logger.Info(true, String.Format("{0},串口{1}的波特率从{2}改为{3},成功", dev.DeviceParameter.DeviceName, oldComPort.ToString(), oldComBaud.ToString(), newComBaud.ToString()));
}
else
{
Logger.Info(true, String.Format("{0},串口{1}的波特率从{2}改为{3},失败", dev.DeviceParameter.DeviceName, oldComPort.ToString(), oldComBaud.ToString(), newComBaud.ToString()));
}
}
}
#endregion
}
}
else
{
Logger.Info(true, String.Format("{0},不是串口类型的设备", dev.DeviceParameter.DeviceName));
}
}
}
public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
{
var joinMap = new DmBladeChassisControllerJoinMap(joinStart);
var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
if (!string.IsNullOrEmpty(joinMapSerialized))
{
joinMap = JsonConvert.DeserializeObject <DmBladeChassisControllerJoinMap>(joinMapSerialized);
}
bridge.AddJoinMap(Key, joinMap);
Debug.Console(1, this, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline.JoinNumber]);
// Link up outputs
for (uint i = 1; i <= Chassis.NumberOfOutputs; i++)
{
var ioSlot = i;
var ioSlotJoin = ioSlot - 1;
// Control
trilist.SetUShortSigAction(joinMap.OutputVideo.JoinNumber + ioSlotJoin, o => ExecuteSwitch(o, ioSlot, eRoutingSignalType.Video));
if (TxDictionary.ContainsKey(ioSlot))
{
Debug.Console(2, "Creating Tx Feedbacks {0}", ioSlot);
var txKey = TxDictionary[ioSlot];
var basicTxDevice = DeviceManager.GetDeviceForKey(txKey) as BasicDmTxControllerBase;
var advancedTxDevice = basicTxDevice as DmTxControllerBase;
if (Chassis is DmMd128x128 || Chassis is DmMd64x64)
{
InputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline.JoinNumber + ioSlotJoin]);
}
else
{
if (advancedTxDevice != null)
{
advancedTxDevice.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline.JoinNumber + ioSlotJoin]);
Debug.Console(2, "Linking Tx Online Feedback from Advanced Transmitter at input {0}", ioSlot);
}
else if (InputEndpointOnlineFeedbacks[ioSlot] != null)
{
Debug.Console(2, "Linking Tx Online Feedback from Input Card {0}", ioSlot);
InputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.InputEndpointOnline.JoinNumber + ioSlotJoin]);
}
}
if (basicTxDevice != null && advancedTxDevice == null)
{
trilist.BooleanInput[joinMap.TxAdvancedIsPresent.JoinNumber + ioSlotJoin].BoolValue = true;
}
if (advancedTxDevice != null)
{
advancedTxDevice.AnyVideoInput.VideoStatus.VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus.JoinNumber + ioSlotJoin]);
}
else
{
Debug.Console(1, "Setting up actions and feedbacks on input card {0}", ioSlot);
VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus.JoinNumber + ioSlotJoin]);
var inputPort = InputPorts[string.Format("inputCard{0}--hdmiIn", ioSlot)];
if (inputPort != null)
{
Debug.Console(1, "Port value for input card {0} is set", ioSlot);
var port = inputPort.Port;
if (port != null)
{
if (port is HdmiInputWithCEC)
{
Debug.Console(1, "Port is HdmiInputWithCec");
var hdmiInPortWCec = port as HdmiInputWithCEC;
if (hdmiInPortWCec.HdcpSupportedLevel != eHdcpSupportedLevel.Unknown)
{
SetHdcpStateAction(true, hdmiInPortWCec, joinMap.HdcpSupportState.JoinNumber + ioSlotJoin, trilist);
}
InputCardHdcpCapabilityFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.HdcpSupportState.JoinNumber + ioSlotJoin]);
if (InputCardHdcpCapabilityTypes.ContainsKey(ioSlot))
{
trilist.UShortInput[joinMap.HdcpSupportCapability.JoinNumber + ioSlotJoin].UShortValue = (ushort)InputCardHdcpCapabilityTypes[ioSlot];
}
else
{
trilist.UShortInput[joinMap.HdcpSupportCapability.JoinNumber + ioSlotJoin].UShortValue = 1;
}
}
}
}
else
{
inputPort = InputPorts[string.Format("inputCard{0}--dmIn", ioSlot)];
if (inputPort != null)
{
var port = inputPort.Port;
if (port is DMInputPortWithCec)
{
Debug.Console(1, "Port is DMInputPortWithCec");
var dmInPortWCec = port as DMInputPortWithCec;
SetHdcpStateAction(PropertiesConfig.InputSlotSupportsHdcp2[ioSlot], dmInPortWCec, joinMap.HdcpSupportState.JoinNumber + ioSlotJoin, trilist);
InputCardHdcpCapabilityFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.HdcpSupportState.JoinNumber + ioSlotJoin]);
if (InputCardHdcpCapabilityTypes.ContainsKey(ioSlot))
{
trilist.UShortInput[joinMap.HdcpSupportCapability.JoinNumber + ioSlotJoin].UShortValue = (ushort)InputCardHdcpCapabilityTypes[ioSlot];
}
else
{
trilist.UShortInput[joinMap.HdcpSupportCapability.JoinNumber + ioSlotJoin].UShortValue = 1;
}
}
}
}
}
}
else
{
VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus.JoinNumber + ioSlotJoin]);
var inputPort = InputPorts[string.Format("inputCard{0}--hdmiIn", ioSlot)];
if (inputPort != null)
{
var hdmiPort = inputPort.Port as EndpointHdmiInput;
if (hdmiPort != null)
{
SetHdcpStateAction(true, hdmiPort, joinMap.HdcpSupportState.JoinNumber + ioSlotJoin, trilist);
InputCardHdcpCapabilityFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.HdcpSupportState.JoinNumber + ioSlotJoin]);
}
}
}
if (RxDictionary.ContainsKey(ioSlot))
{
Debug.Console(2, "Creating Rx Feedbacks {0}", ioSlot);
//var rxKey = RxDictionary[ioSlot];
//var rxDevice = DeviceManager.GetDeviceForKey(rxKey) as DmRmcControllerBase;
//var hdBaseTDevice = DeviceManager.GetDeviceForKey(rxKey) as DmHdBaseTControllerBase;
//if (hdBaseTDevice != null) {
OutputEndpointOnlineFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.OutputEndpointOnline.JoinNumber + ioSlotJoin]);
//}
//else if (rxDevice != null) {
// rxDevice.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.OutputEndpointOnline + ioSlot]);
//}
}
// Feedback
VideoOutputFeedbacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.OutputVideo.JoinNumber + ioSlotJoin]);
OutputNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.OutputNames.JoinNumber + ioSlotJoin]);
InputNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.InputNames.JoinNumber + ioSlotJoin]);
OutputVideoRouteNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.OutputCurrentVideoInputNames.JoinNumber + ioSlotJoin]);
}
}
/// <summary>
/// Neutral Language Processing
/// </summary>
private async void NLP(string sentence, bool speech = false)
{
if (sentence != null && sentence != "")
{
#region Pre-Processing
if (IsDone)
{
textBox1.Document.Blocks.Clear(); image.Source = null;
}
StopCommandWaiting.Invoke(this, new EventArgs());
textBox1.AppendText(sentence + "\n"); this.textBox1.ScrollToEnd();
var Received = lus.TextRequest(sentence);
#endregion
if (Received.Result.ActionIncomplete)
{
#region ActionIncomplete
await HistoryWrite(Received.Result.Fulfillment.Speech, speech);
if (speech)
{
StartSpeak.RaiseEvent(new RoutedEventArgs(ButtonBase.ClickEvent));
}
return;
}
#endregion
else
{
#region ActionComplete
DeviceManager devman = new DeviceManager();
switch (Received.Result.Action)
{
#region WebSearch
case "web.search":
if (Received.Result.Parameters.ContainsKey("q"))
{
Process.Start(String.Concat("https://www.google.com/search?q=" + Received.Result.Parameters["q"]));
}
break;
#endregion
#region Smarthome
case "smarthome.appliances_on":
if (Received.Result.Parameters["all"].ToString() == "true")
{
string dev;
dev = Received.Result.Parameters["appliance_name"].ToString();
if (devman.IsTypeExist(dev))
{
HistoryWrite("I will turn on all " + dev, speech);
devman.SetAll(dev, 1);
}
else
{
HistoryWrite("I can't find any " + dev, speech);
}
}
else
{
string dev;
dev = Received.Result.Parameters["appliance_name"].ToString() + Received.Result.Parameters["number"];
if (devman.IsExist(dev))
{
HistoryWrite("I will turn on the " + dev, speech);
devman.Set(dev, 1);
}
else
{
HistoryWrite("I can't find the " + dev, speech);
}
}
break;
case "smarthome.appliances_off":
if (Received.Result.Parameters["all"].ToString() == "true")
{
string dev;
dev = Received.Result.Parameters["appliance_name"].ToString();
if (devman.IsTypeExist(dev))
{
HistoryWrite("I will turn off all " + dev, speech);
devman.SetAll(dev, 0);
}
else
{
HistoryWrite("I can't find any " + dev, speech);
}
}
else
{
string dev;
dev = Received.Result.Parameters["appliance_name"].ToString() + Received.Result.Parameters["number"];
if (devman.IsExist(dev))
{
HistoryWrite("I will turn off the " + dev, speech);
devman.Set(dev, 0);
}
else
{
HistoryWrite("I can't find the " + dev, speech);
}
}
break;
#endregion
#region Clock
case "clock.date":
if (Received.Result.Parameters["date"].ToString() != null)
{
HistoryWrite("It's " + Received.Result.Parameters["date"], speech);
}
else
{
HistoryWrite("It's " + DateTime.Now.ToShortDateString(), speech);
}
break;
case "clock.time":
HistoryWrite("It's " + DateTime.Now.ToShortTimeString(), speech);
break;
#endregion
#region Weather
case "weather.search":
var WE = new Weather();
DateTime Now = DateTime.Now;
DateTime Converted = DateTime.Now;
string location = "autoip";
if (Received.Result.Parameters.ContainsKey("geo-city") && Received.Result.Parameters["geo-city"].ToString() != "")
{
location = Received.Result.Parameters["geo-city"].ToString();
}
else
{
location = "autoip";
}
string time = "present";
if (Received.Result.Parameters.ContainsKey("date"))
{
DateTime.TryParseExact(Received.Result.Parameters["date"].ToString(), "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out Converted);
if (Now < Converted)
{
time = "future";
}
}
if (time == "present")
{
var data = WE.GetCurrentWeather(location);
if (data == null)
{
HistoryWrite(Received.Result.Fulfillment.Speech);
}
else
{
if (location == "autoip")
{
HistoryWrite("The current weather at current location is " + data["weather"].ToString().ToLower() + " with the temperature of " + data["temp_c"].ToString() + " C.", speech);
}
else
{
HistoryWrite("The current weather in " + location + " is " + data["weather"].ToString().ToLower() + " with the temperature of " + data["temp_c"].ToString() + " C.", speech);
}
BitmapImage bi3 = new BitmapImage();
bi3.BeginInit();
bi3.UriSource = new Uri(data["icon_url"].ToString(), UriKind.Absolute);
bi3.EndInit();
image.Stretch = Stretch.Uniform;
image.Source = bi3;
}
}
if (time == "future")
{
var data = WE.GetForecastWeather(Converted, location);
if (data == null)
{
HistoryWrite(Received.Result.Fulfillment.Speech);
}
else
{
if (location == "autoip")
{
HistoryWrite("The weather at current location on " + data["date"].ToString() + " will be " + data["conditions"].ToString().ToLower() + " with the temperature of " + data["low_c"].ToString() + " C at lowest and " + data["high_c"] + " C at highest.", speech);
}
else
{
HistoryWrite("The weather in " + location + " on " + data["date"].ToString() + " will be " + data["conditions"].ToString().ToLower() + " with the temperature of " + data["low_c"].ToString() + " C at lowest and " + data["high_c"] + " C at highest.", speech);
}
BitmapImage bi3 = new BitmapImage();
bi3.BeginInit();
bi3.UriSource = new Uri(data["icon_url"].ToString(), UriKind.Absolute);
bi3.EndInit();
image.Stretch = Stretch.Uniform;
image.Source = bi3;
}
}
break;
#endregion
#region Easteregg
case "easteregg.singing":
int Choice = Choices.Next() % 3;
var path = System.IO.Path.Combine("Singing", Convert.ToString(Choice) + ".wav");
SoundPlayer player = new SoundPlayer(path);
player.Play();
if (Choice == 1)
{
HistoryWrite("You are my sunshine, my only sunshine. You make me happy, when skies are gray.");
}
else if (Choice == 2)
{
HistoryWrite("Oh he floats through the air with the greatest of ease, this daring young man on the flying trapeze.");
}
else
{
HistoryWrite("Twinkle twinkle little star, how I wonder what you are!");
}
break;
#endregion
#region Reminder
case "reminder.add":
BitmapImage bir = new BitmapImage();
bir.BeginInit();
bir.UriSource = new Uri(@"\Assets\Reminder.png", UriKind.Relative);
bir.EndInit();
image.Stretch = Stretch.Uniform;
image.Source = bir;
string summary = Received.Result.Parameters["summary"].ToString();
time = Received.Result.Parameters["time"].ToString();
DateTime converted = new DateTime();
if (time.Contains("/"))
{
/*if (!time.Contains("T"))
* time = time.Substring(time.IndexOf('/') + 1);
* else */
time = time.Remove(time.IndexOf('/'));
time = time.Trim('/');
}
if (time.Contains("T"))
{
DateTime.TryParseExact(time, "yyyy-MM-dd\\THH:mm:ss\\Z", CultureInfo.InvariantCulture, DateTimeStyles.None, out converted);
}
else
{
if (time.Contains("-"))
{
DateTime.TryParseExact(time, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out converted);
}
else
{
DateTime.TryParseExact(time, "HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out converted);
}
}
while (converted < DateTime.Now)
{
converted = converted.AddDays(1);
}
summary = summary.Trim();
item.reminder = summary;
item.datetime = converted;
item.Notified = false;
string cvt;
if (converted.Date > DateTime.Now.Date)
{
cvt = converted.ToString("dddd, MMMM dd, yyyy h:mm tt");
}
else
{
cvt = converted.ToShortTimeString();
}
await HistoryWrite("I'll remind you to " + summary + " on " + cvt + ". Ready to confirm?", speech);
if (speech)
{
Dispatcher.Invoke((Action)(() =>
{
StartSpeak_Click(this, new RoutedEventArgs());
}));
}
IsDone = false;
return;
case "reminder.confirm":
if (item != new Reminder())
{
ReminderManager.SaveReminder(item);
HistoryWrite(Received.Result.Fulfillment.Speech, speech);
item = new Reminder();
}
else
{
HistoryWrite("I'm not sure what you said.", speech);
}
IsDone = true;
break;
case "reminder.cancel":
item = new Reminder();
HistoryWrite(Received.Result.Fulfillment.Speech, speech);
break;
#endregion
#region Location
case "location.current":
string loc = Location.GetCurrentAddress();
if (loc != null)
{
HistoryWrite("We are at " + loc + " .", speech);
}
else
{
HistoryWrite(Received.Result.Fulfillment.Speech, speech);
}
break;
#endregion
#region History
case "history.event":
List <Dictionary <string, object> > result = null;
DateTime ChosenDate = new DateTime();
bool IsToday = true;
if (Received.Result.Parameters["date"].ToString() == "")
{
result = History.GetHistory(DateTime.Now);
}
else
{
DateTime.TryParseExact(Received.Result.Parameters["date"].ToString(), "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out ChosenDate);
result = History.GetHistory(ChosenDate);
IsToday = false;
}
if (result == null)
{
HistoryWrite(Received.Result.Fulfillment.Speech, speech);
}
else
{
Choice = Choices.Next() % result.Count - 1;
var picked = result[Choice];
if (IsToday)
{
HistoryWrite("On this day in " + picked["year"].ToString() + ", " + AccentsRemover.RemoveAccents(picked["text"].ToString()), speech);
}
else
{
HistoryWrite("On " + ChosenDate.ToShortDateString() + " in " + picked["year"].ToString() + ", " + AccentsRemover.RemoveAccents(picked["text"].ToString()), speech);
}
}
break;
#endregion
#region Knowledge & Dictionary
case "dictionary.search":
string q = Received.Result.Parameters["q"].ToString();
var definition = Dictionary.Define(q);
if (definition == null)
{
HistoryWrite(Received.Result.Fulfillment.Speech, speech);
}
else
{
var First = definition[0];
HistoryWrite(q + " has a " + First.lexicalCategory + " meaning, " + First.entries[0].senses[0].definitions[0], speech, false);
HistoryWrite(q, false, true, true);
foreach (var entry in definition)
{
HistoryWrite(entry.lexicalCategory, false, true, true);
foreach (var def in entry.entries[0].senses)
{
HistoryWrite("-" + def.definitions[0], false, true, true);
}
}
}
break;
case "knowledge.search":
var knowledgeresult = Knowledge.GetKnowledge(Received.Result.Parameters["questionword"].ToString() + " " + Received.Result.Parameters["q"].ToString());
if (knowledgeresult != null)
{
//BitmapImage bitmap = new BitmapImage(new Uri(@"Assets\simple.jpg", UriKind.Relative));
BitmapImage bitmap = new BitmapImage();
BitmapImage bik = new BitmapImage();
try
{
bitmap = new BitmapImage(new Uri(knowledgeresult["simpleurl"], UriKind.Absolute));
}
catch { }
try
{
bik = new BitmapImage(new Uri(knowledgeresult["imageurl"], UriKind.Absolute));
}
catch { }
image.Source = bik;
Image simpleImage = new Image();
simpleImage.Source = bitmap;
simpleImage.Stretch = Stretch.Uniform;
InlineUIContainer container = new InlineUIContainer(simpleImage);
Paragraph paragraph = new Paragraph(container);
HistoryWrite(knowledgeresult["response"], speech);
textBox1.Document.Blocks.Add(paragraph);
}
else
{
Process.Start(String.Concat("https://www.google.com/search?q=" + Received.Result.Parameters["q"]));
}
break;
#endregion
default:
HistoryWrite(Received.Result.Fulfillment.Speech, speech);
break;
}
#endregion
}
StartCommandWaiting.Invoke(this, new EventArgs());
IsDone = true;
}
}
public static IKeyed GetDevice(DeviceConfig dc)
{
var key = dc.Key;
var name = dc.Name;
var type = dc.Type;
var properties = dc.Properties;
var propAnon = new {};
JsonConvert.DeserializeAnonymousType(dc.Properties.ToString(), propAnon);
var typeName = dc.Type.ToLower();
var groupName = dc.Group.ToLower();
if (typeName == "appletv")
{
var irCont = IRPortHelper.GetIrOutputPortController(dc);
return(new AppleTV(key, name, irCont));
}
else if (typeName == "analogwaylivecore")
{
var comm = CommFactory.CreateCommForDevice(dc);
var props = JsonConvert.DeserializeObject <AnalogWayLiveCorePropertiesConfig>(
properties.ToString());
return(new AnalogWayLiveCore(key, name, comm, props));
}
else if (typeName == "basicirdisplay")
{
var ir = IRPortHelper.GetIrPort(properties);
if (ir != null)
{
var display = new BasicIrDisplay(key, name, ir.Port, ir.FileName);
display.IrPulseTime = 200; // Set default pulse time for IR commands.
return(display);
}
}
else if (typeName == "biamptesira")
{
var comm = CommFactory.CreateCommForDevice(dc);
var props = JsonConvert.DeserializeObject <BiampTesiraFortePropertiesConfig>(
properties.ToString());
return(new BiampTesiraForteDsp(key, name, comm, props));
}
else if (typeName == "cameravisca")
{
var comm = CommFactory.CreateCommForDevice(dc);
var props = JsonConvert.DeserializeObject <Cameras.CameraPropertiesConfig>(
properties.ToString());
return(new Cameras.CameraVisca(key, name, comm, props));
}
else if (typeName == "cenrfgwex")
{
return(CenRfgwController.GetNewExGatewayController(key, name,
properties.Value <string>("id"), properties.Value <string>("gatewayType")));
}
else if (typeName == "cenerfgwpoe")
{
return(CenRfgwController.GetNewErGatewayController(key, name,
properties.Value <string>("id"), properties.Value <string>("gatewayType")));
}
else if (groupName == "discplayer") // (typeName == "irbluray")
{
if (properties["control"]["method"].Value <string>() == "ir")
{
var irCont = IRPortHelper.GetIrOutputPortController(dc);
return(new IRBlurayBase(key, name, irCont));
}
else if (properties["control"]["method"].Value <string>() == "com")
{
Debug.Console(0, "[{0}] COM Device type not implemented YET!", key);
}
}
else if (typeName == "digitallogger")
{
// var comm = CommFactory.CreateCommForDevice(dc);
var props = JsonConvert.DeserializeObject <DigitalLoggerPropertiesConfig>(
properties.ToString());
return(new DigitalLogger(key, name, props));
}
else if (typeName == "genericaudiooutwithvolume")
{
var zone = dc.Properties.Value <uint>("zone");
return(new GenericAudioOutWithVolume(key, name,
dc.Properties.Value <string>("volumeDeviceKey"), zone));
}
else if (groupName == "genericsource")
{
return(new GenericSource(key, name));
}
else if (typeName == "inroompc")
{
return(new Core.Devices.InRoomPc(key, name));
}
else if (typeName == "laptop")
{
return(new Core.Devices.Laptop(key, name));
}
else if (typeName == "mockvc")
{
return(new VideoCodec.MockVC(dc));
}
else if (typeName == "mockac")
{
var props = JsonConvert.DeserializeObject <AudioCodec.MockAcPropertiesConfig>(properties.ToString());
return(new AudioCodec.MockAC(key, name, props));
}
else if (typeName.StartsWith("ciscospark"))
{
var comm = CommFactory.CreateCommForDevice(dc);
return(new VideoCodec.Cisco.CiscoSparkCodec(dc, comm));
}
else if (typeName == "zoomroom")
{
var comm = CommFactory.CreateCommForDevice(dc);
return(new VideoCodec.ZoomRoom.ZoomRoom(dc, comm));
}
else if (typeName == "digitalinput")
{
var props = JsonConvert.DeserializeObject <IOPortConfig>(properties.ToString());
IDigitalInputPorts portDevice;
if (props.PortDeviceKey == "processor")
{
portDevice = Global.ControlSystem as IDigitalInputPorts;
}
else
{
portDevice = DeviceManager.GetDeviceForKey(props.PortDeviceKey) as IDigitalInputPorts;
}
if (portDevice == null)
{
Debug.Console(0, "ERROR: Unable to add digital input device with key '{0}'. Port Device does not support digital inputs", key);
}
else
{
var cs = (portDevice as CrestronControlSystem);
if (cs == null)
{
Debug.Console(0, "ERROR: Port device for [{0}] is not control system", props.PortDeviceKey);
return(null);
}
if (cs.SupportsVersiport)
{
Debug.Console(1, "Attempting to add Digital Input device to Versiport port '{0}'", props.PortNumber);
if (props.PortNumber > cs.NumberOfVersiPorts)
{
Debug.Console(0, "WARNING: Cannot add Vesiport {0} on {1}. Out of range",
props.PortNumber, props.PortDeviceKey);
return(null);
}
Versiport vp = cs.VersiPorts[props.PortNumber];
if (!vp.Registered)
{
var regSuccess = vp.Register();
if (regSuccess == eDeviceRegistrationUnRegistrationResponse.Success)
{
Debug.Console(1, "Successfully Created Digital Input Device on Versiport");
return(new GenericVersiportDigitalInputDevice(key, vp, props));
}
else
{
Debug.Console(0, "WARNING: Attempt to register versiport {0} on device with key '{1}' failed: {2}",
props.PortNumber, props.PortDeviceKey, regSuccess);
return(null);
}
}
}
else if (cs.SupportsDigitalInput)
{
Debug.Console(1, "Attempting to add Digital Input device to Digital Input port '{0}'", props.PortNumber);
if (props.PortNumber > cs.NumberOfDigitalInputPorts)
{
Debug.Console(0, "WARNING: Cannot register DIO port {0} on {1}. Out of range",
props.PortNumber, props.PortDeviceKey);
return(null);
}
DigitalInput digitalInput = cs.DigitalInputPorts[props.PortNumber];
if (!digitalInput.Registered)
{
if (digitalInput.Register() == eDeviceRegistrationUnRegistrationResponse.Success)
{
Debug.Console(1, "Successfully Created Digital Input Device on Digital Input");
return(new GenericDigitalInputDevice(key, digitalInput));
}
else
{
Debug.Console(0, "WARNING: Attempt to register digital input {0} on device with key '{1}' failed.",
props.PortNumber, props.PortDeviceKey);
}
}
}
}
}
else if (typeName == "relayoutput")
{
var props = JsonConvert.DeserializeObject <IOPortConfig>(properties.ToString());
IRelayPorts portDevice;
if (props.PortDeviceKey == "processor")
{
portDevice = Global.ControlSystem as IRelayPorts;
}
else
{
portDevice = DeviceManager.GetDeviceForKey(props.PortDeviceKey) as IRelayPorts;
}
if (portDevice == null)
{
Debug.Console(0, "Unable to add relay device with key '{0}'. Port Device does not support relays", key);
}
else
{
var cs = (portDevice as CrestronControlSystem);
if (cs != null)
{
// The relay is on a control system processor
if (!cs.SupportsRelay || props.PortNumber > cs.NumberOfRelayPorts)
{
Debug.Console(0, "Port Device: {0} does not support relays or does not have enough relays");
return(null);
}
}
else
{
// The relay is on another device type
if (props.PortNumber > portDevice.NumberOfRelayPorts)
{
Debug.Console(0, "Port Device: {0} does not have enough relays");
return(null);
}
}
Relay relay = portDevice.RelayPorts[props.PortNumber];
if (!relay.Registered)
{
if (relay.Register() == eDeviceRegistrationUnRegistrationResponse.Success)
{
return(new GenericRelayDevice(key, relay));
}
else
{
Debug.Console(0, "Attempt to register relay {0} on device with key '{1}' failed.", props.PortNumber, props.PortDeviceKey);
}
}
else
{
return(new GenericRelayDevice(key, relay));
}
// Future: Check if portDevice is 3-series card or other non control system that supports versiports
}
}
else if (typeName == "microphoneprivacycontroller")
{
var props = JsonConvert.DeserializeObject <Core.Privacy.MicrophonePrivacyControllerConfig>(properties.ToString());
return(new Core.Privacy.MicrophonePrivacyController(key, props));
}
else if (typeName == "roku")
{
var irCont = IRPortHelper.GetIrOutputPortController(dc);
return(new Roku2(key, name, irCont));
}
else if (groupName == "settopbox") //(typeName == "irstbbase")
{
var irCont = IRPortHelper.GetIrOutputPortController(dc);
var config = dc.Properties.ToObject <SetTopBoxPropertiesConfig>();
var stb = new IRSetTopBoxBase(key, name, irCont, config);
//stb.HasDvr = properties.Value<bool>("hasDvr");
var listName = properties.Value <string>("presetsList");
if (listName != null)
{
stb.LoadPresets(listName);
}
return(stb);
}
else if (typeName == "tvonecorio")
{
var comm = CommFactory.CreateCommForDevice(dc);
var props = JsonConvert.DeserializeObject <TVOneCorioPropertiesConfig>(
properties.ToString());
return(new TVOneCorio(key, name, comm, props));
}
else if (typeName == "glsoirccn")
{
var comm = CommFactory.GetControlPropertiesConfig(dc);
GlsOccupancySensorBase occSensor = null;
occSensor = new GlsOirCCn(comm.CresnetIdInt, Global.ControlSystem);
if (occSensor != null)
{
return(new GlsOccupancySensorBaseController(key, name, occSensor));
}
else
{
Debug.Console(0, "ERROR: Unable to create Occupancy Sensor Device. Key: '{0}'", key);
}
}
else if (typeName == "glsodtccn")
{
var comm = CommFactory.GetControlPropertiesConfig(dc);
var occSensor = new GlsOdtCCn(comm.CresnetIdInt, Global.ControlSystem);
if (occSensor != null)
{
return(new GlsOdtOccupancySensorController(key, name, occSensor));
}
else
{
Debug.Console(0, "ERROR: Unable to create Occupancy Sensor Device. Key: '{0}'", key);
}
}
else if (groupName == "lighting")
{
if (typeName == "lutronqs")
{
var comm = CommFactory.CreateCommForDevice(dc);
var props = JsonConvert.DeserializeObject <Environment.Lutron.LutronQuantumPropertiesConfig>(properties.ToString());
return(new Environment.Lutron.LutronQuantumArea(key, name, comm, props));
}
else if (typeName == "din8sw8")
{
var comm = CommFactory.GetControlPropertiesConfig(dc);
return(new Environment.Lighting.Din8sw8Controller(key, comm.CresnetIdInt));
}
}
else if (groupName == "environment")
{
if (typeName == "shadecontroller")
{
var props = JsonConvert.DeserializeObject <Core.Shades.ShadeControllerConfigProperties>(properties.ToString());
return(new Core.Shades.ShadeController(key, name, props));
}
else if (typeName == "relaycontrolledshade")
{
var props = JsonConvert.DeserializeObject <Environment.Somfy.RelayControlledShadeConfigProperties>(properties.ToString());
return(new Environment.Somfy.RelayControlledShade(key, name, props));
}
}
return(null);
}
public override void Run()
{
#region Create renderers
// Note: the renderers take care of creating their own
// device resources and listen for DeviceManager.OnInitialize
// Create a axis-grid renderer
var axisGrid = ToDispose(new AxisGridRenderer());
axisGrid.Initialize(this);
// Create and initialize the mesh renderer
var loadedMesh = Common.Mesh.LoadFromFile("Character.cmo");
List <MeshRenderer> meshes = new List <MeshRenderer>();
meshes.AddRange((from mesh in loadedMesh
select ToDispose(new MeshRenderer(mesh))));
foreach (var m in meshes)
{
m.Initialize(this);
m.World = Matrix.Identity;
}
// Set the first animation as the current animation and start clock
foreach (var m in meshes)
{
if (m.Mesh.Animations != null && m.Mesh.Animations.Any())
{
m.CurrentAnimation = m.Mesh.Animations.First().Value;
}
m.Clock.Start();
}
// Create and initialize a Direct2D FPS text renderer
var fps = ToDispose(new Common.FpsRenderer("Calibri", Color.CornflowerBlue, new Point(8, 8), 16));
fps.Initialize(this);
// Create and initialize a general purpose Direct2D text renderer
// This will display some instructions and the current view and rotation offsets
var textRenderer = ToDispose(new Common.TextRenderer("Calibri", Color.CornflowerBlue, new Point(8, 40), 12));
textRenderer.Initialize(this);
#endregion
// Initialize the world matrix
var worldMatrix = Matrix.Identity;
// Set the camera position
var cameraPosition = new Vector3(1, 1, 2);
var cameraTarget = Vector3.Zero; // Looking at the origin 0,0,0
var cameraUp = Vector3.UnitY; // Y+ is Up
// Prepare matrices
// Create the view matrix from our camera position, look target and up direction
var viewMatrix = Matrix.LookAtRH(cameraPosition, cameraTarget, cameraUp);
viewMatrix.TranslationVector += new Vector3(0, -0.98f, 0);
// Create the projection matrix
/* FoV 60degrees = Pi/3 radians */
// Aspect ratio (based on window size), Near clip, Far clip
var projectionMatrix = Matrix.PerspectiveFovRH((float)Math.PI / 3f, Width / (float)Height, 0.5f, 100f);
// Maintain the correct aspect ratio on resize
Window.Resize += (s, e) =>
{
projectionMatrix = Matrix.PerspectiveFovRH((float)Math.PI / 3f, Width / (float)Height, 0.5f, 100f);
};
#region Rotation and window event handlers
// Create a rotation vector to keep track of the rotation
// around each of the axes
var rotation = new Vector3(0.0f, 0.0f, 0.0f);
// We will call this action to update text
// for the text renderer
Action updateText = () =>
{
textRenderer.Text =
String.Format("Rotation ({0}) (Up/Down Left/Right Wheel+-)\nView ({1}) (A/D, W/S, Shift+Wheel+-)"
+ "\nPress X to reinitialize the device and resources (device ptr: {2})"
+ "\nPress Z to show/hide depth buffer - Press F to toggle wireframe"
+ "\nPress 1,2,3,4 to switch shaders",
rotation,
viewMatrix.TranslationVector,
DeviceManager.Direct3DDevice.NativePointer);
};
Dictionary <Keys, bool> keyToggles = new Dictionary <Keys, bool>();
keyToggles[Keys.Z] = false;
keyToggles[Keys.F] = false;
// Support keyboard/mouse input to rotate or move camera view
var moveFactor = 0.02f; // how much to change on each keypress
var shiftKey = false;
var ctrlKey = false;
var background = Color.White;
Window.KeyDown += (s, e) =>
{
var context = DeviceManager.Direct3DContext;
shiftKey = e.Shift;
ctrlKey = e.Control;
switch (e.KeyCode)
{
// WASD -> pans view
case Keys.A:
viewMatrix.TranslationVector += new Vector3(moveFactor * 2, 0f, 0f);
break;
case Keys.D:
viewMatrix.TranslationVector -= new Vector3(moveFactor * 2, 0f, 0f);
break;
case Keys.S:
if (shiftKey)
{
viewMatrix.TranslationVector += new Vector3(0f, moveFactor * 2, 0f);
}
else
{
viewMatrix.TranslationVector -= new Vector3(0f, 0f, 1) * moveFactor * 2;
}
break;
case Keys.W:
if (shiftKey)
{
viewMatrix.TranslationVector -= new Vector3(0f, moveFactor * 2, 0f);
}
else
{
viewMatrix.TranslationVector += new Vector3(0f, 0f, 1) * moveFactor * 2;
}
break;
// Up/Down and Left/Right - rotates around X / Y respectively
// (Mouse wheel rotates around Z)
case Keys.Down:
worldMatrix *= Matrix.RotationX(moveFactor);
rotation += new Vector3(moveFactor, 0f, 0f);
break;
case Keys.Up:
worldMatrix *= Matrix.RotationX(-moveFactor);
rotation -= new Vector3(moveFactor, 0f, 0f);
break;
case Keys.Left:
worldMatrix *= Matrix.RotationY(moveFactor);
rotation += new Vector3(0f, moveFactor, 0f);
break;
case Keys.Right:
worldMatrix *= Matrix.RotationY(-moveFactor);
rotation -= new Vector3(0f, moveFactor, 0f);
break;
case Keys.T:
fps.Show = !fps.Show;
textRenderer.Show = !textRenderer.Show;
break;
case Keys.B:
if (background == Color.White)
{
background = new Color(30, 30, 34);
}
else
{
background = Color.White;
}
break;
case Keys.G:
axisGrid.Show = !axisGrid.Show;
break;
case Keys.P:
// Pause or resume mesh animation
meshes.ForEach(m => {
if (m.Clock.IsRunning)
{
m.Clock.Stop();
}
else
{
m.Clock.Start();
}
});
break;
case Keys.X:
// To test for correct resource recreation
// Simulate device reset or lost.
System.Diagnostics.Debug.WriteLine(SharpDX.Diagnostics.ObjectTracker.ReportActiveObjects());
DeviceManager.Initialize(DeviceManager.Dpi);
System.Diagnostics.Debug.WriteLine(SharpDX.Diagnostics.ObjectTracker.ReportActiveObjects());
break;
case Keys.Z:
keyToggles[Keys.Z] = !keyToggles[Keys.Z];
if (keyToggles[Keys.Z])
{
context.PixelShader.Set(depthPixelShader);
}
else
{
context.PixelShader.Set(pixelShader);
}
break;
case Keys.F:
keyToggles[Keys.F] = !keyToggles[Keys.F];
RasterizerStateDescription rasterDesc;
if (context.Rasterizer.State != null)
{
rasterDesc = context.Rasterizer.State.Description;
}
else
{
rasterDesc = new RasterizerStateDescription()
{
CullMode = CullMode.Back,
FillMode = FillMode.Solid
}
};
if (keyToggles[Keys.F])
{
rasterDesc.FillMode = FillMode.Wireframe;
context.Rasterizer.State = ToDispose(new RasterizerState(context.Device, rasterDesc));
}
else
{
rasterDesc.FillMode = FillMode.Solid;
context.Rasterizer.State = ToDispose(new RasterizerState(context.Device, rasterDesc));
}
break;
case Keys.D1:
context.PixelShader.Set(pixelShader);
break;
case Keys.D2:
context.PixelShader.Set(lambertShader);
break;
case Keys.D3:
context.PixelShader.Set(phongShader);
break;
case Keys.D4:
context.PixelShader.Set(blinnPhongShader);
break;
}
updateText();
};
Window.KeyUp += (s, e) =>
{
// Clear the shift/ctrl keys so they aren't sticky
if (e.KeyCode == Keys.ShiftKey)
{
shiftKey = false;
}
if (e.KeyCode == Keys.ControlKey)
{
ctrlKey = false;
}
};
Window.MouseWheel += (s, e) =>
{
if (shiftKey)
{
// Zoom in/out
viewMatrix.TranslationVector += new Vector3(0f, 0f, (e.Delta / 120f) * moveFactor * 2);
}
else
{
// rotate around Z-axis
viewMatrix *= Matrix.RotationZ((e.Delta / 120f) * moveFactor);
rotation += new Vector3(0f, 0f, (e.Delta / 120f) * moveFactor);
}
updateText();
};
var lastX = 0;
var lastY = 0;
Window.MouseDown += (s, e) =>
{
if (e.Button == MouseButtons.Left)
{
lastX = e.X;
lastY = e.Y;
}
};
Window.MouseMove += (s, e) =>
{
if (e.Button == MouseButtons.Left)
{
var yRotate = lastX - e.X;
var xRotate = lastY - e.Y;
lastY = e.Y;
lastX = e.X;
// Mouse move changes
// Rotate view (i.e. camera)
//viewMatrix *= Matrix.RotationX(xRotate * moveFactor);
//viewMatrix *= Matrix.RotationY(yRotate * moveFactor);
// Rotate around origin
var backup = viewMatrix.TranslationVector;
viewMatrix.TranslationVector = Vector3.Zero;
viewMatrix *= Matrix.RotationX(xRotate * moveFactor);
viewMatrix.TranslationVector = backup;
worldMatrix *= Matrix.RotationY(yRotate * moveFactor);
updateText();
}
};
// Display instructions with initial values
updateText();
#endregion
var clock = new System.Diagnostics.Stopwatch();
clock.Start();
#region Render loop
// Create and run the render loop
RenderLoop.Run(Window, () =>
{
// Start of frame:
// Retrieve immediate context
var context = DeviceManager.Direct3DContext;
// Clear depth stencil view
context.ClearDepthStencilView(DepthStencilView, DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, 1.0f, 0);
// Clear render target view
context.ClearRenderTargetView(RenderTargetView, background);
// Create viewProjection matrix
var viewProjection = Matrix.Multiply(viewMatrix, projectionMatrix);
// Extract camera position from view
var camPosition = Matrix.Transpose(Matrix.Invert(viewMatrix)).Column4;
cameraPosition = new Vector3(camPosition.X, camPosition.Y, camPosition.Z);
// If Keys.CtrlKey is down, auto rotate viewProjection based on time
var time = clock.ElapsedMilliseconds / 1000.0f;
if (ctrlKey)
{
viewProjection = Matrix.RotationY(time * 1.8f) * Matrix.RotationX(time * 1f) * Matrix.RotationZ(time * 0.6f) * viewProjection;
}
var worldRotation = Matrix.RotationAxis(Vector3.UnitY, time);
var perFrame = new ConstantBuffers.PerFrame();
perFrame.Light.Color = new Color(0.8f, 0.8f, 0.8f, 1.0f);
var lightDir = Vector3.Transform(new Vector3(1f, -1f, -1f), worldMatrix);
perFrame.Light.Direction = new Vector3(lightDir.X, lightDir.Y, lightDir.Z);// new Vector3(Vector3.Transform(new Vector3(1f, -1f, 1f), worldMatrix * worldRotation).ToArray().Take(3).ToArray());
perFrame.CameraPosition = cameraPosition;
context.UpdateSubresource(ref perFrame, perFrameBuffer);
// Render each object
var perMaterial = new ConstantBuffers.PerMaterial();
perMaterial.Ambient = new Color4(0.2f);
perMaterial.Diffuse = Color.White;
perMaterial.Emissive = new Color4(0);
perMaterial.Specular = Color.White;
perMaterial.SpecularPower = 20f;
perMaterial.HasTexture = 0;
perMaterial.UVTransform = Matrix.Identity;
context.UpdateSubresource(ref perMaterial, perMaterialBuffer);
var perObject = new ConstantBuffers.PerObject();
foreach (var m in meshes)
{
// MESH
perObject.World = m.World * worldMatrix;
perObject.WorldInverseTranspose = Matrix.Transpose(Matrix.Invert(perObject.World));
perObject.WorldViewProjection = perObject.World * viewProjection;
perObject.Transpose();
context.UpdateSubresource(ref perObject, perObjectBuffer);
// Provide the material constant buffer to the mesh renderer
m.PerMaterialBuffer = perMaterialBuffer;
m.PerArmatureBuffer = perArmatureBuffer;
m.Render();
}
// AXIS GRID
using (var prevPixelShader = context.PixelShader.Get())
{
perMaterial.HasTexture = 0;
perMaterial.UVTransform = Matrix.Identity;
context.UpdateSubresource(ref perMaterial, perMaterialBuffer);
context.PixelShader.Set(pixelShader);
perObject.World = worldMatrix;
perObject.WorldInverseTranspose = Matrix.Transpose(Matrix.Invert(perObject.World));
perObject.WorldViewProjection = perObject.World * viewProjection;
perObject.Transpose();
context.UpdateSubresource(ref perObject, perObjectBuffer);
axisGrid.Render();
context.PixelShader.Set(prevPixelShader);
}
// Render FPS
fps.Render();
// Render instructions + position changes
textRenderer.Render();
// Present the frame
Present();
});
#endregion
}
private static bool DebugMenu()
{
if (!LogManager.Configuration.LoggingRules.Any(r => r.IsLoggingEnabledForLevel(LogLevel.Trace)))
{
LogManager.DisableLogging();
}
void WriteHeader(string header)
{
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(header);
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("-------------------------------");
Console.ForegroundColor = ConsoleColor.Gray;
}
void WriteFooter()
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("-------------------------------");
Console.ForegroundColor = ConsoleColor.White;
Console.ResetColor();
}
void WriteProperty(int indent, string propertyName, object value = null)
{
Console.ForegroundColor = ConsoleColor.DarkGray;
Console.Write($"» {new string('\t', indent)} ");
Console.ForegroundColor = ConsoleColor.Gray;
Console.Write($"{propertyName}");
if (value != null)
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write($"{value}");
}
Console.WriteLine();
Console.ResetColor();
}
void WaitForInput()
{
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
void ListInfo()
{
WriteHeader("Info");
WriteProperty(0, "");
var osName = Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion", "ProductName", null)?.ToString() ?? string.Empty;
var osReleaseId = Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion", "ReleaseId", null)?.ToString() ?? string.Empty;
var osBuild = Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion", "BuildLabEx", null)?.ToString() ?? string.Empty;
var appVersion = FileVersionInfo.GetVersionInfo(Assembly.GetCallingAssembly().Location)?.ProductVersion;
WriteProperty(1, "OS: ", $"{osName} {osReleaseId} [{osBuild}]");
WriteProperty(1, "Build: ", appVersion);
WriteProperty(0, "");
WriteFooter();
}
void ListControllers()
{
WriteHeader("Controllers");
WriteProperty(0, "");
PluginLoader.Load(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Plugins"), typeof(IControllerDefinition));
using (var deviceManager = new DeviceManager())
{
foreach (var controller in deviceManager.Controllers)
{
WriteProperty(0, "Name: ", controller.Name);
WriteProperty(1, "VendorId: ", controller.VendorId);
WriteProperty(1, "ProductId: ", controller.ProductId);
WriteProperty(1, "Ports: ");
foreach (var port in controller.Ports)
{
var data = controller.GetPortData(port.Id);
WriteProperty(2, $"{port.Id}: ");
WriteProperty(3, "Data: ", data);
WriteProperty(3, "Identifier: ", port);
}
WriteProperty(1, "Available effect types: ", string.Join(", ", controller.EffectTypes));
}
}
WriteProperty(0, "");
WriteFooter();
}
void ListSensors(params SensorType[] types)
{
WriteHeader("Sensors");
WriteProperty(0, "");
string FormatValue(SensorType type, float value)
{
switch (type)
{
case SensorType.Voltage: return($"{value:F2} V");
case SensorType.Clock: return($"{value:F0} MHz");
case SensorType.Load: return($"{value:F1} %");
case SensorType.Temperature: return($"{value:F1} °C");
case SensorType.Fan: return($"{value:F0} RPM");
case SensorType.Flow: return($"{value:F0} L/h");
case SensorType.Control: return($"{value:F1} %");
case SensorType.Level: return($"{value:F1} %");
case SensorType.Power: return($"{value:F0} W");
case SensorType.Data: return($"{value:F0} GB");
case SensorType.SmallData: return($"{value:F1} MB");
case SensorType.Factor: return($"{value:F3}");
case SensorType.Frequency: return($"{value:F1} Hz");
case SensorType.Throughput: return($"{value:F1} B/s");
}
return($"{value}");
}
using (var _libreHardwareMonitorFacade = new LibreHardwareMonitorFacade())
{
var availableSensors = _libreHardwareMonitorFacade.Sensors.Where(s => types.Length > 0 ? types.Contains(s.SensorType) : true);
foreach (var(hardware, sensors) in availableSensors.GroupBy(s => s.Hardware))
{
WriteProperty(0, $"{hardware.Name}:");
hardware.Update();
foreach (var(type, group) in sensors.GroupBy(s => s.SensorType))
{
WriteProperty(1, $"{type}:");
foreach (var sensor in group)
{
WriteProperty(2, $"{ sensor.Name} ({ sensor.Identifier}): ", FormatValue(type, sensor.Value ?? float.NaN));
}
}
WriteProperty(0, "");
}
}
WriteFooter();
}
void ListPlugins()
{
WriteHeader("Plugins");
WriteProperty(0, "");
var pluginAssemblies = PluginLoader.SearchAll(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Plugins"));
WriteProperty(0, "Detected plugins:");
foreach (var assembly in pluginAssemblies)
{
WriteProperty(1, Path.GetFileName(assembly.Location));
}
WriteProperty(0, "");
WriteFooter();
}
var enabled = Service != null && Service.Status != ServiceControllerStatus.Running;
var menu = new MenuPage("Main Menu > Debug");
menu.Add("Report", () => {
Console.Clear();
ListInfo();
ListControllers();
ListSensors(SensorType.Temperature);
WaitForInput();
return(false);
}, () => enabled);
menu.Add("Controllers", () => {
Console.Clear();
ListControllers();
WaitForInput();
return(false);
}, () => enabled);
menu.Add("Sensors", () => {
Console.Clear();
ListSensors();
WaitForInput();
return(false);
}, () => enabled);
menu.Add("Plugins", () => {
Console.Clear();
ListPlugins();
WaitForInput();
return(false);
}, () => enabled);
menu.Add("Back", () => {
LogManager.EnableLogging();
return(true);
}, () => true, '0');
while (true)
{
Console.Clear();
var selected = menu.Show();
if (selected.Callback())
{
return(false);
}
}
}
protected override ServerQueue <StateRequest> GetQueue(string serialNumber)
{
return(DeviceManager.GetController(serialNumber)?.StateRequestQueue);
}
public static unsafe void Main()
{
try
{
ManagedMemory.InitializeGCMemory();
// Initialize static fields
StartUp.InitializeAssembly();
KMath.Init();
BootInfo.SetupStage1();
// Write protect all possible pages and disallow execution on all non-code pages.
Memory.InitialKernelProtect();
ApiContext.Current = new ApiHost();
Assert.Setup(AssertError);
// Setup some pseudo devices
DeviceManager.InitStage1();
//Setup Output and Debug devices
DeviceManager.InitStage2();
// Write first output
KernelMessage.WriteLine("<KERNEL:CONSOLE:BEGIN>");
PerformanceCounter.Setup(BootInfo.Header->KernelBootStartCycles);
KernelMessage.WriteLine("Starting Abanu Kernel...");
KernelMessage.WriteLine("KConfig.UseKernelMemoryProtection: {0}", KConfig.UseKernelMemoryProtection);
KernelMessage.WriteLine("KConfig.UsePAE: {0}", KConfig.UsePAE);
KernelMessage.WriteLine("Apply PageTableType: {0}", (uint)BootInfo.Header->PageTableType);
KernelMessage.WriteLine("GCInitialMemory: {0:X8}-{1:X8}", Address.GCInitialMemory, Address.GCInitialMemory + Address.GCInitialMemorySize - 1);
CodeTests.Run();
// Detect environment (Memory Maps, Video Mode, etc.)
BootInfo.SetupStage2();
KernelMemoryMapManager.Setup();
//KernelMemoryMapManager.Allocate(0x1000 * 1000, BootInfoMemoryType.PageDirectory);
// Read own ELF-Headers and Sections
KernelElf.Setup();
// Initialize the embedded code (actually only a little proof of concept code)
NativeCalls.Setup();
PhysicalPageManager.Setup();
NonThreadTests.TestPhysicalPageAllocation();
VirtualPageManager.Setup();
// Setup final Memory Allocator
Memory.Setup();
// Now Memory Sub System is working. At this point it's valid
// to allocate memory dynamically
// If we have a Framebuffer, lets try to initialize it.
DeviceManager.InitFrameBuffer();
// Setup Programmable Interrupt Table
PIC.Setup();
// Setup Interrupt Descriptor Table
// Important Note: IDT depends on GDT. Never setup IDT before GDT.
IDTManager.Setup();
InitializeUserMode();
SysCallManager.Setup();
KernelMessage.WriteLine("Initialize Runtime Metadata");
StartUp.InitializeRuntimeMetadata();
KernelMessage.WriteLine("Performing some Non-Thread Tests");
NonThreadTests.RunTests();
}
catch (Exception ex)
{
Panic.Error(ex.Message);
}
if (KConfig.SingleThread)
{
StartupStage2();
}
else
{
ProcessManager.Setup(StartupStage2);
}
}
private void CheckForDBUpdate(bool verbose = false)
{
StartCoroutine(DeviceManager.AssignMappings(true, verbose));
}
public override void Initialize(DeviceManager deviceManager)
{
base.Initialize(deviceManager);
// Remove previous buffer
if (this.constantBuffer != null)
{
this.constantBuffer.Dispose();
}
// RemoveAndDispose(ref constantBuffer);
// Setup local variables
var d3dDevice = deviceManager.DeviceDirect3D;
var d3dContext = deviceManager.ContextDirect3D;
var path = Path.Combine(Windows.ApplicationModel.Package.Current.InstalledLocation.Path, "HelixToolkit.UWP");
// Loads vertex shader bytecode
var vertexShaderByteCode = global::SharpDX.IO.NativeFile.ReadAllBytes(path + "\\MiniCube_VS.fxo");
this.vertexShader = new global::SharpDX.Direct3D11.VertexShader(d3dDevice, vertexShaderByteCode);
// Loads pixel shader bytecode
this.pixelShader = new global::SharpDX.Direct3D11.PixelShader(d3dDevice, global::SharpDX.IO.NativeFile.ReadAllBytes(path + "\\MiniCube_PS.fxo"));
// Layout from VertexShader input signature
this.layout = new global::SharpDX.Direct3D11.InputLayout(
d3dDevice,
vertexShaderByteCode,
new[]
{
new global::SharpDX.Direct3D11.InputElement("POSITION", 0, global::SharpDX.DXGI.Format.R32G32B32A32_Float, 0, 0),
new global::SharpDX.Direct3D11.InputElement("COLOR", 0, global::SharpDX.DXGI.Format.R32G32B32A32_Float, 16, 0)
});
// Instantiate Vertex buffer from vertex data
var vertices = global::SharpDX.Direct3D11.Buffer.Create(
d3dDevice,
global::SharpDX.Direct3D11.BindFlags.VertexBuffer,
new[]
{
new global::SharpDX.Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new global::SharpDX.Vector4(1.0f, 0.0f, 0.0f, 1.0f), // Front
new global::SharpDX.Vector4(-1.0f, 1.0f, -1.0f, 1.0f), new global::SharpDX.Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new global::SharpDX.Vector4(1.0f, 1.0f, -1.0f, 1.0f), new global::SharpDX.Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new global::SharpDX.Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new global::SharpDX.Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new global::SharpDX.Vector4(1.0f, 1.0f, -1.0f, 1.0f), new global::SharpDX.Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new global::SharpDX.Vector4(1.0f, -1.0f, -1.0f, 1.0f), new global::SharpDX.Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new global::SharpDX.Vector4(-1.0f, -1.0f, 1.0f, 1.0f), new global::SharpDX.Vector4(0.0f, 1.0f, 0.0f, 1.0f), // BACK
new global::SharpDX.Vector4(1.0f, 1.0f, 1.0f, 1.0f), new global::SharpDX.Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new global::SharpDX.Vector4(-1.0f, 1.0f, 1.0f, 1.0f), new global::SharpDX.Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new global::SharpDX.Vector4(-1.0f, -1.0f, 1.0f, 1.0f), new global::SharpDX.Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new global::SharpDX.Vector4(1.0f, -1.0f, 1.0f, 1.0f), new global::SharpDX.Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new global::SharpDX.Vector4(1.0f, 1.0f, 1.0f, 1.0f), new global::SharpDX.Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new global::SharpDX.Vector4(-1.0f, 1.0f, -1.0f, 1.0f), new global::SharpDX.Vector4(0.0f, 0.0f, 1.0f, 1.0f), // Top
new global::SharpDX.Vector4(-1.0f, 1.0f, 1.0f, 1.0f), new global::SharpDX.Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new global::SharpDX.Vector4(1.0f, 1.0f, 1.0f, 1.0f), new global::SharpDX.Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new global::SharpDX.Vector4(-1.0f, 1.0f, -1.0f, 1.0f), new global::SharpDX.Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new global::SharpDX.Vector4(1.0f, 1.0f, 1.0f, 1.0f), new global::SharpDX.Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new global::SharpDX.Vector4(1.0f, 1.0f, -1.0f, 1.0f), new global::SharpDX.Vector4(0.0f, 0.0f, 1.0f, 1.0f),
new global::SharpDX.Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new global::SharpDX.Vector4(1.0f, 1.0f, 0.0f, 1.0f), // Bottom
new global::SharpDX.Vector4(1.0f, -1.0f, 1.0f, 1.0f), new global::SharpDX.Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new global::SharpDX.Vector4(-1.0f, -1.0f, 1.0f, 1.0f), new global::SharpDX.Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new global::SharpDX.Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new global::SharpDX.Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new global::SharpDX.Vector4(1.0f, -1.0f, -1.0f, 1.0f), new global::SharpDX.Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new global::SharpDX.Vector4(1.0f, -1.0f, 1.0f, 1.0f), new global::SharpDX.Vector4(1.0f, 1.0f, 0.0f, 1.0f),
new global::SharpDX.Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new global::SharpDX.Vector4(1.0f, 0.0f, 1.0f, 1.0f), // Left
new global::SharpDX.Vector4(-1.0f, -1.0f, 1.0f, 1.0f), new global::SharpDX.Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new global::SharpDX.Vector4(-1.0f, 1.0f, 1.0f, 1.0f), new global::SharpDX.Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new global::SharpDX.Vector4(-1.0f, -1.0f, -1.0f, 1.0f), new global::SharpDX.Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new global::SharpDX.Vector4(-1.0f, 1.0f, 1.0f, 1.0f), new global::SharpDX.Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new global::SharpDX.Vector4(-1.0f, 1.0f, -1.0f, 1.0f), new global::SharpDX.Vector4(1.0f, 0.0f, 1.0f, 1.0f),
new global::SharpDX.Vector4(1.0f, -1.0f, -1.0f, 1.0f), new global::SharpDX.Vector4(0.0f, 1.0f, 1.0f, 1.0f), // Right
new global::SharpDX.Vector4(1.0f, 1.0f, 1.0f, 1.0f), new global::SharpDX.Vector4(0.0f, 1.0f, 1.0f, 1.0f),
new global::SharpDX.Vector4(1.0f, -1.0f, 1.0f, 1.0f), new global::SharpDX.Vector4(0.0f, 1.0f, 1.0f, 1.0f),
new global::SharpDX.Vector4(1.0f, -1.0f, -1.0f, 1.0f), new global::SharpDX.Vector4(0.0f, 1.0f, 1.0f, 1.0f),
new global::SharpDX.Vector4(1.0f, 1.0f, -1.0f, 1.0f), new global::SharpDX.Vector4(0.0f, 1.0f, 1.0f, 1.0f),
new global::SharpDX.Vector4(1.0f, 1.0f, 1.0f, 1.0f), new global::SharpDX.Vector4(0.0f, 1.0f, 1.0f, 1.0f),
});
this.vertexBufferBinding = new global::SharpDX.Direct3D11.VertexBufferBinding(vertices, global::SharpDX.Utilities.SizeOf <global::SharpDX.Vector4>() * 2, 0);
// Create Constant Buffer
this.constantBuffer = new global::SharpDX.Direct3D11.Buffer(
d3dDevice,
global::SharpDX.Utilities.SizeOf <global::SharpDX.Matrix>(),
global::SharpDX.Direct3D11.ResourceUsage.Default,
global::SharpDX.Direct3D11.BindFlags.ConstantBuffer,
global::SharpDX.Direct3D11.CpuAccessFlags.None,
global::SharpDX.Direct3D11.ResourceOptionFlags.None,
0);
this.clock = new Stopwatch();
this.clock.Start();
}
public override void RemoveDevice(int devid)
{
IRunDevice dev = DeviceManager.GetDevice(devid);
if (dev != null)
{
string desc = String.Empty;
string devname = dev.DeviceParameter.DeviceName;
if (DeviceManager.RemoveDevice(dev.DeviceParameter.DeviceID))
{
if (dev.DeviceType == DeviceType.Virtual)
{
desc = "删除虚拟设备";
}
else
{
#region
if (dev.CommunicateType == CommunicateType.COM)
{
IRunDevice[] comDevices = DeviceManager.GetDevices(dev.DeviceParameter.COM.Port.ToString(), CommunicateType.COM);
if (comDevices.Length == 0)
{
string key = ComUtils.PortToString(dev.DeviceParameter.COM.Port);
IController controller = ControllerManager.GetController(key);
if (controller != null)
{
controller.IsWorking = false;
if (ControllerManager.RemoveController(controller.Key))
{
controller.StopController();
controller.Dispose();
IComSession comChannel = (IComSession)((IComController)controller).ComChannel;
comChannel.Close();
comChannel.COMOpen -= ComChannel_COMOpen;
comChannel.COMClose -= ComChannel_COMClose;
comChannel.COMError -= ComChannel_COMError;
if (ChannelManager.RemoveChannel(comChannel.Key))
{
comChannel.Close();
comChannel.Dispose();
}
}
}
}
desc = String.Format("{0},从串口'{1}'删除", dev.DeviceParameter.DeviceName, dev.DeviceParameter.COM.Port.ToString());
}
else if (dev.CommunicateType == CommunicateType.NET)
{
desc = String.Format("{0}-{1},从网络中删除成功", dev.DeviceParameter.DeviceName, dev.DeviceParameter.NET.RemoteIP);
}
#endregion
}
//--------------删除动态显示的实时数据----------------------//
foreach (IGraphicsShow show in this._Shows.Values)
{
show.RemoveDevice(dev.DeviceParameter.DeviceID);
}
//---------------------删除服务数据-----------------------//
foreach (IAppService service in this._Services.Values)
{
service.RemoveDevice(dev.DeviceParameter.DeviceID);
}
dev.DeviceParameter.Delete();
dev.DeviceDynamic.Delete();
dev.Delete();
dev.Dispose();
BindDeviceHandler(dev, dev.DeviceType, false);
desc += ",成功";
OnDeleteDeviceCompleted(dev.DeviceParameter.DeviceID, dev.DeviceParameter.DeviceName, true);
}
else
{
desc += ",失败";
OnDeleteDeviceCompleted(dev.DeviceParameter.DeviceID, dev.DeviceParameter.DeviceName, false);
}
Logger.Info(true, desc);
}
}
private void RefreshSources()
{
_sources.Clear();
var devices = new List<WiaSource>();
var manager = new DeviceManager();
var i = 0;
foreach (DeviceInfo info in manager.DeviceInfos)
{
if (info.Type == WiaDeviceType.ScannerDeviceType)
{
try
{
var name = FindProperty(info.Properties, WiaProperty.Name);
devices.Add(new WiaSource(i, (string)name.get_Value(), info.DeviceID));
i++;
}
catch (Exception e)
{
_log.WarnFormat("Ошибка при добавлении источника: {0}", e);
}
}
}
_sources = devices;
}
public MaterialResource(DeviceManager deviceManager, ITextureResourceManager textureManager, ITextureSamplerManager samplerManager, string id)
: base(id)
{
_deviceManager = deviceManager;
_textureManager = textureManager;
_samplerManager = samplerManager;
}
public void TestManualThreadLockTest()
{
FakeExternalDevice device = new FakeExternalDevice();
device.Open();
DeviceManager manager = new DeviceManager(new[] { device });
ThreadStart start1 = device.TriggerDataReceived;
ThreadStart start2 = manager.EnableCooling;
Thread thread1 = new Thread(start1);
thread1.Name = "Thread 1";
Thread thread2 = new Thread(start2);
thread2.Name = "Thread 2";
// Start both the threads.
// Expect thread blocking as external device locks internally then calls manager which locks internally
// call to manager locks internally then calles external device which tries to lock internally.
thread2.Start();
thread1.Start();
if (!thread1.Join(5000))
{
Debug.WriteLine("t1 join");
Assert.Fail("Thread 1 timeout");
}
if (!thread2.Join(5000))
{
Debug.WriteLine("t2 join");
Assert.Fail("Thread 2 timeout");
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!this.IsPostBack)
{
//code for YT Mobile redirections
string redirctMobileUrl = string.Empty;
DeviceManager deviceManager = new DeviceManager
{
UserAgent = Request.UserAgent,
IsMobileBrowser = Request.Browser.IsMobileDevice
};
// Added by Varun Goel on 25 Jan 2013 for NoRedirection functionality
TributesPortal.Utilities.StateManager stateManager = StateManager.Instance;
objSessionValue = (SessionValue)stateManager.Get("objSessionvalue", StateManager.State.Session);
if (objSessionValue == null || objSessionValue.NoRedirection == null || objSessionValue.NoRedirection == false)
{
if (deviceManager.IsMobileDevice())
{
// Redirection URL
redirctMobileUrl = string.Format("{0}{1}{2}", "https://www.", WebConfig.TopLevelDomain, "/mobile/Tour.html");
Response.Redirect(redirctMobileUrl, false);
}
}
}
if (ConfigurationManager.AppSettings["ApplicationType"].ToString().ToLower() == "yourmoments")
{
yourtribute.Visible = false;
yourmoments.Visible = true;
tourTitle.InnerHtml=@"Tour - See how to create a Website for your significant event";
}
else if (ConfigurationManager.AppSettings["ApplicationType"].ToString().ToLower() == "yourtribute")
{
yourtribute.Visible = true;
yourmoments.Visible = false;
}
}
