public static CapabilityDiscoveryResult DiscoverCapability(this DiscoveryClient discoverClient, Capability capability) { return AsyncHelper.RunSync<CapabilityDiscoveryResult>(async () => { return await discoverClient.DiscoverCapabilityAsync(capability); }); }
public BlockBoolConstant() { width = 50; height = 50; Capability capability = new Capability(this); capability.AddDataOutput("Constant", "bool"); UpdateConnectors(); }
public override string ToCommand(Capability capabilities) { if (!IsSupported(capabilities)) { throw new NotSupportedException("The selected authentication mechanism is not supported"); } return string.Format(ImapCommands.Authenticate + " {1}", "XOAUTH2", PrepareOAuthCredentials(Login, AuthToken)); }
public override string ToCommand(Capability capabilities) { if (!IsSupported(capabilities)) { throw new NotSupportedException("The selected authentication mechanism is not supported"); } return capabilities.LoginDisabled ? string.Format(ImapCommands.Authenticate + "\n{1}\n{2}", "PLAIN", Base64.ToBase64(Encoding.UTF8.GetBytes(Login)), Base64.ToBase64(Encoding.UTF8.GetBytes(Password))) : string.Format(ImapCommands.Login, Login, Password); }
public void AddCapability(Capability capability) { if (_enabledCapabilities.Contains(capability)) { return; } var capImpl = _availableCapabilities[capability]; foreach (var dependency in capImpl.Dependencies) { AddCapability(dependency); } _enabledCapabilities.Add(capability); }
public XBeePin(string name, int pin, string atCommand, int atPin, Capability defaultCapability, string description, Capability[] capabilities) { Name = name; Pin = pin; AtCommand = atCommand; AtPin = atPin; Description = description; DefaultCapability = defaultCapability; Capabilities = capabilities; }
private void TextureStatsHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response) { try { OSD osd = OSDParser.Deserialize(request.Body); m_log.Info("Received a TextureStats message: " + osd.ToString()); } catch (Exception) { m_log.Warn("Failed to decode TextureStats message"); } }
internal static bool CheckCapability(DirectoryEntry rootDSE, Capability capability) { bool flag = false; if (rootDSE != null) { if (capability != Capability.ActiveDirectory) { if (capability != Capability.ActiveDirectoryApplicationMode) { if (capability == Capability.ActiveDirectoryOrADAM) { foreach (string item in rootDSE.Properties[PropertyManager.SupportedCapabilities]) { if (string.Compare(item, SupportedCapability.ADAMOid, StringComparison.OrdinalIgnoreCase) != 0 && string.Compare(item, SupportedCapability.ADOid, StringComparison.OrdinalIgnoreCase) != 0) { continue; } flag = true; break; } } } else { foreach (string str in rootDSE.Properties[PropertyManager.SupportedCapabilities]) { if (string.Compare(str, SupportedCapability.ADAMOid, StringComparison.OrdinalIgnoreCase) != 0) { continue; } flag = true; break; } } } else { foreach (string item1 in rootDSE.Properties[PropertyManager.SupportedCapabilities]) { if (string.Compare(item1, SupportedCapability.ADOid, StringComparison.OrdinalIgnoreCase) != 0) { continue; } flag = true; break; } } } return flag; }
private void ParcelVoiceInfoRequestHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response) { ParcelVoiceInfoRequestMessage message; if (LLUtil.TryGetMessage<ParcelVoiceInfoRequestMessage>(request.Body, out message)) { m_log.DebugFormat("ParcelVoiceInfoRequest: RegionName={0}, ParcelID={1}, SipChannelUri={2}", message.RegionName, message.ParcelID, message.SipChannelUri); } else { m_log.Warn("Received invalid request data for ParcelVoiceInfoRequest"); response.Status = System.Net.HttpStatusCode.BadRequest; } }
public int MapInCapability(Thread current, Capability cap) { int id; if (cap.parent == current) { id = cap.Uses.id; cap.Uses.InsertAfter(Capabilities); } else { id = NewCapAllocId(); var cap_ref = new CapabilityRef(current, id, cap); cap_ref.InsertAfter(Capabilities); } return id; }
internal static bool CheckCapability(DirectoryEntry rootDSE, Capability capability) { bool flag = false; if (rootDSE != null) { if (capability == Capability.ActiveDirectory) { foreach (string str in rootDSE.Properties[PropertyManager.SupportedCapabilities]) { if (string.Compare(str, SupportedCapability.ADOid, StringComparison.OrdinalIgnoreCase) == 0) { return true; } } return flag; } if (capability == Capability.ActiveDirectoryApplicationMode) { foreach (string str2 in rootDSE.Properties[PropertyManager.SupportedCapabilities]) { if (string.Compare(str2, SupportedCapability.ADAMOid, StringComparison.OrdinalIgnoreCase) == 0) { return true; } } return flag; } if (capability != Capability.ActiveDirectoryOrADAM) { return flag; } foreach (string str3 in rootDSE.Properties[PropertyManager.SupportedCapabilities]) { if ((string.Compare(str3, SupportedCapability.ADAMOid, StringComparison.OrdinalIgnoreCase) == 0) || (string.Compare(str3, SupportedCapability.ADOid, StringComparison.OrdinalIgnoreCase) == 0)) { return true; } } } return flag; }
public override bool IsSupported(Capability capabilities) { return(capabilities != null && (!capabilities.LoginDisabled || capabilities.AuthenticationMechanisms.Contains("PLAIN"))); }
private bool NegotiateArea(ScanSettings scanSettings) { var area = scanSettings.Area; if (area == null) { return false; } var cap = new Capability(Capabilities.IUnits, TwainType.Int16, _applicationId, SourceId); if ((Units)cap.GetBasicValue().Int16Value != area.Units) { Capability.SetCapability(Capabilities.IUnits, (short)area.Units, _applicationId, SourceId); } var imageLayout = new ImageLayout { Frame = new Frame { Left = new Fix32(area.Left), Top = new Fix32(area.Top), Right = new Fix32(area.Right), Bottom = new Fix32(area.Bottom) } }; var result = Twain32Native.DsImageLayout( _applicationId, SourceId, DataGroup.Image, DataArgumentType.ImageLayout, Message.Set, imageLayout); if (result != TwainResult.Success) { throw new TwainException("DsImageLayout.GetDefault error", result); } return true; }
public void NegotiateOrientation(ScanSettings scanSettings) { // Set orientation (default is portrait) var cap = new Capability(Capabilities.Orientation, TwainType.Int16, _applicationId, SourceId); if ((Orientation)cap.GetBasicValue().Int16Value != Orientation.Default) { Capability.SetBasicCapability(Capabilities.Orientation, (ushort)scanSettings.Page.Orientation, TwainType.UInt16, _applicationId, SourceId); } }
public static async Task <CapabilityDiscoveryResult> DiscoverCapabilityAsync(this DiscoveryClient discoveryClient, Capability capability) { return(await discoveryClient.DiscoverCapabilityAsync(capability.ToString())); }
private void UploadObjectAssetHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response) { UploadObjectAssetMessage message; if (LLUtil.TryGetMessage<UploadObjectAssetMessage>(request.Body, out message)) { LLPrimitive parent = null; // Build the linkset for (int i = 0; i < message.Objects.Length; i++) { UploadObjectAssetMessage.Object obj = message.Objects[i]; #region Primitive Creation Primitive prim = new Primitive(); prim.Properties = new Primitive.ObjectProperties(); prim.Sculpt = new Primitive.SculptData(); prim.Textures = new Primitive.TextureEntry(UUID.Zero); prim.Flags = PrimFlags.CastShadows | PrimFlags.InventoryEmpty | PrimFlags.CreateSelected; prim.ID = UUID.Random(); prim.MediaURL = String.Empty; prim.OwnerID = cap.OwnerID; prim.GroupID = obj.GroupID; prim.TextColor = Color4.Black; prim.Properties.CreationDate = DateTime.UtcNow; prim.Properties.CreatorID = cap.OwnerID; prim.Properties.Description = String.Empty; prim.Properties.GroupID = obj.GroupID; prim.Properties.LastOwnerID = cap.OwnerID; prim.Properties.Name = obj.Name; prim.Properties.ObjectID = prim.ID; prim.Properties.OwnerID = prim.OwnerID; prim.Properties.Permissions = (m_permissions != null) ? m_permissions.GetDefaultPermissions() : Permissions.FullPermissions; prim.Properties.SalePrice = 10; prim.PrimData.PCode = PCode.Prim; prim.PrimData.Material = obj.Material; prim.PrimData.PathBegin = obj.PathBegin; prim.PrimData.PathCurve = (PathCurve)obj.PathCurve; prim.PrimData.PathEnd = obj.PathEnd; prim.PrimData.ProfileBegin = obj.ProfileBegin; prim.PrimData.ProfileCurve = (ProfileCurve)obj.ProfileCurve; prim.PrimData.ProfileEnd = obj.ProfileEnd; prim.PrimData.ProfileHollow = obj.ProfileHollow; prim.PrimData.PathRadiusOffset = obj.RadiusOffset; prim.PrimData.PathRevolutions = obj.Revolutions; prim.PrimData.PathScaleX = obj.ScaleX; prim.PrimData.PathScaleY = obj.ScaleY; prim.PrimData.PathShearX = obj.ShearX; prim.PrimData.PathShearY = obj.ShearY; prim.PrimData.PathSkew = obj.Skew; prim.PrimData.PathTaperX = obj.TaperX; prim.PrimData.PathTaperY = obj.TaperY; prim.PrimData.PathTwist = obj.Twist; prim.PrimData.PathTwistBegin = obj.TwistBegin; // Extra parameters for (int j = 0; j < obj.ExtraParams.Length; j++) { UploadObjectAssetMessage.Object.ExtraParam extraParam = obj.ExtraParams[j]; switch (extraParam.Type) { case ExtraParamType.Flexible: prim.Flexible = new Primitive.FlexibleData(extraParam.ExtraParamData, 0); break; case ExtraParamType.Light: prim.Light = new Primitive.LightData(extraParam.ExtraParamData, 0); break; case ExtraParamType.Sculpt: prim.Sculpt = new Primitive.SculptData(extraParam.ExtraParamData, 0); break; } } // Faces for (int j = 0; j < obj.Faces.Length; j++) { UploadObjectAssetMessage.Object.Face face = obj.Faces[j]; Primitive.TextureEntryFace primFace = prim.Textures.GetFace(0); primFace.Bump = face.Bump; primFace.RGBA = face.Color; primFace.Fullbright = face.Fullbright; primFace.Glow = face.Glow; primFace.TextureID = face.ImageID; primFace.Rotation = face.ImageRot; primFace.MediaFlags = ((face.MediaFlags & MEDIA_MASK) != 0); primFace.OffsetU = face.OffsetS; primFace.OffsetV = face.OffsetT; primFace.RepeatU = face.ScaleS; primFace.RepeatV = face.ScaleT; primFace.TexMapType = (MappingType)(face.MediaFlags & TEX_MAP_MASK); } prim.Sculpt.SculptTexture = obj.SculptID; prim.Sculpt.Type = obj.SculptType; #endregion Primitive Creation LLPrimitive llprim = new LLPrimitive(prim, m_scene, m_primMesher); llprim.Scale = obj.Scale; // Link children prims to the parent if (i == 0) { llprim.RelativePosition = obj.Position; llprim.RelativeRotation = obj.Rotation; m_scene.EntityAddOrUpdate(this, llprim, UpdateFlags.FullUpdate, 0); parent = llprim; } else { llprim.RelativePosition = obj.Position; llprim.RelativeRotation = obj.Rotation; llprim.SetParent(parent, true, false); m_scene.EntityAddOrUpdate(this, llprim, UpdateFlags.FullUpdate, 0); } } } else { m_log.Warn("Received invalid data for UploadObjectAsset"); response.Status = System.Net.HttpStatusCode.BadRequest; } }
public override bool HasAvailableCapability(Capability capability) => false;
public static CapabilityDiscoveryResult DiscoverCapability(this DiscoveryClient discoverClient, Capability capability) { return(AsyncHelper.RunSync <CapabilityDiscoveryResult>(async() => { return await discoverClient.DiscoverCapabilityAsync(capability); })); }
public override void AddSupportedCapability(Capability capability) { }
public AgnosticListenerTest(ITestOutputHelper _log) { Assert.True(Capability.IPv4Support() && Capability.IPv6Support()); }
public WMAppManifest() { // parse the xml manifest once // parse the package xml to get attributes XmlReader xr = XmlReader.Create("WMAppManifest.xml"); if (xr.ReadToDescendant("Deployment")) { // if built as an 8.1 app defer to platform for most properties IsSilverlight81 = new Version(xr["AppPlatformVersion"]) > new Version(8, 0); if (xr.ReadToDescendant("App")) { ProductID = xr["ProductID"]; DisplayName = xr["Title"]; Description = xr["Description"]; if (DisplayName.StartsWith("@")) { try { object[] attributes = Assembly.Load(Deployment.Current.EntryPointAssembly).GetCustomAttributes(typeof(AssemblyProductAttribute), false); if (attributes.Length > 0) { AssemblyProductAttribute productAttribute = attributes[0] as AssemblyProductAttribute; if (productAttribute != null) { DisplayName = productAttribute.Product; } } } catch { // will fail from background task } } Version = new Version(xr["Version"]).ToPackageVersion(); PublisherDisplayName = xr["Publisher"]; PublisherId = xr["PublisherID"]; if (xr.ReadToDescendant("IconPath")) { Logo = ImagePathToUri(xr); } if (xr.ReadToFollowing("Capabilities")) { bool more = xr.ReadToDescendant("Capability"); while (more) { Capability newCapability = (Capability)0; DeviceCapability newDeviceCapability = (DeviceCapability)0; switch (xr["Name"]) { case "ID_CAP_NETWORKING": newCapability = Capability.Internet; break; /*case "ID_CAP_IDENTITY_DEVICE": * newCapability = Capability.IdentityDevice; * break; * case "ID_CAP_IDENTITY_USER": * newCapability = Capability.IdentityUser; * break; * case "ID_FUNCCAP_EXTEND_MEM": * newCapability = Capability.ExtendedMemory; * break;*/ case "ID_CAP_LOCATION": newDeviceCapability = DeviceCapability.Location; break; case "ID_CAP_SENSORS": newDeviceCapability = DeviceCapability.Sensors; break; case "ID_CAP_MICROPHONE": newDeviceCapability = DeviceCapability.Microphone; break; //case "ID_CAP_MEDIALIB": // newCapability = Capability.MediaLibrary; // break; case "ID_CAP_MEDIALIB_AUDIO": newCapability = Capability.Music; break; case "ID_CAP_MEDIALIB_PHOTO": newCapability = Capability.Pictures; break; /*case "ID_CAP_MEDIALIB_PLAYBACK": * newCapability = Capability.MusicLibraryPlayback; * break; * case "ID_CAP_GAMERSERVICES": * newCapability = Capability.GamerServices; * break;*/ case "ID_CAP_PHONEDIALER": newCapability = Capability.PhoneDialer; break; case "ID_CAP_PUSH_NOTIFICATION": newCapability = Capability.PushNotification; break; case "ID_CAP_REMOVABLE_STORAGE": newCapability = Capability.RemovableStorage; break; /*case "ID_CAP_WEBBROWSERCOMPONENT": * newCapability = Capability.WebBrowserComponent; * break; * case "ID_CAP_RINGTONE_ADD": * newCapability = Capability.RingtoneAdd; * break;*/ case "ID_CAP_PROXIMITY": newDeviceCapability = DeviceCapability.Proximity; break; case "ID_CAP_SPEECH_RECOGNITION": newCapability = Capability.SpeechRecognition; break; case "ID_CAP_VOIP": newCapability = Capability.Voip; break; case "ID_CAP_WALLET": newCapability = Capability.Wallet; break; /*case "ID_CAP_WALLET_PAYMENTINSTRUMENTS": * newCapability = Capability.WalletPaymentInstruments; * break; * case "ID_CAP_WALLET_SECUREELEMENT": * newCapability = Capability.WalletSecureElement; * break;*/ case "ID_CAP_APPOINTMENTS": newCapability = Capability.Appointments; break; case "ID_CAP_CONTACTS": newCapability = Capability.Contacts; break; case "ID_CAP_ISV_CAMERA": newDeviceCapability = DeviceCapability.Camera; break; } global::System.Diagnostics.Debug.WriteLine((int)newCapability); Capabilities |= newCapability; DeviceCapabilities |= newDeviceCapability; more = xr.ReadToNextSibling("Capability"); } } } } xr.Dispose(); }
public void AddCapability(Capability capability) { _capabilities.Add(capability); }
public static extern int XInputGetCapabilities ( int dwUserIndex, // [in] Index of the gamer associated with the device int dwFlags, // [in] Input flags that identify the device type ref Capability pCapabilities // [out] Receives the capabilities );
public DisconnectTest(ITestOutputHelper output) { _log = TestLogging.GetInstance(); Assert.True(Capability.IPv4Support() || Capability.IPv6Support()); }
private void NewFileAgentInventoryVariablePriceHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response) { NewFileAgentInventoryVariablePriceMessage message; if (LLUtil.TryGetMessage<NewFileAgentInventoryVariablePriceMessage>(request.Body, out message)) { NewFileAgentInventoryVariablePriceReplyMessage reply = new NewFileAgentInventoryVariablePriceReplyMessage(); reply.ResourceCost = 0; reply.UploadPrice = 0; // Create a one time upload capability reply.Rsvp = m_scene.Capabilities.AddOneTimeCapability(cap.OwnerID, true, delegate(Capability _cap, IHttpClientContext _context, IHttpRequest _request, IHttpResponse _response) { NewFileAgentInventoryVariablePriceUploadHandler(message, _cap, _context, _request, _response); } ); LLUtil.SendLLSDXMLResponse(response, reply.Serialize()); } else { m_log.Warn("Received invalid data for NewFileAgentInventoryVariablePrice"); response.Status = System.Net.HttpStatusCode.BadRequest; } }
public override bool IsSupported(Capability capabilities) { return capabilities != null && (!capabilities.LoginDisabled || capabilities.AuthenticationMechanisms.Contains("PLAIN")); }
public void BasicTest_StaticIPv6LoopbackIndex_ExceptionIfV6NotSupported() { Assert.True(Capability.IPv6Support()); _log.WriteLine("Loopback IPv6 index: " + NetworkInterface.IPv6LoopbackInterfaceIndex); }
public BlockBoolInvert() { width = 100; height = 50; Capability capability = new Capability(this); capability.AddDataInput("", "bool"); capability.AddDataOutput("", "bool"); UpdateConnectors(); Name = "Invert"; }
public BlockGenericEvent() { width = 100; height = 50; Capability capability = new Capability(this); capability.AddTriggerOutput(""); UpdateConnectors(); }
private static byte[] GetPingPayload(AddressFamily addressFamily) // On Unix, Non-root processes cannot send arbitrary data in the ping packet payload => Capability.CanUseRawSockets(addressFamily) || PlatformDetection.IsOSXLike ? TestSettings.PayloadAsBytes : Array.Empty <byte>();
public BlockSetDebugLed() { width = 100; height = 50; Capability capability = new Capability(this); capability.AddDataInput("State", "bool"); capability.AddTriggerInput(""); UpdateConnectors(); Name = "Set Debug LED"; }
protected async Task RequestNamesViaCapability(Capability cap) { if (cap.CapabilityType != CapabilityType.Http) { Logger.LogWarning($"AvatarNameCache: GetDisplayName capability not of type HTTP. ({cap.CapabilityType})"); return; } string url = ""; lock (PendingRequests) { bool first = true; foreach (Request request in PendingRequests.Where(x => x.Value.IsRequested == false).Select(x => x.Value)) { if (url.Length >= NAME_URL_SEND_THRESHOLD) { break; } url += $"{(first ? "?" : "&")}ids={request.AgentId.ToString()}"; request.IsRequested = true; first = false; } } if (url == "") { return; } url = $"{cap.Url}/{url}"; try { HttpWebRequest request = WebRequest.CreateHttp(url); request.ServerCertificateValidationCallback = (sender, certificate, chain, errors) => true; request.Method = "GET"; var response = (HttpWebResponse)await request.GetResponseAsync(); if (response.StatusCode != HttpStatusCode.OK) { throw new Exception($"WARN AvatarNameCache.RequestNamesViaCapability: Get failed with return code {response.StatusCode}."); } int length = (int)response.ContentLength; var contentStream = response.GetResponseStream(); if (contentStream == null) { throw new Exception($"AvatarNameCache.RequestNamesViaCapability: Failed to get response stream."); } var buffer = new byte[length]; try { int count = 0; int start = 0; while ((count = await contentStream.ReadAsync(buffer, start, length - start)) != 0) { start += count; } } catch (IOException ex) { if (!ex.Message.StartsWith("The response ended prematurely")) { throw; } } string responseText = Encoding.UTF8.GetString(buffer).Replace("\0", ""); XmlDocument document = new XmlDocument(); document.Load(new StringReader(responseText)); ProcessResponse(document); } catch (Exception e) { Logger.LogWarning($"AvatarNameCache.RequestNamesViaCapability: Exception {e}"); } }
public void Create() { Capabilities.Clear(); width = 100; height = 50; ProductDataBase.Device device = ProductDataBase.GetDeviceByID(DeviceType); if (device != null) { Capability capability = new Capability(this); ProductDataBase.Device.RemoteEvent evnt = device.GetRemoteEventByID(EventID); if (evnt != null) { foreach (ProductDataBase.Device.RemoteEvent.Output o in evnt.Outputs) { capability.AddDataOutput(o.Name, o.Type); } foreach (ProductDataBase.Device.RemoteEvent.Input i in evnt.Inputs) { if (i.Type == "void") capability.AddTriggerInput(i.Name); else capability.AddDataInput(i.Name, i.Type); } if (capability.TriggerInputs.Count == 0 && (capability.TriggerInputs.Count != 0 || capability.DataOutputs.Count == 0)) { capability.AddTriggerInput("Trigger"); } } } UpdateConnectors(); }
private void ProvisionVoiceAccountRequestHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response) { ProvisionVoiceAccountRequestMessage reply = new ProvisionVoiceAccountRequestMessage(); reply.Username = String.Empty; reply.Password = String.Empty; // TODO: Implement this once we have Freeswitch support //LLUtil.SendLLSDXMLResponse(response, reply.Serialize()); }
public override bool HasAgreedCapability(Capability capability) => false;
/// <summary> /// Negotiates the size of the page. /// </summary> /// <param name="scanSettings">The scan settings.</param> public void NegotiatePageSize(ScanSettings scanSettings) { var cap = new Capability(Capabilities.Supportedsizes, TwainType.Int16, _applicationId, SourceId); if ((PageType)cap.GetBasicValue().Int16Value != PageType.UsLetter) { Capability.SetBasicCapability(Capabilities.Supportedsizes, (ushort)scanSettings.Page.Size, TwainType.UInt16, _applicationId, SourceId); } }
private void NewFileAgentInventoryHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response) { NewFileAgentInventoryMessage message; if (LLUtil.TryGetMessage<NewFileAgentInventoryMessage>(request.Body, out message)) { m_log.Error("Implement NewFileAgentInventory"); } else { m_log.Warn("Received invalid data for NewFileAgentInventory"); response.Status = System.Net.HttpStatusCode.BadRequest; } }
private void ObjectMediaHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response) { ObjectMediaMessage message; if (LLUtil.TryGetMessage <ObjectMediaMessage>(request.Body, out message)) { if (message.Request is ObjectMediaRequest) { ObjectMediaRequest mediaRequest = (ObjectMediaRequest)message.Request; ISceneEntity entity; if (m_scene.TryGetEntity(mediaRequest.PrimID, out entity) && entity is LLPrimitive) { LLPrimitive prim = (LLPrimitive)entity; ObjectMediaResponse reply = new ObjectMediaResponse(); reply.PrimID = prim.ID; reply.FaceMedia = prim.Prim.FaceMedia ?? new MediaEntry[0]; reply.Version = prim.Prim.MediaVersion ?? String.Empty; LLUtil.SendLLSDXMLResponse(response, reply.Serialize()); } else { m_log.Warn("Received an ObjectMedia request for unknown prim " + mediaRequest.PrimID); } } else if (message.Request is ObjectMediaUpdate) { ObjectMediaUpdate update = (ObjectMediaUpdate)message.Request; ISceneEntity entity; if (m_scene.TryGetEntity(update.PrimID, out entity) && entity is LLPrimitive) { LLPrimitive prim = (LLPrimitive)entity; int lastVersion = ParseMediaVersion(prim.Prim.MediaVersion); prim.Prim.FaceMedia = update.FaceMedia; prim.Prim.MediaVersion = CreateMediaVersion(lastVersion + 1, cap.OwnerID); // Set the CurrentURL fields for (int i = 0; i < prim.Prim.FaceMedia.Length; i++) { MediaEntry entry = prim.Prim.FaceMedia[i]; if (entry != null && String.IsNullOrEmpty(entry.CurrentURL)) { entry.CurrentURL = entry.HomeURL; } } // Set the texture face media flags for (int i = 0; i < prim.Prim.Textures.FaceTextures.Length; i++) { Primitive.TextureEntryFace face = prim.Prim.Textures.FaceTextures[i]; MediaEntry entry = (update.FaceMedia.Length > i) ? update.FaceMedia[i] : null; if (entry != null) { if (face == null) { face = prim.Prim.Textures.CreateFace((uint)i); } face.MediaFlags = true; } else if (face != null) { face.MediaFlags = false; } } m_scene.EntityAddOrUpdate(this, prim, UpdateFlags.FullUpdate, 0); } else { m_log.Warn("Could not update ObjectMedia for " + update.PrimID + ", prim not found"); } } else { m_log.Warn("Unrecognized ObjectMedia message: " + message.Request); } } else { m_log.Warn("Received invalid data for ObjectMedia"); response.Status = System.Net.HttpStatusCode.BadRequest; } }
public override bool IsSupported(Capability capabilities) { return(capabilities.XoAuth2); }
public BlockDelay() { width = 100; height = 50; Capability capability = new Capability(this); capability.AddTriggerOutput(""); capability.AddTriggerInput("Reset"); capability.AddDataInput("Delay", "int"); UpdateConnectors(); }
public static Capability <string> FromPostViewSize(Capability <string> info) { return(AsDisplayNames <string>(info, FromPostViewSize)); }
public BlockIntConstant() { width = 50; height = 50; Capability capability = new Capability(this); capability.AddDataOutput("", "int"); UpdateConnectors(); Name = "Constant"; }
public static Capability <string> FromViewAngle(Capability <int> info) { return(AsDisplayNames <int>(info, FromViewAngle)); }
public void Create() { Capabilities.Clear(); width = 100; height = 50; ProductDataBase.Device device = ProductDataBase.GetDeviceByID(DeviceType); if (device != null) { ProductDataBase.Device.Event evnt = device.GetEventByID(EventID); if (evnt != null) { Capability capability = new Capability(this); capability.AddTriggerOutput("Trigger"); foreach (ProductDataBase.Device.Event.Output o in evnt.Outputs) { capability.AddDataOutput(o.Name, o.Type); } } } UpdateConnectors(); }
public static Capability <string> FromMovieQuality(Capability <string> info) { return(AsDisplayNames <string>(info, FromMovieQuality)); }
public CapabilityRequestMessage(Capability capability) { Capabilities = new[] {capability.Name}; }
public static Capability <string> FromStillImageSize(Capability <StillImageSize> info) { return(AsDisplayNames <StillImageSize>(info, FromStillImageSize)); }
private void ViewerStatsHandler(Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response) { ViewerStatsMessage message; if (LLUtil.TryGetMessage<ViewerStatsMessage>(request.Body, out message)) { DateTime timestamp = DateTime.UtcNow; if (m_statsTracker != null) { // Log timestamped data points m_statsTracker.LogEntry(timestamp, message.SessionID, "AgentFPS", message.AgentFPS); m_statsTracker.LogEntry(timestamp, message.SessionID, "AgentMemoryUsed", message.AgentMemoryUsed); m_statsTracker.LogEntry(timestamp, message.SessionID, "AgentPing", message.AgentPing); m_statsTracker.LogEntry(timestamp, message.SessionID, "AgentsInView", message.AgentsInView); m_statsTracker.LogEntry(timestamp, message.SessionID, "FailuresInvalid", message.FailuresInvalid); m_statsTracker.LogEntry(timestamp, message.SessionID, "FailuresOffCircuit", message.FailuresOffCircuit); m_statsTracker.LogEntry(timestamp, message.SessionID, "FailuresResent", message.FailuresResent); m_statsTracker.LogEntry(timestamp, message.SessionID, "FailuresSendPacket", message.FailuresSendPacket); m_statsTracker.LogEntry(timestamp, message.SessionID, "InCompressedPackets", message.InCompressedPackets); m_statsTracker.LogEntry(timestamp, message.SessionID, "InKbytes", message.InKbytes); m_statsTracker.LogEntry(timestamp, message.SessionID, "InPackets", message.InPackets); m_statsTracker.LogEntry(timestamp, message.SessionID, "InSavings", message.InSavings); m_statsTracker.LogEntry(timestamp, message.SessionID, "MetersTraveled", message.MetersTraveled); m_statsTracker.LogEntry(timestamp, message.SessionID, "MiscInt1", message.MiscInt1); m_statsTracker.LogEntry(timestamp, message.SessionID, "MiscInt2", message.MiscInt2); m_statsTracker.LogEntry(timestamp, message.SessionID, "MiscString1", message.MiscString1); m_statsTracker.LogEntry(timestamp, message.SessionID, "MiscVersion", message.MiscVersion); m_statsTracker.LogEntry(timestamp, message.SessionID, "ObjectKbytes", message.object_kbytes); m_statsTracker.LogEntry(timestamp, message.SessionID, "OutCompressedPackets", message.OutCompressedPackets); m_statsTracker.LogEntry(timestamp, message.SessionID, "OutKbytes", message.OutKbytes); m_statsTracker.LogEntry(timestamp, message.SessionID, "OutPackets", message.OutPackets); m_statsTracker.LogEntry(timestamp, message.SessionID, "OutSavings", message.OutSavings); m_statsTracker.LogEntry(timestamp, message.SessionID, "RegionsVisisted", message.RegionsVisited); m_statsTracker.LogEntry(timestamp, message.SessionID, "SimulatorFPS", message.SimulatorFPS); m_statsTracker.LogEntry(timestamp, message.SessionID, "StatsDropped", message.StatsDropped); m_statsTracker.LogEntry(timestamp, message.SessionID, "StatsFailedResends", message.StatsFailedResends); m_statsTracker.LogEntry(timestamp, message.SessionID, "TextureKbytes", message.texture_kbytes); m_statsTracker.LogEntry(timestamp, message.SessionID, "WorldKbytes", message.world_kbytes); // Update constant values for this session m_statsTracker.SetValue(message.SessionID, "AgentLanguage", message.AgentLanguage); m_statsTracker.SetValue(message.SessionID, "AgentRuntime", message.AgentRuntime); m_statsTracker.SetValue(message.SessionID, "AgentStartTime", message.AgentStartTime); m_statsTracker.SetValue(message.SessionID, "AgentVersion", message.AgentVersion); m_statsTracker.SetValue(message.SessionID, "SystemCPU", message.SystemCPU); m_statsTracker.SetValue(message.SessionID, "SystemGPU", message.SystemGPU); m_statsTracker.SetValue(message.SessionID, "SystemGPUClass", message.SystemGPUClass); m_statsTracker.SetValue(message.SessionID, "SystemGPUVendor", message.SystemGPUVendor); m_statsTracker.SetValue(message.SessionID, "SystemGPUVersion", message.SystemGPUVersion); m_statsTracker.SetValue(message.SessionID, "SystemInstalledRam", message.SystemInstalledRam); m_statsTracker.SetValue(message.SessionID, "SystemOS", message.SystemOS); m_statsTracker.SetValue(message.SessionID, "VertexBuffersEnabled", message.VertexBuffersEnabled); } } else { m_log.Warn("Received invalid data for ViewerStats"); response.Status = System.Net.HttpStatusCode.BadRequest; } }
public static Capability <string> FromWhiteBalance(Capability <string> info) { return(AsDisplayNames <string>(info, FromWhiteBalance)); }
private void NewFileAgentInventoryUploadHandler(NewFileAgentInventoryMessage message, Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response) { byte[] assetData = request.GetBody(); UUID assetID = UUID.Zero; UUID itemID = UUID.Zero; m_log.Debug("Received inventory asset upload from " + cap.OwnerID + " (" + assetData.Length + " bytes)"); if (assetData != null && assetData.Length > 0) { string contentType = LLUtil.LLAssetTypeToContentType((int)message.AssetType); // Create the asset if (m_assetClient.StoreAsset(contentType, false, false, assetData, cap.OwnerID, out assetID)) { // Create the inventory item LLInventoryItem item = new LLInventoryItem(); item.AssetID = assetID; item.ContentType = contentType; item.CreationDate = DateTime.UtcNow; item.CreatorID = cap.OwnerID; item.Description = message.Description; item.ID = UUID.Random(); item.Name = message.Name; item.OwnerID = cap.OwnerID; item.ParentID = message.FolderID; item.Permissions = (m_permissions != null) ? m_permissions.GetDefaultPermissions() : Permissions.FullPermissions; item.SalePrice = 10; item.SaleType = SaleType.Not; if (m_inventoryClient.TryCreateItem(cap.OwnerID, item)) itemID = item.ID; else m_log.Warn("Failed to create inventory item for uploaded asset " + assetID); } else { m_log.WarnFormat("Failed to store uploaded inventory asset ({0} bytes)", assetData.Length); } } else { m_log.Warn("Inventory asset upload contained no data"); } // Build the response message OSDMap reply = new OSDMap { { "state", OSD.FromString("complete") }, { "new_asset", OSD.FromUUID(assetID) }, { "new_inventory_item", OSD.FromUUID(itemID) } }; LLUtil.SendLLSDXMLResponse(response, reply); }
public static Capability <string> FromFocusMode(Capability <string> info) { return(AsDisplayNames <string>(info, FromFocusMode)); }
private void NewFileAgentInventoryVariablePriceUploadHandler(NewFileAgentInventoryVariablePriceMessage message, Capability cap, IHttpClientContext context, IHttpRequest request, IHttpResponse response) { byte[] assetData = request.GetBody(); UUID assetID = UUID.Zero; LLInventoryItem item = null; m_log.Debug("Received inventory asset upload from " + cap.OwnerID + " (" + assetData.Length + " bytes)"); if (assetData != null && assetData.Length > 0) { string contentType = LLUtil.LLAssetTypeToContentType((int)message.AssetType); // Create the asset if (m_assetClient.StoreAsset(contentType, false, false, assetData, cap.OwnerID, out assetID)) { // Create the inventory item item = new LLInventoryItem(); item.AssetID = assetID; item.ContentType = contentType; item.CreationDate = DateTime.UtcNow; item.CreatorID = cap.OwnerID; item.Description = message.Description; item.ID = UUID.Random(); item.Name = message.Name; item.OwnerID = cap.OwnerID; item.ParentID = message.FolderID; Permissions perms = (m_permissions != null) ? m_permissions.GetDefaultPermissions() : Permissions.FullPermissions; perms.EveryoneMask = message.EveryoneMask; perms.GroupMask = message.GroupMask; perms.NextOwnerMask = message.NextOwnerMask; item.Permissions = perms; item.SalePrice = 10; item.SaleType = SaleType.Not; if (!m_inventoryClient.TryCreateItem(cap.OwnerID, item)) m_log.Warn("Failed to create inventory item for uploaded asset " + assetID); } else { m_log.WarnFormat("Failed to store uploaded inventory asset ({0} bytes)", assetData.Length); } } else { m_log.Warn("Inventory asset upload contained no data"); } // Build the response message NewFileAgentInventoryUploadReplyMessage reply = new NewFileAgentInventoryUploadReplyMessage(); reply.NewAsset = assetID; if (item != null) { reply.NewInventoryItem = item.ID; reply.NewBaseMask = item.Permissions.BaseMask; reply.NewEveryoneMask = item.Permissions.EveryoneMask; reply.NewNextOwnerMask = item.Permissions.NextOwnerMask; reply.NewOwnerMask = item.Permissions.OwnerMask; } LLUtil.SendLLSDXMLResponse(response, reply.Serialize()); }
internal static Capability <string> FromZoomSetting(Capability <string> info) { return(AsDisplayNames <string>(info, FromZoomSetting)); }
internal static Capability <string> FromStillQuality(Capability <string> info) { return(AsDisplayNames <string>(info, FromStillQuality)); }
private async Task OnSelectionChanged <T>(object sender, Capability <T> param, AsyncAction <T> action) { await OnComboBoxChanged(sender, param, async (selected) => { await action.Invoke(selected); }); }