/// <summary>
/// Serializes the specified <see cref="Element"/> to XML.
/// </summary>
/// <param name="root">
/// The <c>Element</c> to serialize, including all its children.
/// </param>
/// <remarks>
/// The generated XML will be indented and have a full XML
/// declaration header.
/// </remarks>
/// <exception cref="ArgumentNullException">root is null.</exception>
public void Serialize(Element root)
{
var settings = new XmlWriterSettings();
settings.Indent = true;
//settings.NamespaceHandling = NamespaceHandling.OmitDuplicates;
this.Serialize(root, settings);
}
public void ShouldCallSetBackgroundColorOnlyOnceWithNestedCallsToOnAndOff()
{
// GIVEN
var domContainer = new Mock<DomContainer>().Object;
var nativeElementMock = new Mock<INativeElement>();
var element = new Element(domContainer, nativeElementMock.Object);
Settings.HighLightColor = "myTestColor";
var highLight = new HighlightAction(element);
nativeElementMock.Expect(nativeElement => nativeElement.IsElementReferenceStillValid()).Returns(true);
nativeElementMock.Expect(nativeElement => nativeElement.GetStyleAttributeValue("backgroundColor")).Returns("initialColor").AtMostOnce();
nativeElementMock.Expect(nativeElement => nativeElement.SetStyleAttributeValue("backgroundColor", "myTestColor")).AtMostOnce();
nativeElementMock.Expect(nativeElement => nativeElement.SetStyleAttributeValue("backgroundColor", "initialColor")).AtMostOnce();
// WHEN
highLight.On();
highLight.On();
highLight.On();
highLight.Off();
highLight.Off();
highLight.Off();
// THEN
nativeElementMock.VerifyAll();
}
/// <summary>
/// Creates texture atlas from stream.
/// </summary>
/// <param name="device"></param>
public TextureAtlas ( RenderSystem rs, Stream stream, bool useSRgb = false )
{
var device = rs.Game.GraphicsDevice;
using ( var br = new BinaryReader(stream) ) {
br.ExpectFourCC("ATLS", "texture atlas");
int count = br.ReadInt32();
for ( int i=0; i<count; i++ ) {
var element = new Element();
element.Index = i;
element.Name = br.ReadString();
element.X = br.ReadInt32();
element.Y = br.ReadInt32();
element.Width = br.ReadInt32();
element.Height = br.ReadInt32();
elements.Add( element );
}
int ddsFileLength = br.ReadInt32();
var ddsImageBytes = br.ReadBytes( ddsFileLength );
texture = new UserTexture( rs, ddsImageBytes, useSRgb );
}
dictionary = elements.ToDictionary( e => e.Name );
}
public void Hover(Element element)
{
var sequenceBuilder = new Actions(selenium);
var actionSequenceBuilder = sequenceBuilder.MoveToElement((IWebElement) element.Native);
var action = actionSequenceBuilder.Build();
action.Perform();
}
/// <summary>
/// Exports a FabricArea as an IfcGroup. There is no geometry to export.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportFabricArea(ExporterIFC exporterIFC, Element element, ProductWrapper productWrapper)
{
if (element == null)
return false;
HashSet<IFCAnyHandle> fabricSheetHandles = null;
if (!ExporterCacheManager.FabricAreaHandleCache.TryGetValue(element.Id, out fabricSheetHandles))
return false;
if (fabricSheetHandles == null || fabricSheetHandles.Count == 0)
return false;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(element, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, revitObjectType);
IFCAnyHandle fabricArea = IFCInstanceExporter.CreateGroup(file, guid,
ownerHistory, name, description, objectType);
productWrapper.AddElement(element, fabricArea);
IFCInstanceExporter.CreateRelAssignsToGroup(file, GUIDUtil.CreateGUID(), ownerHistory,
null, null, fabricSheetHandles, null, fabricArea);
tr.Commit();
return true;
}
}
public void ElementCreate()
{
Element e = new Element(3.141592);
Assert.IsNotNull(e);
Element p = new Element(100);
Element q = new Element(p);
Element z = new Element(DateTime.Now);
ConstExpr j = new ConstExpr(z);
ConstExpr k = new ConstExpr(j.Value.BoolValue());
ConstExpr v = new ConstExpr(k);
ConstExpr u = new ConstExpr(v);
Element b = new Element(true);
Element i = new Element(100);
Element l = new Element(9812080980101);
Element d = new Element(3.1314);
Element s = new Element("Hello World!");
Element dt = new Element(DateTime.Now);
Element ts = new Element(TimeSpan.FromSeconds(100));
Element r = new Element(new Regex("abc[0-9]"));
Assert.IsTrue(b.DataType == ElementType.BOOL);
Assert.IsTrue(l.DataType == ElementType.LONG);
Assert.IsTrue(d.DataType == ElementType.DOUBLE);
Assert.IsTrue(s.DataType == ElementType.STRING);
Assert.IsTrue(dt.DataType == ElementType.DATETIME);
Assert.IsTrue(ts.DataType == ElementType.TIMESPAN);
Assert.IsTrue(r.DataType == ElementType.REGEX);
}
/// <summary>
/// Gets IFC covering type for an element.
/// </summary>
/// <param name="element">
/// The element.
/// </param>
/// <param name="typeName">
/// The type name.
/// </param>
public static Toolkit.IFCCoveringType GetIFCCoveringType(Element element, string typeName)
{
string value = null;
if (!ParameterUtil.GetStringValueFromElementOrSymbol(element, "IfcType", out value))
{
value = typeName;
}
if (String.IsNullOrEmpty(value))
return Toolkit.IFCCoveringType.NotDefined;
string newValue = NamingUtil.RemoveSpacesAndUnderscores(value);
if (String.Compare(newValue, "USERDEFINED", true) == 0)
return Toolkit.IFCCoveringType.UserDefined;
if (String.Compare(newValue, "CEILING", true) == 0)
return Toolkit.IFCCoveringType.Ceiling;
if (String.Compare(newValue, "FLOORING", true) == 0)
return Toolkit.IFCCoveringType.Flooring;
if (String.Compare(newValue, "CLADDING", true) == 0)
return Toolkit.IFCCoveringType.Cladding;
if (String.Compare(newValue, "ROOFING", true) == 0)
return Toolkit.IFCCoveringType.Roofing;
if (String.Compare(newValue, "INSULATION", true) == 0)
return Toolkit.IFCCoveringType.Insulation;
if (String.Compare(newValue, "MEMBRANE", true) == 0)
return Toolkit.IFCCoveringType.Membrane;
if (String.Compare(newValue, "SLEEVING", true) == 0)
return Toolkit.IFCCoveringType.Sleeving;
if (String.Compare(newValue, "WRAPPING", true) == 0)
return Toolkit.IFCCoveringType.Wrapping;
return Toolkit.IFCCoveringType.NotDefined;
}
public Element GetPrivate(Jid jid, Element element)
{
CheckArgs(jid, element);
var elementStr = ExecuteScalar<string>(new SqlQuery("jabber_private").Select("element").Where("jid", jid.Bare).Where("tag", element.TagName).Where("namespace", element.Namespace));
return !string.IsNullOrEmpty(elementStr) ? ElementSerializer.DeSerializeElement<Element>(elementStr) : null;
}
public void AddResource(Element element)
{
locker.EnterWriteLock();
try
{
CreateDir();
string filePath = Path.Combine(this.path, ResXResourceFileHelper.GetFileName(element.Category, element.Culture));
XDocument document = GetResxDocument(filePath);
if (document == null)
{
document = CreateResXDocument();
}
var exists = document.Root.Elements("data")
.FirstOrDefault(d => d.Attribute("name").Value == element.Name);
if (exists == null)
{
document.Root.Add(
new XElement("data",
new XAttribute("name", element.Name),
new XAttribute(XNamespace.Xml + "space", "preserve"),
new XElement("value", element.Value)));
document.Save(filePath);
}
}
finally
{
locker.ExitWriteLock();
}
}
/// <summary>
/// Exports an element to IFC footing.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="element">
/// The element.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="ifcEnumType">
/// The string value represents the IFC type.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportFooting(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement,
string ifcEnumType, IFCProductWrapper productWrapper)
{
// export parts or not
bool exportParts = PartExporter.CanExportParts(element);
if (exportParts && !PartExporter.CanExportElementInPartExport(element, element.Level.Id, false))
return;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(setter.GetPlacement());
IFCAnyHandle prodRep = null;
if (!exportParts)
{
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
prodRep = RepresentationUtil.CreateBRepProductDefinitionShape(element.Document.Application, exporterIFC,
element, catId, geometryElement, bodyExporterOptions, null, ecData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodRep))
{
ecData.ClearOpenings();
return;
}
}
string instanceGUID = ExporterIFCUtils.CreateGUID(element);
string origInstanceName = exporterIFC.GetName();
string instanceName = NamingUtil.GetNameOverride(element, origInstanceName);
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string instanceElemId = NamingUtil.CreateIFCElementId(element);
Toolkit.IFCFootingType footingType = GetIFCFootingType(element, ifcEnumType);
IFCAnyHandle footing = IFCInstanceExporter.CreateFooting(file, instanceGUID, exporterIFC.GetOwnerHistoryHandle(),
instanceName, instanceDescription, instanceObjectType, ecData.GetLocalPlacement(), prodRep, instanceElemId, footingType);
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, element, footing, productWrapper, setter, setter.GetPlacement(), null);
}
productWrapper.AddElement(footing, setter, ecData, LevelUtil.AssociateElementToLevel(element));
OpeningUtil.CreateOpeningsIfNecessary(footing, element, ecData, exporterIFC, ecData.GetLocalPlacement(), setter, productWrapper);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
}
}
tr.Commit();
}
}
/// <summary>
/// Creates uniformat classification.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC.</param>
/// <param name="file">The file.</param>
/// <param name="element">The element.</param>
/// <param name="elemHnd">The element handle.</param>
public static void CreateUniformatClassification(ExporterIFC exporterIFC, IFCFile file, Element element, IFCAnyHandle elemHnd)
{
// Create Uniformat classification, if it is not set.
string uniformatKeyString = "Uniformat";
string uniformatCode = "";
if (ParameterUtil.GetStringValueFromElementOrSymbol(element, BuiltInParameter.UNIFORMAT_CODE, false, out uniformatCode) == null)
ParameterUtil.GetStringValueFromElementOrSymbol(element, "Assembly Code", out uniformatCode);
string uniformatDescription = "";
if (!String.IsNullOrWhiteSpace(uniformatCode))
{
if (ParameterUtil.GetStringValueFromElementOrSymbol(element, BuiltInParameter.UNIFORMAT_DESCRIPTION, false, out uniformatDescription) == null)
ParameterUtil.GetStringValueFromElementOrSymbol(element, "Assembly Description", out uniformatDescription);
}
IFCAnyHandle classification;
if (!ExporterCacheManager.ClassificationCache.ClassificationHandles.TryGetValue(uniformatKeyString, out classification))
{
classification = IFCInstanceExporter.CreateClassification(file, "http://www.csiorg.net/uniformat", "1998", null, uniformatKeyString);
ExporterCacheManager.ClassificationCache.ClassificationHandles.Add(uniformatKeyString, classification);
}
InsertClassificationReference(exporterIFC, file, element, elemHnd, uniformatKeyString, uniformatCode, uniformatDescription, "http://www.csiorg.net/uniformat" );
}
private void CheckArgs(Jid jid, Element element)
{
if (jid == null) throw new ArgumentNullException("jid");
if (element == null) throw new ArgumentNullException("element");
if (string.IsNullOrEmpty(element.TagName)) throw new ArgumentNullException("element.TagName");
if (string.IsNullOrEmpty(element.Namespace)) throw new ArgumentNullException("element.Namespace");
}
/// <summary>
/// Calculates the end hook angle for a rebar.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
/// <param name="element">The element to calculate the value.</param>
/// <param name="elementType">The element type.</param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
RebarBendData bendData = null;
if (element is Rebar)
bendData = (element as Rebar).GetBendData();
else if (element is RebarInSystem)
bendData = (element as RebarInSystem).GetBendData();
if (bendData != null)
{
if (bendData.HookLength1 > MathUtil.Eps())
{
ElementId hookAtEndTypeId;
if (ParameterUtil.GetElementIdValueFromElement(element, BuiltInParameter.REBAR_ELEM_HOOK_END_TYPE, out hookAtEndTypeId) != null)
{
RebarHookType rebarHookType = element.Document.GetElement(hookAtEndTypeId) as RebarHookType;
if (rebarHookType != null)
{
//HookAngle is measured in radians, so scale directly.
m_Angle = rebarHookType.HookAngle *180 / Math.PI;
return true;
}
}
}
}
return false;
}
/// <summary>
/// Exports a Rebar, AreaReinforcement or PathReinforcement to IFC ReinforcingBar.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="element">The element.</param>
/// <param name="filterView">The view.</param>
/// <param name="productWrapper">The product wrapper.</param>
public static void Export(ExporterIFC exporterIFC,
Element element, Autodesk.Revit.DB.View filterView, ProductWrapper productWrapper)
{
if (element is Rebar)
{
ExportRebar(exporterIFC, element, filterView, productWrapper);
}
else if (element is AreaReinforcement)
{
AreaReinforcement areaReinforcement = element as AreaReinforcement;
IList<ElementId> rebarIds = areaReinforcement.GetRebarInSystemIds();
Document doc = areaReinforcement.Document;
foreach (ElementId id in rebarIds)
{
Element rebarInSystem = doc.GetElement(id);
ExportRebar(exporterIFC, rebarInSystem, filterView, productWrapper);
}
}
else if (element is PathReinforcement)
{
PathReinforcement pathReinforcement = element as PathReinforcement;
IList<ElementId> rebarIds = pathReinforcement.GetRebarInSystemIds();
Document doc = pathReinforcement.Document;
foreach (ElementId id in rebarIds)
{
Element rebarInSystem = doc.GetElement(id);
ExportRebar(exporterIFC, rebarInSystem, filterView, productWrapper);
}
}
}
public void ParseEquity(Element fieldData)
{
string tenor = fieldData.GetElementAsString("ID_BB_SEC_NUM_DES");
double px_mid = fieldData.GetElementAsFloat64("PRIOR_CLOSE_MID");
tenor = tenor.Replace(isin,"");
pointsCourbe.Add(TenorToDate(tenor), px_mid);
}
public override void ElementHandle(XmppStream stream, Element element, XmppHandlerContext context)
{
context.Sender.SendTo(stream, new Compressed());
var connection = context.Sender.GetXmppConnection(stream.ConnectionId);
connection.SetStreamTransformer(new GZipTransformer());
context.Sender.ResetStream(stream);
}
public Route(Element route, Jid from, Jid to)
: this()
{
RouteElement = route;
From = from;
To = to;
}
public void SetElementMenuDetail(Element element)
{
if (element != null)
{
_elementMenuDetail = element;
}
}
public WorkDetailViewModel(Element Element = null)
{
if(Element != null)
{
this.Content = GetWorkByElement(Element);
}
}
public PathViewModel(RepositoryNavigationRequest request, AbstractTreeNode node)
{
Elements = new List<Element>();
CurrentItem = new Element(
new RepositoryNavigationRequest(request) { Path = node.Path },
request.Treeish,
node);
var currentNode = node;
while (currentNode.Parent != null)
{
currentNode = currentNode.Parent;
if (currentNode.Parent != null)
{
Elements.Add(
new Element(new RepositoryNavigationRequest(request) { Path = currentNode.Path },
request.Treeish,
currentNode));
}
}
Elements = new List<Element>(Elements.Reverse());
Root = new Element(request, request.Treeish, currentNode);
IsRootEqualToCurrentItem = (currentNode == node);
}
public Element ReadNextElement()
{
if (_atEof || ReadBoundary())
return null;
var elem = new Element();
string header;
while ((header = ReadHeaders()) != null)
{
if (StrUtils.StartsWith(header, "Content-Disposition:", true))
{
elem.Name = GetContentDispositionAttribute(header, "name");
elem.Filename = StripPath(GetContentDispositionAttributeWithEncoding(header, "filename"));
}
else if (StrUtils.StartsWith(header, "Content-Type:", true))
{
elem.ContentType = header.Substring("Content-Type:".Length).Trim();
}
}
long start = data.Position;
elem.Start = start;
long pos = MoveToNextBoundary();
if (pos == -1)
return null;
elem.Length = pos - start;
return elem;
}
/// <summary>
/// Calculates perimeter for a slab.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
if (extrusionCreationData == null)
return false;
m_Perimeter = extrusionCreationData.ScaledOuterPerimeter;
return m_Perimeter > MathUtil.Eps();
}
/// <summary>
/// Calculates shape parameter A for a rebar.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
/// <param name="element">The element to calculate the value.</param>
/// <param name="elementType">The element type.</param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
bool ret = (ParameterUtil.GetDoubleValueFromElement(element, BuiltInParameterGroup.PG_GEOMETRY, "A", out m_ShapeParameterA) != null);
if (ret)
m_ShapeParameterA = UnitUtil.ScaleLength(m_ShapeParameterA);
return ret;
}
public MemberAccess(TextPosition tp, Element acs, string member)
: base(tp)
{
Access = acs;
Member = member;
AppendChild(Access);
}
public void AllAttributesEmptyOrNull_TwoAttributesOneWithValues()
{
Element element = new Element();
element.MaxOccurs = 1;
element.MinOccurs = 0;
element.Name = "baseElement";
element.Parent = null;
element.RootElement = true;
element.SpecialLength = false;
element.Type = "DataType.String";
element.Value = "baseElement";
element.Documentation = "baseElement";
element.IsAdvanced = true;
NewRelic.AgentConfiguration.Parts.Attribute attribute = new NewRelic.AgentConfiguration.Parts.Attribute();
attribute.Name = "attributeName";
attribute.Parent = element;
element.Attributes.Add(attribute);
NewRelic.AgentConfiguration.Parts.Attribute attribute2 = new NewRelic.AgentConfiguration.Parts.Attribute();
attribute2.Name = "attribute2Name";
attribute2.Parent = element;
attribute2.Value = "attribute2Value";
element.Attributes.Add(attribute2);
Assert.IsFalse(element.AllAttributesEmptyOrNull());
}
// Извърша двоично търсене.
private static int BinarySearch(Element<int>[] elements, int elementToSearch)
{
int leftIndex = 0;
int rightIndex = elements.Length - 1;
int result = NotFound;
while (leftIndex <= rightIndex)
{
int midIndex = (leftIndex + rightIndex) / 2;
if (elementToSearch < elements[midIndex].Key)
{
rightIndex = midIndex - 1;
}
else if (elementToSearch > elements[midIndex].Key)
{
leftIndex = midIndex + 1;
}
else
{
result = midIndex;
break;
}
}
return result;
}
public void Check(Element field)
{
var seleniumElement = SeleniumElement(field);
if (!seleniumElement.Selected)
seleniumElement.Click();
}
/// <summary>
/// Called when the collider associated encounters another collider.
/// Check if the object encountered is an element, if it is the case, it is put in <see cref="ElementDetected"/>.
/// </summary>
/// <param name="other">The collider encountered.</param>
void OnTriggerEnter2D(Collider2D other)
{
Component com = other.gameObject.GetComponent<Element>();
Element element = com as Element;
if (element != null)
ElementDetected = element;
}
/// <summary>
/// Renders a single value that can be selected by the user.
/// </summary>
/// <param name="label">Text representing the value to the user.</param>
/// <param name="value">The value that will be applied to the setting if chosen by the user.</param>
/// <param name="parent">DOM element that should be the parent of the value's DOM fragment.</param>
protected void renderValue(string label, object value, Element parent)
{
// Creates a SPAN element
var span = (HTMLSpanElement)window.document.createElement("SPAN");
span.innerHTML = label;
// As with the menu, handling the mousedown event prevents focus changes caused by the click event on some browsers
span.addEventListener("mousedown", (e) =>
{
e.preventDefault();
e.stopPropagation();
// do nothing if this is already the selected value
if (this.value == value) return;
// select the new value
this.value = value;
select(value);
// notify the menu and other settings of the selection
triggerChanged(key, value);
}, false);
span["value"] = value;
spans.push(span);
parent.appendChild(span);
}
public void UpdateVisibility(Element element)
{
var mainWindow = MainWindow.MIns;
if (mainWindow == null)
return;
if (element?.GetElementType() == null)
return;
switch (element.GetElementType().GetElementType())
{
case ElementType.Type.BUILDING_CITYGUARD_HOUSE:
EnableCanvas(mainWindow.recruit_cityguard);
break;
case ElementType.Type.BUILDING_MOONGLOW_TOWER:
EnableCanvas(mainWindow.recruit_mage);
EnableCanvas(mainWindow.recruit_warlock);
break;
case ElementType.Type.BUILDING_STABLE:
EnableCanvas(mainWindow.recruit_crossbow);
EnableCanvas(mainWindow.recruit_knight);
EnableCanvas(mainWindow.recruit_paladin);
break;
case ElementType.Type.BUILDING_TRAINING_GROUND:
EnableCanvas(mainWindow.recruit_berserker);
EnableCanvas(mainWindow.recruit_guardian);
EnableCanvas(mainWindow.recruit_ranger);
EnableCanvas(mainWindow.recruit_templar);
break;
}
}
internal static NSAttributedString ToAttributed(this FormattedString formattedString, Element owner,
Color defaultForegroundColor)
{
if (formattedString == null)
{
return(null);
}
var attributed = new NSMutableAttributedString();
foreach (var span in formattedString.Spans)
{
if (span.Text == null)
{
continue;
}
attributed.Append(span.ToAttributed(owner, defaultForegroundColor));
}
return(attributed);
}
// public override void Layout (int l, int t, int r, int b)
// {
// base.Layout (l, t, r, b);
// }
void Clicked(object sender, AdapterView.ItemClickEventArgs e)
{
Element.NotifyItemSelected(Element.Items.ToList()[e.Position]);
}
protected override void UpdatePlaceholderColor()
{
_hintColorSwitcher = _hintColorSwitcher ?? new TextColorSwitcher(EditText.HintTextColors, Element.UseLegacyColorManagement());
_hintColorSwitcher.UpdateTextColor(EditText, Element.PlaceholderColor, EditText.SetHintTextColor);
}
protected override void UpdateTextColor(Color color)
{
_textColorSwitcher = _textColorSwitcher ?? new TextColorSwitcher(EditText.TextColors, Element.UseLegacyColorManagement());
_textColorSwitcher.UpdateTextColor(EditText, color);
}
IEnumerable <IHtmlAttribute> IHtmlElement.Attributes()
{
return(Element.Attributes());
}
IEnumerable <IHtmlNode> IHtmlContainer.Nodes()
{
return(Element.Nodes());
}
protected virtual void UpdateFont()
{
EditText.Typeface = Element.ToTypeface();
EditText.SetTextSize(ComplexUnitType.Sp, (float)Element.FontSize);
}
protected virtual void OnImageFailed(object sender, ExceptionRoutedEventArgs exceptionRoutedEventArgs)
{
Log.Warning("Image Loading", $"Image failed to load: {exceptionRoutedEventArgs.ErrorMessage}");
Element?.SetIsLoading(false);
}
