public override void updateRenderObject(BuildContext context, RenderObject renderObject)
{
if (renderObject is _RenderAppBarTitleBox renderAppBarTitleBox)
{
renderAppBarTitleBox.textDirection = Directionality.of(context);
}
}
public LineSource(Curve SrcPath, String Code, int el_m, int SrcID, Phase_Regime ph)
: base(new double[8] {
60, 49, 41, 35, 31, 28, 26, 24
}, new Point3d(0, 0, 0), ph, SrcID)
{
string type = SrcPath.GetUserString("SourceType");
if (type == "Aircraft (ANCON derived)")
{
double velocity = double.Parse(SrcPath.GetUserString("Velocity"));
double delta = double.Parse(SrcPath.GetUserString("delta"));
D = new ANCON(delta, velocity);
}
else
{
D = new Simple();
}
samplespermeter = el_m;
Curve = SrcPath;
//Divide curve up in ~equal length segments.
Samples = Curve.DivideEquidistant(1.0 / (double)samplespermeter);
Level = Utilities.PachTools.DecodeSourcePower(Code);
Power = new double[8];
double PowerMod = Curve.GetLength() / (double)Samples.Length;
for (int oct = 0; oct < 8; oct++)
{
Power[oct] = 1E-12 * Math.Pow(10, .1 * Level[oct]) * PowerMod;
}
}
public override Widget build(BuildContext context)
{
D.assert(WidgetsD.debugCheckHasDirectionality(context));
List <Widget> children = new List <Widget>();
if (this.leading != null)
{
children.Add(new LayoutId(id: _ToolbarSlot.leading, child: this.leading));
}
if (this.middle != null)
{
children.Add(new LayoutId(id: _ToolbarSlot.middle, child: this.middle));
}
if (this.trailing != null)
{
children.Add(new LayoutId(id: _ToolbarSlot.trailing, child: this.trailing));
}
TextDirection textDirection = Directionality.of(context);
return(new CustomMultiChildLayout(
layoutDelegate: new _ToolbarLayout(
centerMiddle: this.centerMiddle,
middleSpacing: this.middleSpacing,
textDirection: textDirection
),
children: children
));
}
public LineSource(Curve SrcPath, String Code, int el_m, int SrcID, Phase_Regime ph)
:base(new double[8]{60, 49, 41, 35, 31, 28, 26, 24}, new Point3d(0,0,0), ph, SrcID)
{
string type = SrcPath.GetUserString("SourceType");
if (type == "Aircraft (ANCON derived)")
{
double velocity = double.Parse(SrcPath.GetUserString("Velocity"));
double delta = double.Parse(SrcPath.GetUserString("delta"));
D = new ANCON(delta, velocity);
}
else D = new Simple();
samplespermeter = el_m;
Curve = SrcPath;
//Divide curve up in ~equal length segments.
Samples = Curve.DivideEquidistant(1.0 / (double)samplespermeter);
Level = Utilities.PachTools.DecodeSourcePower(Code);
Power = new double[8];
double PowerMod = Curve.GetLength() / (double)Samples.Length;
for (int oct = 0; oct < 8; oct++) Power[oct] = 1E-12 * Math.Pow(10, .1 * Level[oct]) * PowerMod;
}
void _createNewEntry()
{
RenderBox box = context.findRenderObject() as RenderBox;
Offset target = box.localToGlobal(box.size.center(Offset.zero));
Widget overlay = new Directionality(
textDirection: Directionality.of(context),
child: new _TooltipOverlay(
message: widget.message,
height: height,
padding: padding,
margin: margin,
decoration: decoration,
textStyle: textStyle,
animation: new CurvedAnimation(
parent: _controller,
curve: Curves.fastOutSlowIn
),
target: target,
verticalOffset: verticalOffset,
preferBelow: preferBelow
)
);
_entry = new OverlayEntry(builder: (BuildContext context) => overlay);
Overlay.of(context, debugRequiredFor: widget).insert(_entry);
}
public override void updateRenderObject(BuildContext context, RenderObject renderObject)
{
if (renderObject is _RenderChildOverflowBox renderChildOverflowBox)
{
renderChildOverflowBox.textDirection = Directionality.of(context);
}
}
public override Widget build(BuildContext context)
{
Widget navigator = null;
if (this._navigator != null)
{
navigator = new Navigator(
key: this._navigator,
initialRoute: this.widget.initialRoute ?? Navigator.defaultRouteName,
onGenerateRoute: this._onGenerateRoute,
onUnknownRoute: this._onUnknownRoute,
observers: this.widget.navigatorObservers
);
}
Widget result;
if (this.widget.builder != null)
{
result = new Builder(
builder: _context => { return(this.widget.builder(_context, navigator)); }
);
}
else
{
D.assert(navigator != null);
result = navigator;
}
if (this.widget.textStyle != null)
{
result = new DefaultTextStyle(
style: this.widget.textStyle,
child: result
);
}
D.assert(() => {
if (WidgetInspectorService.instance.debugShowInspector)
{
result = new WidgetInspector(null, result, this._InspectorSelectButtonBuilder);
}
return(true);
});
result = new Directionality(child: result, TextDirection.ltr);
result = new WindowProvider(
window: this.widget.window,
child: result
);
result = new MediaQuery(
data: MediaQueryData.fromWindow(this.widget.window),
child: result
);
return(result);
}
void _handleTap()
{
RenderBox itemBox = (RenderBox)context.findRenderObject();
Rect itemRect = itemBox.localToGlobal(Offset.zero) & itemBox.size;
TextDirection textDirection = Directionality.of(context);
EdgeInsetsGeometry menuMargin = ButtonTheme.of(context).alignedDropdown
? material_._kAlignedMenuMargin
: material_._kUnalignedMenuMargin;
List <_MenuItem <T> > menuItems = new List <_MenuItem <T> >(new _MenuItem <T> [widget.items.Count]);
for (int index = 0; index < widget.items.Count; index += 1)
{
var pindex = index;
menuItems[pindex] = new _MenuItem <T>(
item: widget.items[pindex],
onLayout: (Size size) => {
if (_dropdownRoute == null)
{
return;
}
_dropdownRoute.itemHeights[pindex] = size.height;
}
);
}
D.assert(_dropdownRoute == null);
_dropdownRoute = new _DropdownRoute <T>(
items: menuItems,
buttonRect: menuMargin.resolve(textDirection).inflateRect(itemRect),
padding: material_._kMenuItemPadding.resolve(textDirection),
selectedIndex: _selectedIndex ?? 0,
elevation: widget.elevation,
theme: Theme.of(context, shadowThemeOnly: true),
style: _textStyle,
barrierLabel: MaterialLocalizations.of(context).modalBarrierDismissLabel,
itemHeight: widget.itemHeight,
dropdownColor: widget.dropdownColor
);
Navigator.push <T>(context, _dropdownRoute).then(newValue => {
_DropdownRouteResult <T> value = newValue as _DropdownRouteResult <T>;
_removeDropdownRoute();
if (!mounted || newValue == null)
{
return;
}
if (widget.onChanged != null)
{
widget.onChanged(value.result);
}
});
if (widget.onTap != null)
{
widget.onTap();
}
}
public override void updateRenderObject(BuildContext context, RenderObject renderObject)
{
renderObject = (_RenderSegmentedControl <T>)renderObject;
((_RenderSegmentedControl <T>)renderObject).textDirection = Directionality.of(context);
((_RenderSegmentedControl <T>)renderObject).selectedIndex = selectedIndex;
((_RenderSegmentedControl <T>)renderObject).pressedIndex = pressedIndex;
((_RenderSegmentedControl <T>)renderObject).backgroundColors = backgroundColors;
((_RenderSegmentedControl <T>)renderObject).borderColor = borderColor;
}
public void OnByComponentClicked(object sender, EventArgs e)
{
if (!ByComponentVectorCheckBox.Checked)
{
WholeVectorCheckBox.Checked = false;
ByComponentVectorCheckBox.Checked = true;
Directionality.ToByComponent();
}
}
public override void didChangeDependencies()
{
base.didChangeDependencies();
ThemeData theme = Theme.of(this.context);
this._themeColor = theme.highlightColor.withOpacity(1.0f);
this._textDirection = Directionality.of(this.context);
this._materialPainter = this._BuildMaterialScrollbarPainter();
}
public override RenderObject createRenderObject(BuildContext context)
{
return(new _RenderSegmentedControl <T>(
textDirection: Directionality.of(context),
selectedIndex: selectedIndex,
pressedIndex: pressedIndex,
backgroundColors: backgroundColors,
borderColor: borderColor
));
}
public override void updateRenderObject(BuildContext context, RenderObject renderObject)
{
var _renderObject = renderObject as _RenderCupertinoSwitch;
_renderObject.value = this.value;
_renderObject.activeColor = this.activeColor;
_renderObject.onChanged = this.onChanged;
_renderObject.textDirection = Directionality.of(context);
_renderObject.vsync = this.vsync;
_renderObject.dragStartBehavior = this.dragStartBehavior;
}
public override RenderObject createRenderObject(BuildContext context)
{
return(new _RenderCupertinoSwitch(
value: this.value,
activeColor: this.activeColor,
onChanged: this.onChanged,
textDirection: Directionality.of(context),
vsync: this.vsync,
dragStartBehavior: this.dragStartBehavior
));
}
public override void updateRenderObject(BuildContext context, RenderObject renderObject)
{
RenderAnimatedSize _renderObject = (RenderAnimatedSize)renderObject;
_renderObject.alignment = alignment;
_renderObject.duration = duration;
_renderObject.reverseDuration = reverseDuration;
_renderObject.curve = curve;
_renderObject.vsync = vsync;
_renderObject.textDirection = Directionality.of(context);
}
public override RenderObject createRenderObject(BuildContext context)
{
return(new RenderAnimatedSize(
alignment: alignment,
duration: duration,
reverseDuration: reverseDuration,
curve: curve,
vsync: vsync,
textDirection: Directionality.of(context)
));
}
public override RenderObject createRenderObject(BuildContext context)
{
return(new _SelectToggleButtonRenderObject(
leadingBorderSide,
horizontalBorderSide,
trailingBorderSide,
borderRadius,
isFirstButton,
isLastButton,
Directionality.of(context)
));
}
public override void updateRenderObject(BuildContext context, RenderObject renderObject)
{
var _renderObject = (_SelectToggleButtonRenderObject)renderObject;
_renderObject.leadingBorderSide = leadingBorderSide;
_renderObject.horizontalBorderSide = horizontalBorderSide;
_renderObject.trailingBorderSide = trailingBorderSide;
_renderObject.borderRadius = borderRadius;
_renderObject.isFirstButton = isFirstButton;
_renderObject.isLastButton = isLastButton;
_renderObject.textDirection = Directionality.of(context);
}
float?_convertToLogical(float?value)
{
switch (Directionality.of(context))
{
case TextDirection.rtl:
return(-value);
case TextDirection.ltr:
return(value);
}
return(value);
}
public override void updateRenderObject(BuildContext context, RenderObject _renderObject)
{
_RenderCupertinoSlider renderObject = _renderObject as _RenderCupertinoSlider;
renderObject.value = value ?? 0.0f;
renderObject.divisions = divisions;
renderObject.activeColor = activeColor;
renderObject.thumbColor = CupertinoDynamicColor.resolve(thumbColor, context);
renderObject.trackColor = CupertinoDynamicColor.resolve(CupertinoColors.systemFill, context);
renderObject.onChanged = onChanged;
renderObject.onChangeStart = onChangeStart;
renderObject.onChangeEnd = onChangeEnd;
renderObject.textDirection = Directionality.of(context);
}
public override void didChangeDependencies()
{
base.didChangeDependencies();
_localizations = MaterialLocalizations.of(context);
_textDirection = Directionality.of(context);
if (!_announcedInitialDate)
{
_announcedInitialDate = true;
// SemanticsService.announce(
// _localizations.formatFullDate(_selectedDate),
// _textDirection,
// );
}
}
public override Widget build(BuildContext context)
{
D.assert(WidgetsD.debugCheckHasDirectionality(context));
return(Positioned.directional(
textDirection: Directionality.of(context: context),
child: widget.child,
start: _start?.evaluate(animation: animation),
top: _top?.evaluate(animation: animation),
end: _end?.evaluate(animation: animation),
bottom: _bottom?.evaluate(animation: animation),
width: _width?.evaluate(animation: animation),
height: _height?.evaluate(animation: animation)
));
}
public Task UnassociateAsync(INode targetNode, QName associationTypeQName, Directionality directionality)
{
string uri = URI + "/unassociate";
IDictionary <string, string> queryParams = new Dictionary <string, string>();
queryParams.Add("node", targetNode.Id);
queryParams.Add("type", associationTypeQName.ToString());
if (!directionality.Equals(Directionality.DIRECTED))
{
queryParams.Add("directionality", directionality.ToString());
}
return(Driver.PostAsync(uri, queryParams));
}
public override Widget build(BuildContext context)
{
D.assert((textDirection != null && layoutDirection != null) || WidgetsD.debugCheckHasDirectionality(context));
return(new CustomPaint(
foregroundPainter: new BannerPainter(
message: message,
textDirection: textDirection ?? Directionality.of(context),
location: location,
layoutDirection: layoutDirection ?? Directionality.of(context),
color: color,
textStyle: textStyle
),
child: child
));
}
public override RenderObject createRenderObject(BuildContext context)
{
return(new _RenderCupertinoSlider(
value: value ?? 0.0f,
divisions: divisions,
activeColor: activeColor,
thumbColor: CupertinoDynamicColor.resolve(thumbColor, context),
trackColor: CupertinoDynamicColor.resolve(CupertinoColors.systemFill, context),
onChanged: onChanged,
onChangeStart: onChangeStart,
onChangeEnd: onChangeEnd,
vsync: vsync,
textDirection: Directionality.of(context)
));
}
public ScrollbarPainter _buildCupertinoScrollbarPainter(BuildContext context)
{
return(new ScrollbarPainter(
color: CupertinoDynamicColor.resolve(CupertinoScrollbarUtils._kScrollbarColor, context),
textDirection: Directionality.of(context),
thickness: _thickness,
fadeoutOpacityAnimation: _fadeoutOpacityAnimation,
mainAxisMargin: CupertinoScrollbarUtils._kScrollbarMainAxisMargin,
crossAxisMargin: CupertinoScrollbarUtils._kScrollbarCrossAxisMargin,
radius: _radius,
padding: MediaQuery.of(context).padding,
minLength: CupertinoScrollbarUtils._kScrollbarMinLength,
minOverscrollLength: CupertinoScrollbarUtils._kScrollbarMinOverscrollLength
));
}
public override Widget build(BuildContext context)
{
D.assert(WidgetsD.debugCheckHasDirectionality(context));
TextDirection textDirection = Directionality.of(context);
return(new SlideTransition(
position: _secondaryPositionAnimation,
textDirection: textDirection,
transformHitTests: false,
child: new SlideTransition(
position: _positionAnimation,
child: child
)
));
}
public override Widget buildPage(BuildContext context, Animation <float> animation,
Animation <float> secondaryAnimation)
{
int?selectedItemIndex = null;
if (initialValue != null)
{
for (int index = 0; selectedItemIndex == null && index < items.Count; index += 1)
{
if (items[index].represents(initialValue))
{
selectedItemIndex = index;
}
}
}
Widget menu = new _PopupMenu <T>(route: this);
if (captureInheritedThemes ?? false)
{
menu = InheritedTheme.captureAll(showMenuContext, menu);
}
else
{
if (theme != null)
{
menu = new Theme(data: theme, child: menu);
}
}
return(MediaQuery.removePadding(
context: context,
removeTop: true,
removeBottom: true,
removeLeft: true,
removeRight: true,
child: new Builder(
builder: _ => new CustomSingleChildLayout(
layoutDelegate: new _PopupMenuRouteLayout(
position,
itemSizes,
selectedItemIndex ?? 0,
Directionality.of(context)
),
child: menu
))
));
}
void _settle(DragEndDetails details)
{
if (_controller.isDismissed)
{
return;
}
if (details.velocity.pixelsPerSecond.dx.abs() >= DrawerUtils._kMinFlingVelocity)
{
float visualVelocity = details.velocity.pixelsPerSecond.dx / DrawerUtils._kWidth;
switch (widget.alignment)
{
case DrawerAlignment.start:
break;
case DrawerAlignment.end:
visualVelocity = -visualVelocity;
break;
}
switch (Directionality.of(context))
{
case TextDirection.rtl:
_controller.fling(velocity: -visualVelocity);
if (widget.drawerCallback != null)
{
widget.drawerCallback(visualVelocity < 0.0f);
}
break;
case TextDirection.ltr:
_controller.fling(velocity: visualVelocity);
if (widget.drawerCallback != null)
{
widget.drawerCallback(visualVelocity > 0.0f);
}
break;
}
}
else if (_controller.value < 0.5f)
{
close();
}
else
{
open();
}
}
AxisDirection?_getDirection(BuildContext context)
{
switch (widget.scrollDirection)
{
case Axis.horizontal:
D.assert(WidgetsD.debugCheckHasDirectionality(context));
TextDirection textDirection = Directionality.of(context);
AxisDirection?axisDirection = AxisUtils.textDirectionToAxisDirection(textDirection);
return(widget.reverse ? AxisUtils.flipAxisDirection(axisDirection) : axisDirection);
case Axis.vertical:
return(widget.reverse ? AxisDirection.up : AxisDirection.down);
}
throw new UIWidgetsError("fail to get axis direction");
}
public override void updateRenderObject(BuildContext context, RenderObject renderObject)
{
_RenderSlider _renderObject = (_RenderSlider)renderObject;
_renderObject.value = value;
_renderObject.divisions = divisions;
_renderObject.label = label;
_renderObject.sliderTheme = sliderTheme;
_renderObject.theme = Theme.of(context);
_renderObject.mediaQueryData = mediaQueryData;
_renderObject.onChanged = onChanged;
_renderObject.onChangeStart = onChangeStart;
_renderObject.onChangeEnd = onChangeEnd;
_renderObject.textDirection = Directionality.of(context);
_renderObject.platform = Theme.of(context).platform;
}
