public override object CreateDomElement(object parentRef, out object domElementWhereToPlaceChildren)
{
dynamic passwordField = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("input", parentRef, this);
domElementWhereToPlaceChildren = passwordField; // Note: this value is used by the Padding_Changed method to set the padding of the PasswordBox.
INTERNAL_HtmlDomManager.SetDomElementAttribute(passwordField, "type", "password", forceSimulatorExecuteImmediately: true);
//passwordField.type = "password";
//-----------------------
// Prepare to raise the "TextChanged" event and to update the value of the "Text" property when the DOM text changes:
//-----------------------
//todo: why did we put this here instead of in INTERNAL_AttachToDomEvents?
if (IsRunningOnInternetExplorer())
{
//-----------------------
// Fix "input" event not working under IE:
//-----------------------
this.GotFocus += InternetExplorer_GotFocus;
this.LostFocus += InternetExplorer_LostFocus;
INTERNAL_EventsHelper.AttachToDomEvents("textinput", passwordField, (Action <object>)(e =>
{
InternetExplorer_RaisePasswordChangedIfNecessary();
}));
INTERNAL_EventsHelper.AttachToDomEvents("paste", passwordField, (Action <object>)(e =>
{
InternetExplorer_RaisePasswordChangedIfNecessary();
}));
INTERNAL_EventsHelper.AttachToDomEvents("cut", passwordField, (Action <object>)(e =>
{
InternetExplorer_RaisePasswordChangedIfNecessary();
}));
INTERNAL_EventsHelper.AttachToDomEvents("keyup", passwordField, (Action <object>)(e =>
{
InternetExplorer_RaisePasswordChangedIfNecessary();
}));
INTERNAL_EventsHelper.AttachToDomEvents("delete", passwordField, (Action <object>)(e =>
{
InternetExplorer_RaisePasswordChangedIfNecessary();
}));
INTERNAL_EventsHelper.AttachToDomEvents("mouseup", passwordField, (Action <object>)(e =>
{
InternetExplorer_RaisePasswordChangedIfNecessary();
}));
}
else
{
//-----------------------
// Modern browsers
//-----------------------
INTERNAL_EventsHelper.AttachToDomEvents("input", passwordField, (Action <object>)(e =>
{
PasswordAreaValueChanged();
}));
}
//textArea.style.resize = "none"; //to avoid letting the posibility to the user to resize the TextBox
return(passwordField);
}
public override object CreateDomElement(object parentRef, out object domElementWhereToPlaceChildren)
{
//<img style="width: 100%; height: 100%;" src="C:\Users\Sylvain\Documents\Adventure Maker v4.7\Projects\ASA_game\Icons\settings.ico" alt="settings" />
var div = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("div", parentRef, this);
var intermediaryDomStyle = INTERNAL_HtmlDomManager.GetDomElementStyleForModification(div);
intermediaryDomStyle.lineHeight = "0px"; //this one is to fix in Firefox the few pixels gap that appears below the image whith certain displays (table, table-cell and possibly some others)
var img = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("img", div, this);
INTERNAL_HtmlDomManager.SetDomElementAttribute(img, "src", TransparentGifOnePixel);
INTERNAL_HtmlDomManager.SetDomElementAttribute(img, "alt", " "); //the text displayed when the image cannot be found. We set it as an empty string since there is nothing in Xaml
var style = INTERNAL_HtmlDomManager.GetDomElementStyleForModification(img);
style.display = "block"; //this is to avoid a random few pixels wide gap below the image.
style.width = "0"; // Defaulting to 0 because if there is no source set, we want the 1x1 transparent placeholder image to be sure to take no space. If the source is set, it will then be set to "inherit"
style.height = "0"; // Same as above.
style.objectPosition = "center top";
CSHTML5.Interop.ExecuteJavaScriptAsync(@"
$0.addEventListener('mousedown', function(e) {
e.preventDefault();
}, false);
$0.addEventListener('error', function(e) {
this.src = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7';
this.style.width = 0;
this.style.height = 0;
});
", img);
_imageDiv = img;
domElementWhereToPlaceChildren = null;
return(div);
}
public override object CreateDomElement(object parentRef, out object domElementWhereToPlaceChildren)
{
var div = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("div", parentRef, this);
var style = INTERNAL_HtmlDomManager.GetDomElementStyleForModification(div);
style.overflow = "display";
style.position = "relative";
domElementWhereToPlaceChildren = div;
return(div);
//domElementWhereToPlaceChildren = div;
//var div1 = INTERNAL_HtmlDomManager.CreateDomElement("div");
//var div2 = INTERNAL_HtmlDomManager.CreateDomElement("div");
//div2.style.position = "absolute";
//INTERNAL_HtmlDomManager.AppendChild(div1, div2);
//domElementWhereToPlaceChildren = div2;
//return div;
/* -------------------------------
* A canvas should look like this:
* -------------------------------
* <div style="width: 50px; height: 50px;">
* <div style="position:relative"> width & height are the size of the canvas itself
* ... children (with position: absolute), below are two example of children
* <div style="background-color: rgb(200,0,200);width:20px;height:20px; position: absolute"></div>
* <div style="background-color: rgb(100,0,200);width:20px;height:20px;margin-left:20px;margin-right:auto; position: absolute"></div>
* </div>
* </div>
*/
}
public override object CreateDomElement(object parentRef, out object domElementWhereToPlaceChildren)
{
var span = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("span", parentRef, this);
domElementWhereToPlaceChildren = span;
return(span);
}
public override object CreateDomElement(object parentRef, out object domElementWhereToPlaceChildren)
{
//<img style="width: 100%; height: 100%;" src="C:\Users\Sylvain\Documents\Adventure Maker v4.7\Projects\ASA_game\Icons\settings.ico" alt="settings" />
var div = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("div", parentRef, this);
var img = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("img", div, this);
INTERNAL_HtmlDomManager.SetDomElementAttribute(img, "alt", " "); //the text displayed when the image cannot be found. We set it as an empty string since there is nothing in Xaml
var style = INTERNAL_HtmlDomManager.GetDomElementStyleForModification(img);
style.display = "block"; //this is to avoid a random few pixels wide gap below the image.
style.width = "100%";
style.height = "100%";
style.objectPosition = "center top";
CSHTML5.Interop.ExecuteJavaScriptAsync(@"
$0.addEventListener('mousedown', function(e) {
e.preventDefault();
}, false);", img);
_imageDiv = img;
domElementWhereToPlaceChildren = null;
return(div);
}
public override object CreateDomElement(object parentRef, out object domElementWhereToPlaceChildren)
{
var linebreak = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("br", parentRef, this);
domElementWhereToPlaceChildren = linebreak;
return(linebreak);
}
public override object CreateDomElement(object parentRef, out object domElementWhereToPlaceChildren)
{
dynamic a = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("a", parentRef, this);
domElementWhereToPlaceChildren = a;
return(a);
}
public override object CreateDomElement(object parentRef, out object domElementWhereToPlaceChildren)
{
var span = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("span", parentRef, this);
var style = INTERNAL_HtmlDomManager.GetDomElementStyleForModification(span);
style.textDecoration = "inherit";
domElementWhereToPlaceChildren = span;
return(span);
}
/*
* // Summary:
* // Arranges the content of a System.Windows.Controls.WrapPanel element.
* //
* // Parameters:
* // finalSize:
* // The System.Windows.Size that this element should use to arrange its child
* // elements.
* //
* // Returns:
* // The System.Windows.Size that represents the arranged size of this System.Windows.Controls.WrapPanel
* // element and its children.
* protected override Size ArrangeOverride(Size finalSize);
* //
* // Summary:
* // Measures the child elements of a System.Windows.Controls.WrapPanel in anticipation
* // of arranging them during the System.Windows.Controls.WrapPanel.ArrangeOverride(System.Windows.Size)
* // pass.
* //
* // Parameters:
* // constraint:
* // An upper limit System.Windows.Size that should not be exceeded.
* //
* // Returns:
* // The System.Windows.Size that represents the desired size of the element.
* protected override Size MeasureOverride(Size constraint);
* */
public override object CreateDomElement(object parentRef, out object domElementWhereToPlaceChildren)
{
var div = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("div", parentRef, this);
var divStyle = INTERNAL_HtmlDomManager.GetDomElementStyleForModification(div);
//divStyle.overflow = "auto";
divStyle.lineHeight = "0px";
domElementWhereToPlaceChildren = div;
return(div);
}
public override object CreateDomElement(object parentRef, out object domElementWhereToPlaceChildren)
{
dynamic div = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("div", parentRef, this);
dynamic divStyle = INTERNAL_HtmlDomManager.GetDomElementStyleForModification(div);
divStyle.whiteSpace = TextWrapping == TextWrapping.NoWrap ? "pre" : "pre-wrap";
divStyle.overflow = "hidden"; //keeps the text from overflowing despite the TextBlock's size limitations.
divStyle.textAlign = "left"; // this is the default value.
domElementWhereToPlaceChildren = div;
return(div);
}
public override object CreateDomChildWrapper(object parentRef, out object domElementWhereToPlaceChild, int index = -1)
{
var div = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("div", parentRef, this);
var divStyle = INTERNAL_HtmlDomManager.GetDomElementStyleForModification(div);
divStyle.overflow = "hidden"; //keeps the text from overflowing despite the RichTextBlock's size limitations.
divStyle.textAlign = "left"; // this is the default value.
divStyle.width = "100%";
domElementWhereToPlaceChild = div;
return(div);
}
public override object CreateDomElement(object parentRef, out object domElementWhereToPlaceChildren)
{
var div = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("div", parentRef, this);
var divStyle = INTERNAL_HtmlDomManager.GetDomElementStyleForModification(div);
domElementWhereToPlaceChildren = div;
divStyle.width = "100%"; //todo: see if there are cases where we do not want this to be 100%
divStyle.height = "100%"; //todo: see if there are cases where we do not want this to be 100%
return(div);
}
public override object CreateDomChildWrapper(object parentRef, out object domElementWhereToPlaceChild, int index = -1)
{
if (Orientation == Controls.Orientation.Horizontal)
{
var div = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("div", parentRef, this, index);
var divStyle = INTERNAL_HtmlDomManager.GetDomElementStyleForModification(div);
divStyle.display = "inline-block";
divStyle.lineHeight = "initial";
domElementWhereToPlaceChild = div;
return(div);
}
else
{
domElementWhereToPlaceChild = null;
return(null);
}
}
internal static object CreateDomElementForPathAndSimilar(UIElement associatedUIElement, object parentRef, out object canvasDomElement, out object domElementWhereToPlaceChildren)
{
domElementWhereToPlaceChildren = null;
var div = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("div", parentRef, associatedUIElement);
var divStyle = INTERNAL_HtmlDomManager.GetDomElementStyleForModification(div);
//divStyle.overflow = "hidden";
divStyle.width = "100%";
divStyle.height = "100%";
divStyle.fontSize = "0px"; //this allows this div to be as small as we want (for some reason in Firefox, what contains a canvas has a height of at least about (1 + 1/3) * fontSize)
canvasDomElement = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("canvas", div, associatedUIElement);
var style = INTERNAL_HtmlDomManager.GetDomElementStyleForModification(canvasDomElement);
style.width = "0px";
style.height = "0px";
style.marginBottom = "-4px"; // This is due to the fact that there is a 4px margin at the bottom of the html <canvas>, cf. https://stackoverflow.com/questions/8600393/there-is-a-4px-gap-below-canvas-video-audio-elements-in-html5
return(div);
}
internal static object CreateDomElementForPathAndSimilar(UIElement associatedUIElement, object parentRef, out object canvasDomElement, out object domElementWhereToPlaceChildren)
{
domElementWhereToPlaceChildren = null;
var div = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("div", parentRef, associatedUIElement);
var divStyle = INTERNAL_HtmlDomManager.GetDomElementStyleForModification(div);
//divStyle.overflow = "hidden";
divStyle.lineHeight = "0"; // Line height is not needed in shapes because it causes layout issues.
//divStyle.width = "100%";
//divStyle.height = "100%";
divStyle.fontSize = "0px"; //this allows this div to be as small as we want (for some reason in Firefox, what contains a canvas has a height of at least about (1 + 1/3) * fontSize)
canvasDomElement = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("canvas", div, associatedUIElement);
var style = INTERNAL_HtmlDomManager.GetDomElementStyleForModification(canvasDomElement);
style.width = "0px";
style.height = "0px";
return(div);
}
public override object CreateDomElement(object parentRef, out object domElementWhereToPlaceChildren)
{
dynamic innerDiv = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("div", parentRef, this);
dynamic innerDivStyle = INTERNAL_HtmlDomManager.GetDomElementStyleForModification(innerDiv);
if (TextWrapping == TextWrapping.NoWrap)
{
innerDivStyle.whiteSpace = "nowrap";
}
else //so that we are sure that it will behave the same on all browsers
{
innerDivStyle.whiteSpace = "normal";
}
innerDivStyle.overflow = "hidden"; //keeps the text from overflowing despite the TextBlock's size limitations.
innerDivStyle.textAlign = "left"; // this is the default value.
domElementWhereToPlaceChildren = innerDiv;
return(innerDiv);
}
public override object CreateDomElement(object parentRef, out object domElementWhereToPlaceChildren)
{
if (_useNativeComboBox)
{
var select = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("select", parentRef, this);
domElementWhereToPlaceChildren = select;
_nativeComboBoxDomElement = select;
INTERNAL_EventsHelper.AttachToDomEvents("change", select, (Action <object>)(e =>
{
DomSelectionChanged(select);
}));
INTERNAL_HtmlDomManager.SetDomElementStyleProperty(select, new List <string>()
{
"fontSize"
}, "inherit");
// Add an empty element that will make it easier to have nothing selected when items are added to the ComboBox: // See: http://stackoverflow.com/questions/8605516/default-select-option-as-blank
var emptyOption = INTERNAL_HtmlDomManager.AddOptionToNativeComboBox(_nativeComboBoxDomElement, "");
CSHTML5.Interop.ExecuteJavaScriptAsync("$0.disabled = true", emptyOption);
CSHTML5.Interop.ExecuteJavaScriptAsync("$0.selected = true", emptyOption);
CSHTML5.Interop.ExecuteJavaScriptAsync("$0.style.display = 'hidden'", emptyOption);
// Set the mark saying that the pointer events must be "absorbed" by the ComboBox:
INTERNAL_HtmlDomManager.SetDomElementProperty(select, "data-absorb-events", true);
return(select);
}
else
{
#if !BRIDGE
return(base.CreateDomElement(parentRef, out domElementWhereToPlaceChildren));
#else
return(CreateDomElement_WorkaroundBridgeInheritanceBug(parentRef, out domElementWhereToPlaceChildren));
#endif
}
}
public override object CreateDomElement(object parentRef, out object domElementWhereToPlaceChildren)
{
var select = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("select", parentRef, this);
domElementWhereToPlaceChildren = select;
this._nativeComboBoxDomElement = select;
INTERNAL_HtmlDomManager.SetDomElementStyleProperty(select, new List <string>()
{
"fontSize"
}, "inherit");
// Set the mark saying that the pointer events must be "absorbed" by the ComboBox:
INTERNAL_HtmlDomManager.SetDomElementProperty(select, "data-absorb-events", true);
// Fill the ComboBox and synchronize selection properties
this.Refresh();
// Listen to native selection change event
this.SubscribeToHtmlChangeEvent();
return(select);
}
public override object CreateDomElement(object parentRef, out object domElementWhereToPlaceChildren)
{
_jsDiv = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("div", parentRef, this);
domElementWhereToPlaceChildren = _jsDiv;
return(_jsDiv);
}
public override object CreateDomChildWrapper(object parentRef, out object domElementWhereToPlaceChild)
{
if (Orientation == Orientation.Horizontal)
{
//------v1------//
//NOTE: here, we are in a table
//wrapper for each child:
//<td style="padding:0px">
// <div style="width: inherit;position:relative">
// ...(child)
// </div>
//</td>
//var td = INTERNAL_HtmlDomManager.CreateDomElement("td");
//td.style.position = "relative";
//td.style.padding = "0px";
////var div = INTERNAL_HtmlDomManager.CreateDomElement("div");
////div.style.height = "inherit"; //todo: find a way to make this div actually inherit the height of the td... (otherwise we cannot set its verticalAlignment)
////div.style.position = "relative";
////INTERNAL_HtmlDomManager.AppendChild(td, div);
//domElementWhereToPlaceChild = td;
//return td;
//------v2------// = better because we only use divs, it's more simple and verticalAlignment.Stretch works when the stackPanel's size is hard coded (but it still doesn't work when it's not).
//wrapper for each child - v2
//<div style="display: table-cell;height:inherit;>
// ...
//</div>
var div = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("div", parentRef, this);
var divStyle = INTERNAL_HtmlDomManager.GetDomElementStyleForModification(div);
divStyle.position = "relative";
divStyle.display = "table-cell";
divStyle.height = "100%"; //this allow the stretched items to actually be stretched to the size of the tallest element when the stackpanel's size is only defined by this element.
divStyle.verticalAlign = "middle"; // We use this as a default value for elements that have a "stretch" vertical alignment
domElementWhereToPlaceChild = div;
return(div);
}
else if (Orientation == Orientation.Vertical) //when we arrive here, it should always be true but we never know...
{
//NOTE: here, we are in a div
//wrapper for each child:
//<div style="width: inherit">... </div>
var div = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("div", parentRef, this);
var divStyle = INTERNAL_HtmlDomManager.GetDomElementStyleForModification(div);
divStyle.position = "relative";
divStyle.width = "100%"; // Makes it possible to do horizontal alignment of the element that will be the child of this div.
domElementWhereToPlaceChild = div;
return(div);
}
else
{
throw new NotSupportedException();
}
}
static void AttachVisualChild_Private_MainSteps(UIElement child,
UIElement parent,
int index,
bool doesParentRequireToCreateAWrapperForEachChild,
object innerDivOfWrapperForChild,
object domElementWhereToPlaceChildStuff,
object wrapperForChild)
{
//--------------------------------------------------------
// CREATE THE DIV FOR THE MARGINS (OPTIONAL):
//--------------------------------------------------------
#if PERFSTAT
var t1 = Performance.now();
#endif
// Determine if an additional DIV for handling margins is needed:
object additionalOutsideDivForMargins = null;
var margin = ((FrameworkElement)child).Margin;
bool containsNegativeMargins = (margin.Left < 0d || margin.Top < 0d || margin.Right < 0d || margin.Bottom < 0d);
bool isADivForMarginsNeeded = !(parent is Canvas) && // Note: In a Canvas, we don't want to add the additional DIV because there are no margins and we don't want to interfere with the pointer events by creating an additional DIV.
!(child is Inline); // Note: inside a TextBlock we do not want the HTML DIV because we want to create HTML SPAN elements only (otherwise there would be unwanted line returns).
if (isADivForMarginsNeeded && (parent.IsCustomLayoutRoot || parent.IsUnderCustomLayout))
{
isADivForMarginsNeeded = false;
}
if (isADivForMarginsNeeded)
{
// Determine where to place it:
object whereToPlaceDivForMargins =
(doesParentRequireToCreateAWrapperForEachChild
? innerDivOfWrapperForChild
: domElementWhereToPlaceChildStuff);
// Create and append the DIV for handling margins and append:
additionalOutsideDivForMargins = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("div", whereToPlaceDivForMargins, parent, index); //todo: check if the third parameter should be the child or the parent (make something with margins and put a mouseenter in the parent then see if the event is triggered).
// Style the DIV for handling margins:
var style = INTERNAL_HtmlDomManager.GetDomElementStyleForModification(additionalOutsideDivForMargins);
style.boxSizing = "border-box";
if (child is FrameworkElement &&
(((FrameworkElement)child).HorizontalAlignment == HorizontalAlignment.Stretch && double.IsNaN(((FrameworkElement)child).Width)))
{
if (!containsNegativeMargins)
{
style.width = "100%";
}
}
if (child is FrameworkElement &&
(((FrameworkElement)child).VerticalAlignment == VerticalAlignment.Stretch && double.IsNaN(((FrameworkElement)child).Height)))
{
style.height = "100%";
}
}
#if PERFSTAT
Performance.Counter("VisualTreeManager: Create the DIV for the margin", t1);
#endif
//--------------------------------------------------------
// PREPARE THE CHILD:
//--------------------------------------------------------
#if PERFSTAT
var t2 = Performance.now();
#endif
// Determine where to place the child:
object whereToPlaceTheChild = (isADivForMarginsNeeded
? additionalOutsideDivForMargins : (doesParentRequireToCreateAWrapperForEachChild
? innerDivOfWrapperForChild
: domElementWhereToPlaceChildStuff));
child.IsConnectedToLiveTree = true;
// Set the "ParentWindow" property so that the element knows where to display popups:
child.INTERNAL_ParentWindow = parent.INTERNAL_ParentWindow;
// Create and append the DOM structure of the Child:
object domElementWhereToPlaceGrandChildren = null;
object outerDomElement;
bool isChildAControl = child is Control;
if (child.INTERNAL_HtmlRepresentation == null)
{
bool hasTemplate = isChildAControl && ((Control)child).HasTemplate;
if (hasTemplate)
{
outerDomElement = ((Control)child).CreateDomElementForControlTemplate(whereToPlaceTheChild, out domElementWhereToPlaceGrandChildren);
}
else
{
outerDomElement = child.CreateDomElement(whereToPlaceTheChild, out domElementWhereToPlaceGrandChildren);
}
}
else
{
outerDomElement = INTERNAL_HtmlDomManager.CreateDomFromStringAndAppendIt(child.INTERNAL_HtmlRepresentation, whereToPlaceTheChild, child);
}
// Initialize the "Width" and "Height" of the child DOM structure:
if (child is FrameworkElement)
{
FrameworkElement.INTERNAL_InitializeOuterDomElementWidthAndHeight(((FrameworkElement)child), outerDomElement);
}
// Update the DOM structure of the Child (for example, if the child is a Grid, this will render its rows and columns):
child.INTERNAL_UpdateDomStructureIfNecessary();
// For debugging purposes (to better read the output html), add a class to the outer DIV that tells us the corresponding type of the element (Border, StackPanel, etc.):
INTERNAL_HtmlDomManager.SetDomElementAttribute(outerDomElement, "class", child.GetType().ToString());
// Set Visibility hidden when rendering with CustomLayout
if (child.IsCustomLayoutRoot && child.Visibility == Visibility.Visible)
{
INTERNAL_HtmlDomManager.GetDomElementStyleForModification(outerDomElement).visibility = "hidden";
child.isFirstRendering = true;
}
#if PERFSTAT
Performance.Counter("VisualTreeManager: Prepare the child", t2);
#endif
//--------------------------------------------------------
// REMEMBER ALL INFORMATION FOR FUTURE USE:
//--------------------------------------------------------
#if PERFSTAT
var t3 = Performance.now();
#endif
// Remember the DIVs:
child.INTERNAL_OuterDomElement = outerDomElement;
child.INTERNAL_InnerDomElement = domElementWhereToPlaceGrandChildren;
child.INTERNAL_AdditionalOutsideDivForMargins = additionalOutsideDivForMargins ?? outerDomElement;
child.INTERNAL_InnerDivOfTheChildWrapperOfTheParentIfAny = doesParentRequireToCreateAWrapperForEachChild ? innerDivOfWrapperForChild : null;
// Remember the information about the "VisualChildren":
if (parent.INTERNAL_VisualChildrenInformation == null)
{
parent.INTERNAL_VisualChildrenInformation = new Dictionary <UIElement, INTERNAL_VisualChildInformation>();
}
parent.INTERNAL_VisualChildrenInformation.Add(child,
new INTERNAL_VisualChildInformation()
{
INTERNAL_UIElement = child,
INTERNAL_OptionalChildWrapper_OuterDomElement = wrapperForChild,
INTERNAL_OptionalChildWrapper_ChildWrapperInnerDomElement = innerDivOfWrapperForChild
});
#if PERFSTAT
Performance.Counter("VisualTreeManager: Remember all info for future use", t3);
#endif
//--------------------------------------------------------
// HANDLE SPECIAL CASES:
//--------------------------------------------------------
#if PERFSTAT
var t4 = Performance.now();
#endif
// If we are inside a canvas, we set the position to "absolute":
if (parent is Canvas)
{
INTERNAL_HtmlDomManager.GetDomElementStyleForModification(outerDomElement).position = "absolute"; //todo: test if this works properly
}
UIElement.SetPointerEvents(child);
// Reset the flag that tells if we have already applied the RenderTransformOrigin (this is useful to ensure that the default RenderTransformOrigin is (0,0) like in normal XAML, instead of (0.5,0.5) like in CSS):
child.INTERNAL_RenderTransformOriginHasBeenApplied = false;
#if PERFSTAT
Performance.Counter("VisualTreeManager: Handle special cases", t4);
#endif
//--------------------------------------------------------
// HANDLE EVENTS:
//--------------------------------------------------------
#if PERFSTAT
var t5 = Performance.now();
#endif
// Register DOM events if any:
child.INTERNAL_AttachToDomEvents();
#if PERFSTAT
Performance.Counter("VisualTreeManager: Handle events", t5);
#endif
//--------------------------------------------------------
// SET "ISLOADED" PROPERTY AND CALL "ONATTACHED" EVENT:
//--------------------------------------------------------
// Tell the control that it is now present into the visual tree:
child._isLoaded = true;
// Raise the "OnAttached" event:
child.INTERNAL_OnAttachedToVisualTree(); // IMPORTANT: Must be done BEFORE "RaiseChangedEventOnAllDependencyProperties" (for example, the ItemsControl uses this to initialize its visual)
//--------------------------------------------------------
// RENDER THE ELEMENTS BY APPLYING THE CSS PROPERTIES:
//--------------------------------------------------------
// Defer rendering when the control is not visible to when becomes visible (note: when this option is enabled, we do not apply the CSS properties of the UI elements that are not visible. Those property are applied later, when the control becomes visible. This option results in improved performance.)
bool enableDeferredRenderingOfCollapsedControls =
EnableOptimizationWhereCollapsedControlsAreNotRendered ||
EnableOptimizationWhereCollapsedControlsAreLoadedLast ||
EnableOptimizationWhereCollapsedControlsAreNotLoaded;
if (enableDeferredRenderingOfCollapsedControls && !child.IsVisible)
{
child.INTERNAL_DeferredRenderingWhenControlBecomesVisible = () =>
{
RenderElementsAndRaiseChangedEventOnAllDependencyProperties(child);
child.ClearMeasureAndArrangeValidation();
};
}
else
{
RenderElementsAndRaiseChangedEventOnAllDependencyProperties(child);
}
//--------------------------------------------------------
// HANDLE BINDING:
//--------------------------------------------------------
#if PERFSTAT
var t9 = Performance.now();
#endif
child.INTERNAL_UpdateBindingsSource();
#if PERFSTAT
Performance.Counter("VisualTreeManager: Handle binding", t9);
#endif
//--------------------------------------------------------
// HANDLE TABINDEX:
//--------------------------------------------------------
// For GotFocus and LostFocus to work, the DIV specified by "INTERNAL_OptionalSpecifyDomElementConcernedByFocus"
// (or the OuterDomElement otherwise) needs to have the "tabIndex" attribute set. Therefore we need to always set
// it (unless IsTabStop is False) to its current value (default is Int32.MaxValue). At the time when this code was
// written, there was no way to automatically call the "OnChanged" on a dependency property if no value was set.
// IMPORTANT: This needs to be done AFTER the "OnApplyTemplate" (for example, the TextBox sets the "INTERNAL_OptionalSpecifyDomElementConcernedByFocus" in the "OnApplyTemplate").
if (isChildAControl)
{
if (!(child is TextBlock)) // TextBlock should not count in tabbing (TextBlock is not supposed to be a Control).
{
Control.TabIndexProperty_MethodToUpdateDom(child, ((Control)child).TabIndex);
}
}
//--------------------------------------------------------
// APPLY THE VISIBILITY:
//--------------------------------------------------------
Visibility childVisibility = child.Visibility;
if (childVisibility == Visibility.Collapsed)
{
UIElement.INTERNAL_ApplyVisibility(child, childVisibility);
}
//--------------------------------------------------------
// RAISE THE "SIZECHANGED" EVENT:
//--------------------------------------------------------
#if PERFSTAT
var t10 = Performance.now();
#endif
// Raise the "SizeChanged" event: (note: in XAML, the "SizeChanged" event is called before the "Loaded" event)
// IMPORTANT: This event needs to be raised AFTER the "OnApplyTemplate" and AFTER the "IsLoaded=true" (for example, it is used in the ScrollBar implementation).
if (child is FrameworkElement)
{
((FrameworkElement)child).INTERNAL_SizeChangedWhenAttachedToVisualTree();
}
#if PERFSTAT
Performance.Counter("VisualTreeManager: Raise size changed event", t10);
#endif
//--------------------------------------------------------
// RAISE THE "LOADED" EVENT:
//--------------------------------------------------------
#if PERFSTAT
var t11 = Performance.now();
#endif
// Raise the "Loaded" event: (note: in XAML, the "loaded" event of the children is called before the "loaded" event of the parent)
if (child is FrameworkElement)
{
((FrameworkElement)child).INTERNAL_RaiseLoadedEvent();
}
child.StartManagingPointerPositionForPointerExitedEventIfNeeded();
#if PERFSTAT
Performance.Counter("VisualTreeManager: Raise Loaded event", t11);
#endif
}
static void AttachVisualChild_Private_MainSteps(UIElement child,
UIElement parent,
bool doesParentRequireToCreateAWrapperForEachChild,
object innerDivOfWrapperForChild,
object domElementWhereToPlaceChildStuff,
object wrapperForChild)
{
#if REWORKLOADED
if (INTERNAL_VisualTreeOperation.Current.Root == null)
{
INTERNAL_VisualTreeOperation.Current.Root = parent;
}
#endif
//#if CSHTML5BLAZOR && DEBUG
// string childIndentity = child + (child != null ? " (" + child.GetHashCode() + ")" : "");
// string parentIndentity = parent + (parent != null ? " (" + parent.GetHashCode() + ")" : "");
// Console.WriteLine("OPEN SILVER DEBUG: VisualTreeManager : AttachVisualChild_Private_FinalStepsOnlyIfControlIsVisible: " + childIndentity + " attached to " + parentIndentity);
//#endif
//--------------------------------------------------------
// CREATE THE DIV FOR THE MARGINS (OPTIONAL):
//--------------------------------------------------------
#if PERFSTAT
var t1 = Performance.now();
#endif
// Determine if an additional DIV for handling margins is needed:
object additionalOutsideDivForMargins = null;
var margin = ((FrameworkElement)child).Margin;
bool containsNegativeMargins = (margin.Left < 0d || margin.Top < 0d || margin.Right < 0d || margin.Bottom < 0d);
#if ONLY_ADD_DIV_FOR_MARGINS_WHEN_MARGINS_NOT_ZERO
bool isADivForMarginsNeeded = !(parent is Canvas) && !(child is Inline) && child is FrameworkElement; // Note: In a Canvas, we don't want to add the additional DIV because there are no margins and we don't want to interfere with the pointer events by creating an additional DIV.
if (isADivForMarginsNeeded)
{
var horizontalAlign = ((FrameworkElement)child).HorizontalAlignment;
var verticalAlign = ((FrameworkElement)child).VerticalAlignment;
isADivForMarginsNeeded = !(margin.Left == 0 && margin.Top == 0 && margin.Right == 0 && margin.Bottom == 0 && horizontalAlign == HorizontalAlignment.Stretch && verticalAlign == VerticalAlignment.Stretch);
}
#else
bool isADivForMarginsNeeded = !(parent is Canvas) && // Note: In a Canvas, we don't want to add the additional DIV because there are no margins and we don't want to interfere with the pointer events by creating an additional DIV.
!(child is Inline); // Note: inside a TextBlock we do not want the HTML DIV because we want to create HTML SPAN elements only (otherwise there would be unwanted line returns).
#endif
if (isADivForMarginsNeeded)
{
// Determine where to place it:
object whereToPlaceDivForMargins =
(doesParentRequireToCreateAWrapperForEachChild
? innerDivOfWrapperForChild
: domElementWhereToPlaceChildStuff);
// Create and append the DIV for handling margins and append:
additionalOutsideDivForMargins = INTERNAL_HtmlDomManager.CreateDomElementAndAppendIt("div", whereToPlaceDivForMargins, parent); //todo: check if the third parameter should be the child or the parent (make something with margins and put a mouseenter in the parent then see if the event is triggered).
// Style the DIV for handling margins:
var style = INTERNAL_HtmlDomManager.GetDomElementStyleForModification(additionalOutsideDivForMargins);
style.boxSizing = "border-box";
if (child is FrameworkElement &&
(((FrameworkElement)child).HorizontalAlignment == HorizontalAlignment.Stretch && double.IsNaN(((FrameworkElement)child).Width)))
{
if (!containsNegativeMargins)
{
style.width = "100%";
}
}
if (child is FrameworkElement &&
(((FrameworkElement)child).VerticalAlignment == VerticalAlignment.Stretch && double.IsNaN(((FrameworkElement)child).Height)))
{
style.height = "100%";
}
}
#if PERFSTAT
Performance.Counter("VisualTreeManager: Create the DIV for the margin", t1);
#endif
//--------------------------------------------------------
// PREPARE THE CHILD:
//--------------------------------------------------------
#if PERFSTAT
var t2 = Performance.now();
#endif
// Determine where to place the child:
object whereToPlaceTheChild = (isADivForMarginsNeeded
? additionalOutsideDivForMargins : (doesParentRequireToCreateAWrapperForEachChild
? innerDivOfWrapperForChild
: domElementWhereToPlaceChildStuff));
// Set the "Parent" property of the Child (IMPORTANT: we need to do that before child.CreateDomElement because the type of the parent is used to display the child correctly):
child.INTERNAL_VisualParent = parent;
// Set the "ParentWindow" property so that the element knows where to display popups:
child.INTERNAL_ParentWindow = parent.INTERNAL_ParentWindow;
// Create and append the DOM structure of the Child:
object domElementWhereToPlaceGrandChildren = null;
object outerDomElement;
bool isChildAControl = child is Control;
if (child.INTERNAL_HtmlRepresentation == null)
{
bool hasTemplate = isChildAControl && ((Control)child).HasTemplate;
if (hasTemplate)
{
outerDomElement = ((Control)child).CreateDomElementForControlTemplate(whereToPlaceTheChild, out domElementWhereToPlaceGrandChildren);
}
else
{
outerDomElement = child.CreateDomElement(whereToPlaceTheChild, out domElementWhereToPlaceGrandChildren);
}
}
else
{
outerDomElement = INTERNAL_HtmlDomManager.CreateDomFromStringAndAppendIt(child.INTERNAL_HtmlRepresentation, whereToPlaceTheChild, child);
}
// Initialize the "Width" and "Height" of the child DOM structure:
if (child is FrameworkElement)
{
FrameworkElement.INTERNAL_InitializeOuterDomElementWidthAndHeight(((FrameworkElement)child), outerDomElement);
}
// Update the DOM structure of the Child (for example, if the child is a Grid, this will render its rows and columns):
child.INTERNAL_UpdateDomStructureIfNecessary();
// For debugging purposes (to better read the output html), add a class to the outer DIV that tells us the corresponding type of the element (Border, StackPanel, etc.):
INTERNAL_HtmlDomManager.SetDomElementAttribute(outerDomElement, "class", child.GetType().ToString());
#if PERFSTAT
Performance.Counter("VisualTreeManager: Prepare the child", t2);
#endif
//--------------------------------------------------------
// REMEMBER ALL INFORMATION FOR FUTURE USE:
//--------------------------------------------------------
#if PERFSTAT
var t3 = Performance.now();
#endif
// Remember the DIVs:
child.INTERNAL_OuterDomElement = outerDomElement;
child.INTERNAL_InnerDomElement = domElementWhereToPlaceGrandChildren;
child.INTERNAL_AdditionalOutsideDivForMargins = additionalOutsideDivForMargins ?? outerDomElement;
child.INTERNAL_InnerDivOfTheChildWrapperOfTheParentIfAny = doesParentRequireToCreateAWrapperForEachChild ? innerDivOfWrapperForChild : null;
// Remember the information about the "VisualChildren":
if (parent.INTERNAL_VisualChildrenInformation == null)
{
parent.INTERNAL_VisualChildrenInformation = new Dictionary <UIElement, INTERNAL_VisualChildInformation>();
}
parent.INTERNAL_VisualChildrenInformation.Add(child,
new INTERNAL_VisualChildInformation()
{
INTERNAL_UIElement = child,
INTERNAL_OptionalChildWrapper_OuterDomElement = wrapperForChild,
INTERNAL_OptionalChildWrapper_ChildWrapperInnerDomElement = innerDivOfWrapperForChild
});
#if PERFSTAT
Performance.Counter("VisualTreeManager: Remember all info for future use", t3);
#endif
//--------------------------------------------------------
// HANDLE SPECIAL CASES:
//--------------------------------------------------------
#if PERFSTAT
var t4 = Performance.now();
#endif
// If we are inside a canvas, we set the position to "absolute":
if (parent is Canvas)
{
INTERNAL_HtmlDomManager.GetDomElementStyleForModification(outerDomElement).position = "absolute"; //todo: test if this works properly
}
UIElement.SynchronizeForceInheritProperties(child, parent);
#if REVAMPPOINTEREVENTS
UIElement.INTERNAL_UpdateCssPointerEvents(child);
#else
// If the current element is inside a Grid, we need to explicitly set its CSS property "PointerEvents=auto" because its parent child wrapper has "PointerEvents=none" in order to prevent its child wrappers from overlapping each other and thus preventing clicks on some children.
if (parent is Grid && child is FrameworkElement) //todo: generalize this code so that we have no hard-reference on the Grid control, and third-party controls can use the same mechanics.
{
var frameworkElement = ((FrameworkElement)child);
FrameworkElement.INTERNAL_UpdateCssPointerEventsPropertyBasedOnIsHitTestVisibleAndIsEnabled(frameworkElement, frameworkElement.IsHitTestVisible, frameworkElement.IsEnabled);
}
#endif
// Reset the flag that tells if we have already applied the RenderTransformOrigin (this is useful to ensure that the default RenderTransformOrigin is (0,0) like in normal XAML, instead of (0.5,0.5) like in CSS):
child.INTERNAL_RenderTransformOriginHasBeenApplied = false;
#if PERFSTAT
Performance.Counter("VisualTreeManager: Handle special cases", t4);
#endif
//--------------------------------------------------------
// HANDLE EVENTS:
//--------------------------------------------------------
#if PERFSTAT
var t5 = Performance.now();
#endif
// Register DOM events if any:
child.INTERNAL_AttachToDomEvents();
#if PERFSTAT
Performance.Counter("VisualTreeManager: Handle events", t5);
#endif
//--------------------------------------------------------
// HANDLE INHERITED PROPERTIES:
//--------------------------------------------------------
#if PERFSTAT
var t6 = Performance.now();
#endif
// Get the Inherited properties and pass them to the direct children:
foreach (DependencyProperty dependencyProperty in
#if BRIDGE
INTERNAL_BridgeWorkarounds.GetDictionaryKeys_SimulatorCompatible(parent.INTERNAL_AllInheritedProperties)
#else
parent.INTERNAL_AllInheritedProperties.Keys
#endif
)
{
bool recursively = false; // We don't want a recursion here because the "Attach" method is already recursive due to the fact that we raise property changed on the Children property, which causes to reattach the subtree.
INTERNAL_PropertyStorage storage = parent.INTERNAL_AllInheritedProperties[dependencyProperty];
child.SetInheritedValue(dependencyProperty, INTERNAL_PropertyStore.GetEffectiveValue(storage), recursively);
}
#if PERFSTAT
Performance.Counter("Handle inherited properties", t6);
#endif
//--------------------------------------------------------
// SET "ISLOADED" PROPERTY AND CALL "ONATTACHED" EVENT:
//--------------------------------------------------------
// Tell the control that it is now present into the visual tree:
child._isLoaded = true;
// Raise the "OnAttached" event:
child.INTERNAL_OnAttachedToVisualTree(); // IMPORTANT: Must be done BEFORE "RaiseChangedEventOnAllDependencyProperties" (for example, the ItemsControl uses this to initialize its visual)
//--------------------------------------------------------
// RENDER THE ELEMENTS BY APPLYING THE CSS PROPERTIES:
//--------------------------------------------------------
// Defer rendering when the control is not visible to when becomes visible (note: when this option is enabled, we do not apply the CSS properties of the UI elements that are not visible. Those property are applied later, when the control becomes visible. This option results in improved performance.)
bool enableDeferredRenderingOfCollapsedControls =
EnableOptimizationWhereCollapsedControlsAreNotRendered ||
EnableOptimizationWhereCollapsedControlsAreLoadedLast ||
EnableOptimizationWhereCollapsedControlsAreNotLoaded;
if (enableDeferredRenderingOfCollapsedControls && !child.IsVisible)
{
child.INTERNAL_DeferredRenderingWhenControlBecomesVisible = () =>
{
RenderElementsAndRaiseChangedEventOnAllDependencyProperties(child);
};
}
else
{
RenderElementsAndRaiseChangedEventOnAllDependencyProperties(child);
}
//--------------------------------------------------------
// HANDLE BINDING:
//--------------------------------------------------------
#if PERFSTAT
var t9 = Performance.now();
#endif
child.INTERNAL_UpdateBindingsSource();
#if PERFSTAT
Performance.Counter("VisualTreeManager: Handle binding", t9);
#endif
//--------------------------------------------------------
// HANDLE TABINDEX:
//--------------------------------------------------------
// For GotFocus and LostFocus to work, the DIV specified by "INTERNAL_OptionalSpecifyDomElementConcernedByFocus"
// (or the OuterDomElement otherwise) needs to have the "tabIndex" attribute set. Therefore we need to always set
// it (unless IsTabStop is False) to its current value (default is Int32.MaxValue). At the time when this code was
// written, there was no way to automatically call the "OnChanged" on a dependency property if no value was set.
#if !REWORKLOADED
// IMPORTANT: This needs to be done AFTER the "OnApplyTemplate" (for example, the TextBox sets the "INTERNAL_OptionalSpecifyDomElementConcernedByFocus" in the "OnApplyTemplate").
if (isChildAControl)
{
if (!(child is ContentPresenter) && !(child is TextBlock)) //ContentPresenter should not count in tabbing, as well as TextBlock (especially since TextBlock is not supposed to be a Control).
{
Control.TabIndexProperty_MethodToUpdateDom(child, ((Control)child).TabIndex);
}
}
#endif
//--------------------------------------------------------
// APPLY THE VISIBILITY:
//--------------------------------------------------------
Visibility childVisibility = child.Visibility;
if (childVisibility == Visibility.Collapsed)
{
UIElement.INTERNAL_ApplyVisibility(child, childVisibility);
}
//--------------------------------------------------------
// RAISE THE "SIZECHANGED" EVENT:
//--------------------------------------------------------
#if !REWORKLOADED
#if PERFSTAT
var t10 = Performance.now();
#endif
// Raise the "SizeChanged" event: (note: in XAML, the "SizeChanged" event is called before the "Loaded" event)
// IMPORTANT: This event needs to be raised AFTER the "OnApplyTemplate" and AFTER the "IsLoaded=true" (for example, it is used in the ScrollBar implementation).
if (child is FrameworkElement)
{
((FrameworkElement)child).INTERNAL_SizeChangedWhenAttachedToVisualTree();
}
#if PERFSTAT
Performance.Counter("VisualTreeManager: Raise size changed event", t10);
#endif
//--------------------------------------------------------
// RAISE THE "LOADED" EVENT:
//--------------------------------------------------------
#if PERFSTAT
var t11 = Performance.now();
#endif
// Raise the "Loaded" event: (note: in XAML, the "loaded" event of the children is called before the "loaded" event of the parent)
if (child is FrameworkElement)
{
((FrameworkElement)child).INTERNAL_RaiseLoadedEvent();
}
child.StartManagingPointerPositionForPointerExitedEventIfNeeded();
#if PERFSTAT
Performance.Counter("VisualTreeManager: Raise Loaded event", t11);
#endif
#else
INTERNAL_VisualTreeOperation.Current.Enqueue(child);
#endif
}
