bool TryReduceBlockWidth(BlockElement root, int blockEndIndex, int blockWidth, out int restartAtIndex, out int restartBlockWidth) { restartAtIndex = 0; restartBlockWidth = 0; for (int i = blockEndIndex; i >= 0; i--) { AElement e = root.Children[i]; if (e.IsThisAtomABreakingSpace) { return(false); } blockWidth -= e.Width; if (blockWidth <= root.Width) { // if this is text, hyphenate, otherwise just insert a line break. if (e is CharacterElement) { AElement hyphen = new InternalHyphenBreakElement(e.Style); if (blockWidth + hyphen.Width <= root.Width) { root.Children.Insert(i, hyphen); restartBlockWidth = blockWidth; restartAtIndex = i; return(true); } continue; } root.Children.Insert(i, new InternalLineBreakElement(e.Style)); restartBlockWidth = blockWidth; restartAtIndex = i; return(true); } } return(false); }
public void ParseTag(HTMLchunk chunk, AElement atom) { if (!chunk.bClosure || chunk.bEndClosure) { // create the tag and add it to the list of open tags. OpenTag tag = new OpenTag(chunk); m_OpenTags.Add(tag); // parse the tag (which will update the StyleParser's current style ParseTag(tag, atom); // if the style has changed and atom is not null, set the atom's style to the current style. if (atom != null) { atom.Style = Style; } // if this is a self-closing tag (<br/>) close it! if (chunk.bEndClosure) { CloseOneTag(chunk); } } else { CloseOneTag(chunk); } }
public ButtonAsIcon(AElement parent, int page, string icon_normal = null, string icon_down = null, string icon_hover = null) : base(parent, page) { m_IconNormal = icon_normal; m_IconDown = icon_down; m_IconHover = icon_hover; }
// ============================================================================================================ // Get Carat Position, given an input index into the text or a clicked position // ============================================================================================================ public Point GetCaratPositionByIndex(int textIndex) { Point carat = Point.Zero; if (m_Root == null) { return(carat); } int index = 0; for (int i = 0; i < m_Root.Children.Count; i++) { AElement e = m_Root.Children[i]; if (index == textIndex && !e.IsThisAtomInternalOnly) { return(carat); } if (e.IsThisAtomALineBreak) { carat.X = 0; carat.Y += e.Height; } carat.X += e.Width; if (e.IsThisAtomInternalOnly) { if (index == textIndex) { return(carat); } index--; } index++; } return(carat); }
public static Elements.Div Generate(AElement element, string id, string cssClass) { var newDivInstance = new Elements.Div(child: element, id: id, cssClass: cssClass); newDivInstance.Rendered = GenerateDivBody(id: id, cssClass: cssClass, content: element?.Rendered); return(newDivInstance); }
public MenuBar(List<MenuElement> children, AElement parent, int page) : base(parent, page) { if (children == null) m_Elements = new List<MenuElement>(); else m_Elements = children; HandlesMouseInput = true; }
public TabBar(AElement parent, int page, string[] items = null) : base(parent, page) { HandlesMouseInput = true; if (items != null) foreach (string item in items) AddTab(item); }
public ACompiledScript(XmlElement elem, XmlPrefixMap map, AElement parent) : base(elem, map, parent) { lock (_rand) { _className = _NextName(); _functionName = _NextName(); } }
public Property(string propertyValue, AElement element, PropertyInfo propertyInfo) { PropertyName = element.Name; PropertyValue = propertyValue; Element = element; PropertyInfo = propertyInfo; }
public static Property InitProperty(IAutoviewDto autoviewDto, AElement element, ModelStateDictionary modelstate) { PropertyInfo getPropertyInfo = GetPropertyInfoOfDtoByName(autoviewDto, propertyName: element.Name); string getPropertyValue = Extensions.GetPropertyValue(autoviewDto, propertyInfo: getPropertyInfo); var newProperty = new Property(propertyValue: getPropertyValue, element, propertyInfo: getPropertyInfo); InitPropertyErrors(property: ref newProperty, modelstate); newProperty.Element = newProperty.Element.InitialElement(property: newProperty); return(newProperty); }
private void OnTriggerEnter(Collider collider) { // Check if other is AElement AElement other = collider.GetComponent <AElement>(); if (other != null) { // React with other's element ElementalReaction(other.Element); // Destroy other if it's a Projectile // if (other is ElementalProjectile && other.gameObject.layer != 17) // Destroy(other.gameObject); } }
private void OnTriggerEnter(Collider collider) { AElement other = collider.GetComponent <AElement>(); if (other != null) { ElementalReaction(other.Element); // Destroy other if it's a Projectile if (other is ElementalProjectile) { Destroy(other.gameObject); } } }
public void InterpretHREF(HTMLchunk chunk, AElement atom) { if (chunk.EndClosure) { } // solo anchor elements are meaningless. if (!chunk.Closure) { // opening a hyperlink! RecalculateStyle(); var tag = new OpenTag(chunk); _openTags.Add(tag); ParseTag(tag, atom); } else { RecalculateStyle(); // closing a hyperlink. } }
public int GetCaratIndexByPosition(Point pointInText) { int index = 0; if (m_Root == null) { return(index); } Rectangle rect = new Rectangle(0, 0, 0, 0); for (int i = 0; i < m_Root.Children.Count; i++) { AElement e = m_Root.Children[i]; rect.Width = e.Width; rect.Height = e.Height; if (rect.Contains(pointInText)) { return(index); } if (e.IsThisAtomALineBreak) { rect.Width = m_MaxWidth - rect.X; if (rect.Contains(pointInText)) { return(e.IsThisAtomInternalOnly ? index - 1 : index); } rect.X = 0; rect.Y += e.Height; } if (e.IsThisAtomInternalOnly) { index--; } rect.X += e.Width; index++; } // check for click at bottom of page rect = new Rectangle(0, rect.Y, m_MaxWidth, 2000); if (rect.Contains(pointInText)) { return(index); // end of the last line } return(-1); // don't change }
private void OnTriggerEnter(Collider collider) { // Check if other is AElement AElement other = collider.GetComponent <AElement>(); if (other != null) { if (other is ElementalProjectile) { ElementalProjectile elemProj = other.GetComponent <ElementalProjectile>(); if (elemProj.InstanceID != gameObject.GetInstanceID()) { // React with other's element ElementalReaction(other.Element); } } else { // React with other's element ElementalReaction(other.Element); } } }
void CalculateLayoutWidthsRecursive(BlockElement root) { int longestBlockWidth = 0, blockWidth = 0; int longestLineWidth = 0, lineWidth = 0; int styleWidth = 0; bool isLastElement = false; for (int i = 0; i < root.Children.Count; i++) { AElement e = root.Children[i]; isLastElement = i >= root.Children.Count - 1; if (e is BlockElement) { e.Width = root.Width; CalculateLayoutWidthsRecursive(e as BlockElement); blockWidth += (e as BlockElement).Layout_MinWidth; lineWidth += (e as BlockElement).Layout_MaxWidth; } else { if (!e.IsThisAtomABreakingSpace) { blockWidth += e.Width; } if (e.IsThisAtomABreakingSpace || isLastElement) { if (blockWidth > root.Width) { int restartAtIndex, restartBlockWidth; if (TryReduceBlockWidth(root, i - 1, blockWidth + styleWidth, out restartAtIndex, out restartBlockWidth)) { i = restartAtIndex - 1; blockWidth = restartBlockWidth; lineWidth = restartBlockWidth; continue; } } if (blockWidth + styleWidth > longestBlockWidth) { longestBlockWidth = blockWidth + styleWidth; } blockWidth = 0; } lineWidth += e.Width; if (e.Style.ExtraWidth > styleWidth) { styleWidth = e.Style.ExtraWidth; } } if (e.IsThisAtomALineBreak || isLastElement) { if (blockWidth + styleWidth > longestBlockWidth) { longestBlockWidth = blockWidth + styleWidth; } if (lineWidth + styleWidth > longestLineWidth) { longestLineWidth = lineWidth + styleWidth; } blockWidth = 0; lineWidth = 0; styleWidth = 0; } } root.Layout_MinWidth = longestBlockWidth; root.Layout_MaxWidth = longestLineWidth; }
// ============================================================================================================ // Parse and create boxes // ============================================================================================================ BlockElement ParseHtmlToBlocks(string html) { IResourceProvider provider = Service.Get <IResourceProvider>(); StyleParser styles = new StyleParser(provider); BlockElement root, currentBlock; root = currentBlock = new BlockElement("root", styles.Style); // this is the root! // if this is not HTML, do not parse tags. Otherwise search out and interpret tags. bool parseHTML = true; if (!parseHTML) { for (int i = 0; i < html.Length; i++) { currentBlock.AddAtom(new CharacterElement(styles.Style, html[i])); } } else { m_Parser.Init(html); HTMLchunk chunk; while ((chunk = ParseNext(m_Parser)) != null) { if (!(chunk.oHTML == string.Empty)) { // This is a span of text. string text = chunk.oHTML; // make sure to replace escape characters! text = EscapeCharacters.ReplaceEscapeCharacters(text); //Add the characters to the current box for (int i = 0; i < text.Length; i++) { currentBlock.AddAtom(new CharacterElement(styles.Style, text[i])); } } else { // This is a tag. interpret the tag and edit the openTags list. // It may also be an atom, in which case we should add it to the list of atoms! AElement atom = null; if (chunk.bClosure && !chunk.bEndClosure) { styles.CloseOneTag(chunk); if (currentBlock.Tag == chunk.sTag) { currentBlock = currentBlock.Parent; } } else { bool isBlockTag = false; switch (chunk.sTag) { // ==================================================================================== // Anchor elements are added to the open tag collection as HREFs. case "a": styles.InterpretHREF(chunk, null); break; // ==================================================================================== // These html elements are ignored. case "body": break; // ==================================================================================== // These html elements are blocks but can also have styles case "center": case "left": case "right": case "div": atom = new BlockElement(chunk.sTag, styles.Style); styles.ParseTag(chunk, atom); isBlockTag = true; break; // ==================================================================================== // These html elements are styles, and are added to the StyleParser. case "span": case "font": case "b": case "i": case "u": case "outline": case "big": case "basefont": case "medium": case "small": styles.ParseTag(chunk, null); break; // ==================================================================================== // These html elements are added as atoms only. They cannot impart style // onto other atoms. case "br": atom = new CharacterElement(styles.Style, '\n'); break; case "gumpimg": // draw a gump image atom = new ImageElement(styles.Style, ImageElement.ImageTypes.UI); styles.ParseTag(chunk, atom); break; case "itemimg": // draw a static image atom = new ImageElement(styles.Style, ImageElement.ImageTypes.Item); styles.ParseTag(chunk, atom); break; // ==================================================================================== // Every other element is not interpreted, but rendered as text. Easy! default: { string text = html.Substring(chunk.iChunkOffset, chunk.iChunkLength); // make sure to replace escape characters! text = EscapeCharacters.ReplaceEscapeCharacters(text); //Add the characters to the current box for (int i = 0; i < text.Length; i++) { currentBlock.AddAtom(new CharacterElement(styles.Style, text[i])); } } break; } if (atom != null) { currentBlock.AddAtom(atom); if (isBlockTag && !chunk.bEndClosure) { currentBlock = (BlockElement)atom; } } styles.CloseAnySoloTags(); } } } } return(root); }
public VBScript(XmlElement elem, XmlPrefixMap map, AElement parent) : base(elem, map, parent) { }
public ButtonController(AElement model, GUIManager manager) : base(model, manager) { }
public Panel(AElement parent, int page) : base(parent, page) { }
internal static IElement ConstructElementType(XmlElement element, XmlPrefixMap map, AElement parent) { Type t = null; if (BusinessProcess.ElementMapCache != null) { if (BusinessProcess.ElementMapCache.IsCached(element.Name)) { t = BusinessProcess.ElementMapCache[element.Name]; } else { t = Utility.LocateElementType((parent == null ? null : parent.GetType()), element.Name, map); BusinessProcess.ElementMapCache[element.Name] = t; } } else { t = Utility.LocateElementType((parent == null ? null : parent.GetType()), element.Name, map); } if (t != null) { return((IElement)_xmlConstructors[t].Invoke(new object[] { element, map, parent })); } return(null); }
public Button(AElement parent, int page) : base(parent, page) { HandlesMouseInput = true; }
public MessageFlow(XmlElement elem, XmlPrefixMap map, AElement parent) : base(elem, map, parent) { }
public TextBoxController(AElement model, GUIManager manager) : base(model, manager) { }
public CheckBox(AElement parent, int page) : base(parent, page) { HandlesMouseInput = true; FontSize = 14f; }
public EscalationEventDefinition(XmlElement elem, XmlPrefixMap map, AElement parent) : base(elem, map, parent) { }
public AGateway(XmlElement elem, XmlPrefixMap map, AElement parent) : base(elem, map, parent) { }
public Bounds(XmlElement elem, XmlPrefixMap map, AElement parent) : base(elem, map, parent) { }
public TextBox(AElement parent, int page) : base(parent, page) { HandlesMouseInput = true; HandlesKeyboardInput = true; }
public Association(XmlElement elem, XmlPrefixMap map, AElement parent) : base(elem, map, parent) { }
void LayoutElementsHorizontal(BlockElement root, int x, int y, out int ascenderDelta) { int x0 = x; int x1 = x + root.Width; int height = 0, lineHeight = 0; ascenderDelta = 0; int lineBeganAtElementIndex = 0; int lineCount = 0; for (int i = 0; i < root.Children.Count; i++) { AElement e0 = root.Children[i]; if (e0.IsThisAtomALineBreak) { // root alignment styles align a root's children elements within the root width. if (root.Alignment == Alignments.Center) { int centerX = x + (x1 - x0) / 2; for (int j = lineBeganAtElementIndex; j < i; j++) { AElement e1 = root.Children[j]; e1.Layout_X = centerX; centerX += e1.Width; } } else if (root.Alignment == Alignments.Right) { int rightX = x1 - x0; for (int j = lineBeganAtElementIndex; j < i; j++) { AElement e1 = root.Children[j]; e1.Layout_X = rightX; rightX += e1.Width; } } e0.Layout_X = x0; e0.Layout_Y = y; if (lineHeight < e0.Height) { lineHeight = e0.Height; } y += lineHeight; x0 = x; x1 = x + root.Width; height += lineHeight; lineHeight = 0; lineBeganAtElementIndex = i + 1; lineCount++; if (MaxLineCount > 0 && lineCount >= MaxLineCount) { int index = 0; for (int j = 0; j < i; j++) { index += root.Children[j].IsThisAtomInternalOnly ? 0 : 1; } root.Children.RemoveRange(i, root.Children.Count - i); m_OnPageOverflow?.Invoke(index); break; } } else { int wordWidth, styleWidth, wordHeight, ascender; List <AElement> word = LayoutElementsGetWord(root.Children, i, out wordWidth, out styleWidth, out wordHeight, out ascender); if (wordWidth + styleWidth > root.Width) { // Can't fit this word on even a full line. Must break it somewhere. // might as well break it as close to the line end as possible. // TODO: For words VERY near the end of the line, we should not break it, but flow to the next line. LayoutElements_BreakWordAtLineEnd(root.Children, i, x1 - x0, word, wordWidth, styleWidth); i--; } else if (x0 + wordWidth + styleWidth > x1) { // This word is too long for this line. Flow it to the next line without breaking, unless it's a space character, // in which case we insert it before the linebreak. // TODO: we should introduce some heuristic that that super long words aren't flowed. Perhaps words // longer than 8 chars, where the break would be after character 3 and before 3 characters from the end? if (word.Count == 1 && word[0].IsThisAtomABreakingSpace) { root.Children.Insert(i + 1, new InternalLineBreakElement(e0.Style)); } else { root.Children.Insert(i, new InternalLineBreakElement(e0.Style)); i--; } } else { // This word can fit on the current line without breaking. Lay it out! foreach (AElement e1 in word) { if (e1 is BlockElement) { Alignments alignment = (e1 as BlockElement).Alignment; switch (alignment) { case Alignments.Left: e1.Layout_X = x0; e1.Layout_Y = y; x0 += e1.Width; break; case Alignments.Center: // centered in the root element, not in the remaining space. e1.Layout_X = (x + root.Width - e1.Width) / 2; e1.Layout_Y = y; break; case Alignments.Right: e1.Layout_X = x1 - e1.Width; e1.Layout_Y = y; x1 -= e1.Width; break; } LayoutElements((e1 as BlockElement)); } else { e1.Layout_X = x0; e1.Layout_Y = y; // -ascender; x0 += e1.Width; } } if (y + ascender < ascenderDelta) { ascenderDelta = y + ascender; } if (wordHeight > lineHeight) { lineHeight = wordHeight; } i += word.Count - 1; } } if (e0.Height > lineHeight) { lineHeight = e0.Height; } } root.Height = height + lineHeight; }
public MenuBarController(AElement model, GUIManager manager) : base(model, manager) { }
public ATask(XmlElement elem, XmlPrefixMap map, AElement parent) : base(elem, map, parent) { }
public RadioButton(AElement parent, int page, RadioButtonGroup group) : base(parent, page) { IsDown = false; Group = group; }
public ANegatableCondition(XmlElement elem, XmlPrefixMap map, AElement parent) : base(elem, map, parent) { }
public GreaterThanOrEqualCondition(XmlElement elem, XmlPrefixMap map, AElement parent) : base(elem, map, parent) { }
public Participant(XmlElement elem, XmlPrefixMap map, AElement parent) : base(elem, map, parent) { }
public AScript(XmlElement elem, XmlPrefixMap map, AElement parent) : base(elem, map, parent) { _map = map; }
public EndEvent(XmlElement elem, XmlPrefixMap map, AElement parent) : base(elem, map, parent) { }
public static void InitalElement(this IAutoviewDto autoviewDto, AElement element) { Mainboard.Elements.Add(item: element); }
public Plane(XmlElement elem, XmlPrefixMap map, AElement parent) : base(elem, map, parent) { }
public Label(AElement parent, int page, string caption) : base(parent, page) { Caption = caption; }