OLD | NEW |
(Empty) | |
| 1 |
| 2 import 'package:vector_math/vector_math.dart'; |
| 3 |
| 4 import '../rendering/block.dart'; |
| 5 import '../rendering/box.dart'; |
| 6 import '../rendering/flex.dart'; |
| 7 import '../rendering/object.dart'; |
| 8 import '../rendering/paragraph.dart'; |
| 9 import '../rendering/stack.dart'; |
| 10 import 'ui_node.dart'; |
| 11 |
| 12 export '../rendering/box.dart' show BoxConstraints, BoxDecoration, Border, Borde
rSide, EdgeDims; |
| 13 export '../rendering/flex.dart' show FlexDirection; |
| 14 export '../rendering/object.dart' show Point, Size, Rect, Color, Paint, Path; |
| 15 export 'ui_node.dart' show UINode, Component, App, EventListenerNode, ParentData
Node; |
| 16 |
| 17 |
| 18 // PAINTING NODES |
| 19 |
| 20 class Opacity extends OneChildRenderObjectWrapper { |
| 21 Opacity({ this.opacity, UINode child, Object key }) |
| 22 : super(child: child, key: key); |
| 23 |
| 24 RenderOpacity get root { RenderOpacity result = super.root; return result; } |
| 25 final double opacity; |
| 26 |
| 27 RenderOpacity createNode() => new RenderOpacity(opacity: opacity); |
| 28 |
| 29 void syncRenderObject(Opacity old) { |
| 30 super.syncRenderObject(old); |
| 31 root.opacity = opacity; |
| 32 } |
| 33 } |
| 34 |
| 35 class DecoratedBox extends OneChildRenderObjectWrapper { |
| 36 |
| 37 DecoratedBox({ this.decoration, UINode child, Object key }) |
| 38 : super(child: child, key: key); |
| 39 |
| 40 RenderDecoratedBox get root { RenderDecoratedBox result = super.root; return r
esult; } |
| 41 final BoxDecoration decoration; |
| 42 |
| 43 RenderDecoratedBox createNode() => new RenderDecoratedBox(decoration: decorati
on); |
| 44 |
| 45 void syncRenderObject(DecoratedBox old) { |
| 46 super.syncRenderObject(old); |
| 47 root.decoration = decoration; |
| 48 } |
| 49 |
| 50 } |
| 51 |
| 52 // TODO(jackson) need a mechanism for marking the RenderCustomPaint as needing p
aint |
| 53 class CustomPaint extends OneChildRenderObjectWrapper { |
| 54 |
| 55 CustomPaint({ this.callback, UINode child, Object key }) |
| 56 : super(child: child, key: key); |
| 57 |
| 58 RenderCustomPaint get root { RenderCustomPaint result = super.root; return res
ult; } |
| 59 final CustomPaintCallback callback; |
| 60 |
| 61 RenderCustomPaint createNode() => new RenderCustomPaint(callback: callback); |
| 62 |
| 63 void syncRenderObject(CustomPaint old) { |
| 64 super.syncRenderObject(old); |
| 65 root.callback = callback; |
| 66 } |
| 67 |
| 68 void remove() { |
| 69 root.callback = null; |
| 70 super.remove(); |
| 71 } |
| 72 |
| 73 } |
| 74 |
| 75 class ClipRect extends OneChildRenderObjectWrapper { |
| 76 |
| 77 ClipRect({ UINode child, Object key }) |
| 78 : super(child: child, key: key); |
| 79 |
| 80 RenderClipRect get root { RenderClipRect result = super.root; return result; } |
| 81 RenderClipRect createNode() => new RenderClipRect(); |
| 82 } |
| 83 |
| 84 class ClipOval extends OneChildRenderObjectWrapper { |
| 85 |
| 86 ClipOval({ UINode child, Object key }) |
| 87 : super(child: child, key: key); |
| 88 |
| 89 RenderClipOval get root { RenderClipOval result = super.root; return result; } |
| 90 RenderClipOval createNode() => new RenderClipOval(); |
| 91 } |
| 92 |
| 93 |
| 94 // POSITIONING AND SIZING NODES |
| 95 |
| 96 class Transform extends OneChildRenderObjectWrapper { |
| 97 |
| 98 Transform({ this.transform, UINode child, Object key }) |
| 99 : super(child: child, key: key); |
| 100 |
| 101 RenderTransform get root { RenderTransform result = super.root; return result;
} |
| 102 final Matrix4 transform; |
| 103 |
| 104 RenderTransform createNode() => new RenderTransform(transform: transform); |
| 105 |
| 106 void syncRenderObject(Transform old) { |
| 107 super.syncRenderObject(old); |
| 108 root.transform = transform; |
| 109 } |
| 110 |
| 111 } |
| 112 |
| 113 class Padding extends OneChildRenderObjectWrapper { |
| 114 |
| 115 Padding({ this.padding, UINode child, Object key }) |
| 116 : super(child: child, key: key); |
| 117 |
| 118 RenderPadding get root { RenderPadding result = super.root; return result; } |
| 119 final EdgeDims padding; |
| 120 |
| 121 RenderPadding createNode() => new RenderPadding(padding: padding); |
| 122 |
| 123 void syncRenderObject(Padding old) { |
| 124 super.syncRenderObject(old); |
| 125 root.padding = padding; |
| 126 } |
| 127 |
| 128 } |
| 129 |
| 130 class SizedBox extends OneChildRenderObjectWrapper { |
| 131 |
| 132 SizedBox({ |
| 133 double width: double.INFINITY, |
| 134 double height: double.INFINITY, |
| 135 UINode child, |
| 136 Object key |
| 137 }) : desiredSize = new Size(width, height), super(child: child, key: key); |
| 138 |
| 139 RenderSizedBox get root { RenderSizedBox result = super.root; return result; } |
| 140 final Size desiredSize; |
| 141 |
| 142 RenderSizedBox createNode() => new RenderSizedBox(desiredSize: desiredSize); |
| 143 |
| 144 void syncRenderObject(SizedBox old) { |
| 145 super.syncRenderObject(old); |
| 146 root.desiredSize = desiredSize; |
| 147 } |
| 148 |
| 149 } |
| 150 |
| 151 class ConstrainedBox extends OneChildRenderObjectWrapper { |
| 152 |
| 153 ConstrainedBox({ this.constraints, UINode child, Object key }) |
| 154 : super(child: child, key: key); |
| 155 |
| 156 RenderConstrainedBox get root { RenderConstrainedBox result = super.root; retu
rn result; } |
| 157 final BoxConstraints constraints; |
| 158 |
| 159 RenderConstrainedBox createNode() => new RenderConstrainedBox(additionalConstr
aints: constraints); |
| 160 |
| 161 void syncRenderObject(ConstrainedBox old) { |
| 162 super.syncRenderObject(old); |
| 163 root.additionalConstraints = constraints; |
| 164 } |
| 165 |
| 166 } |
| 167 |
| 168 class ShrinkWrapWidth extends OneChildRenderObjectWrapper { |
| 169 |
| 170 ShrinkWrapWidth({ UINode child, Object key }) : super(child: child, key: key); |
| 171 |
| 172 RenderShrinkWrapWidth get root { RenderShrinkWrapWidth result = super.root; re
turn result; } |
| 173 |
| 174 RenderShrinkWrapWidth createNode() => new RenderShrinkWrapWidth(); |
| 175 |
| 176 } |
| 177 |
| 178 class SizeObserver extends OneChildRenderObjectWrapper { |
| 179 |
| 180 SizeObserver({ this.callback, UINode child, Object key }) |
| 181 : super(child: child, key: key); |
| 182 |
| 183 RenderSizeObserver get root { RenderSizeObserver result = super.root; return r
esult; } |
| 184 final SizeChangedCallback callback; |
| 185 |
| 186 RenderSizeObserver createNode() => new RenderSizeObserver(callback: callback); |
| 187 |
| 188 void syncRenderObject(SizeObserver old) { |
| 189 super.syncRenderObject(old); |
| 190 root.callback = callback; |
| 191 } |
| 192 |
| 193 void remove() { |
| 194 root.callback = null; |
| 195 super.remove(); |
| 196 } |
| 197 |
| 198 } |
| 199 |
| 200 |
| 201 // CONVENIENCE CLASS TO COMBINE COMMON PAINTING, POSITIONING, AND SIZING NODES |
| 202 |
| 203 class Container extends Component { |
| 204 |
| 205 Container({ |
| 206 Object key, |
| 207 this.child, |
| 208 this.constraints, |
| 209 this.decoration, |
| 210 this.width, |
| 211 this.height, |
| 212 this.margin, |
| 213 this.padding, |
| 214 this.transform |
| 215 }) : super(key: key); |
| 216 |
| 217 final UINode child; |
| 218 final BoxConstraints constraints; |
| 219 final BoxDecoration decoration; |
| 220 final EdgeDims margin; |
| 221 final EdgeDims padding; |
| 222 final Matrix4 transform; |
| 223 final double width; |
| 224 final double height; |
| 225 |
| 226 UINode build() { |
| 227 UINode current = child; |
| 228 |
| 229 if (child == null && width == null && height == null) |
| 230 current = new SizedBox(); |
| 231 |
| 232 if (padding != null) |
| 233 current = new Padding(padding: padding, child: current); |
| 234 |
| 235 if (decoration != null) |
| 236 current = new DecoratedBox(decoration: decoration, child: current); |
| 237 |
| 238 if (width != null || height != null) |
| 239 current = new SizedBox( |
| 240 width: width == null ? double.INFINITY : width, |
| 241 height: height == null ? double.INFINITY : height, |
| 242 child: current |
| 243 ); |
| 244 |
| 245 if (constraints != null) |
| 246 current = new ConstrainedBox(constraints: constraints, child: current); |
| 247 |
| 248 if (margin != null) |
| 249 current = new Padding(padding: margin, child: current); |
| 250 |
| 251 if (transform != null) |
| 252 current = new Transform(transform: transform, child: current); |
| 253 |
| 254 return current; |
| 255 } |
| 256 |
| 257 } |
| 258 |
| 259 |
| 260 // LAYOUT NODES |
| 261 |
| 262 class Block extends MultiChildRenderObjectWrapper { |
| 263 |
| 264 Block(List<UINode> children, { Object key }) |
| 265 : super(key: key, children: children); |
| 266 |
| 267 RenderBlock get root { RenderBlock result = super.root; return result; } |
| 268 RenderBlock createNode() => new RenderBlock(); |
| 269 |
| 270 } |
| 271 |
| 272 class Stack extends MultiChildRenderObjectWrapper { |
| 273 |
| 274 Stack(List<UINode> children, { Object key }) |
| 275 : super(key: key, children: children); |
| 276 |
| 277 RenderStack get root { RenderStack result = super.root; return result; } |
| 278 RenderStack createNode() => new RenderStack(); |
| 279 |
| 280 } |
| 281 |
| 282 class StackPositionedChild extends ParentDataNode { |
| 283 StackPositionedChild(UINode content, { |
| 284 double top, double right, double bottom, double left |
| 285 }) : super(content, new StackParentData()..top = top |
| 286 ..right = right |
| 287 ..bottom = bottom |
| 288 ..left = left); |
| 289 } |
| 290 |
| 291 class Flex extends MultiChildRenderObjectWrapper { |
| 292 |
| 293 Flex(List<UINode> children, { |
| 294 Object key, |
| 295 this.direction: FlexDirection.horizontal, |
| 296 this.justifyContent: FlexJustifyContent.flexStart, |
| 297 this.alignItems: FlexAlignItems.center |
| 298 }) : super(key: key, children: children); |
| 299 |
| 300 RenderFlex get root { RenderFlex result = super.root; return result; } |
| 301 RenderFlex createNode() => new RenderFlex(direction: this.direction); |
| 302 |
| 303 final FlexDirection direction; |
| 304 final FlexJustifyContent justifyContent; |
| 305 final FlexAlignItems alignItems; |
| 306 |
| 307 void syncRenderObject(UINode old) { |
| 308 super.syncRenderObject(old); |
| 309 root.direction = direction; |
| 310 root.justifyContent = justifyContent; |
| 311 root.alignItems = alignItems; |
| 312 } |
| 313 |
| 314 } |
| 315 |
| 316 class FlexExpandingChild extends ParentDataNode { |
| 317 FlexExpandingChild(UINode content, { int flex: 1, Object key }) |
| 318 : super(content, new FlexBoxParentData()..flex = flex, key: key); |
| 319 } |
| 320 |
| 321 class Paragraph extends RenderObjectWrapper { |
| 322 |
| 323 Paragraph({ Object key, this.text }) : super(key: key); |
| 324 |
| 325 RenderParagraph get root { RenderParagraph result = super.root; return result;
} |
| 326 RenderParagraph createNode() => new RenderParagraph(text: text); |
| 327 |
| 328 final String text; |
| 329 |
| 330 void syncRenderObject(UINode old) { |
| 331 super.syncRenderObject(old); |
| 332 root.text = text; |
| 333 } |
| 334 |
| 335 void insert(RenderObjectWrapper child, dynamic slot) { |
| 336 assert(false); |
| 337 // Paragraph does not support having children currently |
| 338 } |
| 339 |
| 340 } |
| 341 |
| 342 class Text extends Component { |
| 343 Text(this.data) : super(key: '*text*'); |
| 344 final String data; |
| 345 bool get interchangeable => true; |
| 346 UINode build() => new Paragraph(text: data); |
| 347 } |
| 348 |
| 349 class Image extends RenderObjectWrapper { |
| 350 |
| 351 Image({ |
| 352 Object key, |
| 353 this.src, |
| 354 this.size |
| 355 }) : super(key: key); |
| 356 |
| 357 RenderImage get root { RenderImage result = super.root; return result; } |
| 358 RenderImage createNode() => new RenderImage(this.src, this.size); |
| 359 |
| 360 final String src; |
| 361 final Size size; |
| 362 |
| 363 void syncRenderObject(UINode old) { |
| 364 super.syncRenderObject(old); |
| 365 root.src = src; |
| 366 root.requestedSize = size; |
| 367 } |
| 368 |
| 369 void insert(RenderObjectWrapper child, dynamic slot) { |
| 370 assert(false); |
| 371 // Image does not support having children currently |
| 372 } |
| 373 |
| 374 } |
OLD | NEW |