Add a Flutter like widget system

+# 1.3.0
+* Add a Flutter like widget system
+
 # 1.2.0
 # 1.2.0
 * Change license to Apache 2.0
 * Change license to Apache 2.0
 * Improve PdfRect
 * Improve PdfRect

 # Pdf creation library for dart / flutter
 # Pdf creation library for dart / flutter
 
 
-This is a low-level Pdf creation library.
+This library is divided in two parts:
+
+* a low-level Pdf creation library that takes care of the pdf bits generation.
+* a Widgets system similar to Flutter's, for easy high-level Pdf creation.
+
 It can create a full multi-pages document with graphics,
 It can create a full multi-pages document with graphics,
-images and text using TrueType fonts.
+images and text using TrueType fonts. With the ease of use you already know.
 
 
 > Use `printing` package <https://pub.dartlang.org/packages/printing>
 > Use `printing` package <https://pub.dartlang.org/packages/printing>
 > for full flutter print and share operation.
 > for full flutter print and share operation.
 
 
-The coordinate system is using the internal Pdf system:
- * (0.0, 0.0) is bottom-left
+The coordinate system is using the internal Pdf unit:
  * 1.0 is defined as 1 / 72.0 inch
  * 1.0 is defined as 1 / 72.0 inch
  * you can use the constants for centimeters, milimeters and inch defined in PdfPageFormat
  * you can use the constants for centimeters, milimeters and inch defined in PdfPageFormat
 
 
 Example:
 Example:
 ```dart
 ```dart
-final pdf = PdfDocument();
-final page = PdfPage(pdf, pageFormat: PdfPageFormat.letter);
-final g = page.getGraphics();
-final font = PdfFont(pdf);
-
-g.setColor(PdfColor(0.0, 1.0, 1.0));
-g.drawRect(50.0, 30.0, 100.0, 50.0);
-g.fillPath();
-
-g.setColor(PdfColor(0.3, 0.3, 0.3));
-g.drawString(font, 12.0, "Hello World!", 5.0 * PdfPageFormat.mm, 300.0);
-
-var file = File('file.pdf');
-file.writeAsBytesSync(pdf.save());
+final pdf = Document()
+  ..addPage(Page(
+      pageFormat: PdfPageFormat.a4,
+      build: (Context context) {
+        return Center(
+          child: Text("Hello World"),
+        ); // Center
+      })); // Page
 ```
 ```
 
 
 To load an image it is possible to use the dart library [image](https://pub.dartlang.org/packages/image):
 To load an image it is possible to use the dart library [image](https://pub.dartlang.org/packages/image):

 import 'dart:io';
 import 'dart:io';
 
 
 import 'package:pdf/pdf.dart';
 import 'package:pdf/pdf.dart';
+import 'package:pdf/widgets.dart';
 
 
 void main() {
 void main() {
-  final pdf = PdfDocument(deflate: zlib.encode);
-  final page = PdfPage(pdf, pageFormat: PdfPageFormat.letter);
-  final g = page.getGraphics();
-  final font = g.defaultFont;
-  final top = page.pageFormat.height;
+  final pdf = Document(deflate: zlib.encode);
 
 
-  g.setColor(PdfColor(0.0, 1.0, 1.0));
-  g.drawRect(50.0 * PdfPageFormat.mm, top - 80.0 * PdfPageFormat.mm,
-      100.0 * PdfPageFormat.mm, 50.0 * PdfPageFormat.mm);
-  g.fillPath();
-
-  g.setColor(PdfColor(0.3, 0.3, 0.3));
-  g.drawString(font, 12.0, "Hello World!", 10.0 * PdfPageFormat.mm,
-      top - 10.0 * PdfPageFormat.mm);
+  pdf.addPage(MultiPage(
+      pageFormat:
+          PdfPageFormat.letter.copyWith(marginBottom: 1.5 * PdfPageFormat.cm),
+      crossAxisAlignment: CrossAxisAlignment.start,
+      header: (Context context) {
+        if (context.pageNumber == 1) return null;
+        return Container(
+            alignment: Alignment.centerRight,
+            margin: EdgeInsets.only(bottom: 3.0 * PdfPageFormat.mm),
+            padding: EdgeInsets.only(bottom: 3.0 * PdfPageFormat.mm),
+            decoration: BoxDecoration(
+                border:
+                    BoxBorder(bottom: true, width: 0.5, color: PdfColor.grey)),
+            child: Text("Portable Document Format",
+                style: Theme.of(context)
+                    .defaultTextStyle
+                    .copyWith(color: PdfColor.grey)));
+      },
+      footer: (Context context) {
+        return Container(
+            alignment: Alignment.centerRight,
+            margin: EdgeInsets.only(top: 1.0 * PdfPageFormat.cm),
+            child: Text("Page ${context.pageNumber}",
+                style: Theme.of(context)
+                    .defaultTextStyle
+                    .copyWith(color: PdfColor.grey)));
+      },
+      build: (Context context) => <Widget>[
+            Header(
+                level: 0,
+                child: Row(
+                    mainAxisAlignment: MainAxisAlignment.spaceBetween,
+                    children: <Widget>[
+                      Text("Portable Document Format", textScaleFactor: 2.0),
+                      PdfLogo()
+                    ])),
+            Paragraph(
+                text:
+                    "The Portable Document Format (PDF) is a file format developed by Adobe in the 1990s to present documents, including text formatting and images, in a manner independent of application software, hardware, and operating systems. Based on the PostScript language, each PDF file encapsulates a complete description of a fixed-layout flat document, including the text, fonts, vector graphics, raster images and other information needed to display it. PDF was standardized as an open format, ISO 32000, in 2008, and no longer requires any royalties for its implementation."),
+            Paragraph(
+                text:
+                    "Today, PDF files may contain a variety of content besides flat text and graphics including logical structuring elements, interactive elements such as annotations and form-fields, layers, rich media (including video content) and three dimensional objects using U3D or PRC, and various other data formats.[citation needed] The PDF specification also provides for encryption and digital signatures, file attachments and metadata to enable workflows requiring these features."),
+            Header(level: 1, text: "History and standardization"),
+            Paragraph(
+                text:
+                    "Adobe Systems made the PDF specification available free of charge in 1993. In the early years PDF was popular mainly in desktop publishing workflows, and competed with a variety of formats such as DjVu, Envoy, Common Ground Digital Paper, Farallon Replica and even Adobe's own PostScript format."),
+            Paragraph(
+                text:
+                    "PDF was a proprietary format controlled by Adobe until it was released as an open standard on July 1, 2008, and published by the International Organization for Standardization as ISO 32000-1:2008, at which time control of the specification passed to an ISO Committee of volunteer industry experts. In 2008, Adobe published a Public Patent License to ISO 32000-1 granting royalty-free rights for all patents owned by Adobe that are necessary to make, use, sell, and distribute PDF compliant implementations."),
+            Paragraph(
+                text:
+                    "PDF 1.7, the sixth edition of the PDF specification that became ISO 32000-1, includes some proprietary technologies defined only by Adobe, such as Adobe XML Forms Architecture (XFA) and JavaScript extension for Acrobat, which are referenced by ISO 32000-1 as normative and indispensable for the full implementation of the ISO 32000-1 specification. These proprietary technologies are not standardized and their specification is published only on Adobe's website. Many of them are also not supported by popular third-party implementations of PDF."),
+            Paragraph(
+                text:
+                    "On July 28, 2017, ISO 32000-2:2017 (PDF 2.0) was published. ISO 32000-2 does not include any proprietary technologies as normative references."),
+            Header(level: 1, text: "Technical foundations"),
+            Paragraph(text: "The PDF combines three technologies:"),
+            Bullet(
+                text:
+                    "A subset of the PostScript page description programming language, for generating the layout and graphics."),
+            Bullet(
+                text:
+                    "A font-embedding/replacement system to allow fonts to travel with the documents."),
+            Bullet(
+                text:
+                    "A structured storage system to bundle these elements and any associated content into a single file, with data compression where appropriate."),
+            Header(level: 2, text: "PostScript"),
+            Paragraph(
+                text:
+                    "PostScript is a page description language run in an interpreter to generate an image, a process requiring many resources. It can handle graphics and standard features of programming languages such as if and loop commands. PDF is largely based on PostScript but simplified to remove flow control features like these, while graphics commands such as lineto remain."),
+            Paragraph(
+                text:
+                    "Often, the PostScript-like PDF code is generated from a source PostScript file. The graphics commands that are output by the PostScript code are collected and tokenized. Any files, graphics, or fonts to which the document refers also are collected. Then, everything is compressed to a single file. Therefore, the entire PostScript world (fonts, layout, measurements) remains intact."),
+            Column(
+                crossAxisAlignment: CrossAxisAlignment.start,
+                children: <Widget>[
+                  Paragraph(
+                      text:
+                          "As a document format, PDF has several advantages over PostScript:"),
+                  Bullet(
+                      text:
+                          "PDF contains tokenized and interpreted results of the PostScript source code, for direct correspondence between changes to items in the PDF page description and changes to the resulting page appearance."),
+                  Bullet(
+                      text:
+                          "PDF (from version 1.4) supports graphic transparency; PostScript does not."),
+                  Bullet(
+                      text:
+                          "PostScript is an interpreted programming language with an implicit global state, so instructions accompanying the description of one page can affect the appearance of any following page. Therefore, all preceding pages in a PostScript document must be processed to determine the correct appearance of a given page, whereas each page in a PDF document is unaffected by the others. As a result, PDF viewers allow the user to quickly jump to the final pages of a long document, whereas a PostScript viewer needs to process all pages sequentially before being able to display the destination page (unless the optional PostScript Document Structuring Conventions have been carefully complied with)."),
+                ]),
+            Header(level: 1, text: "Content"),
+            Paragraph(
+                text:
+                    "A PDF file is often a combination of vector graphics, text, and bitmap graphics. The basic types of content in a PDF are:"),
+            Bullet(
+                text:
+                    "Text stored as content streams (i.e., not encoded in plain text)"),
+            Bullet(
+                text:
+                    "Vector graphics for illustrations and designs that consist of shapes and lines"),
+            Bullet(
+                text:
+                    "Raster graphics for photographs and other types of image"),
+            Bullet(text: "Multimedia objects in the document"),
+            Paragraph(
+                text:
+                    "In later PDF revisions, a PDF document can also support links (inside document or web page), forms, JavaScript (initially available as plugin for Acrobat 3.0), or any other types of embedded contents that can be handled using plug-ins."),
+            Paragraph(
+                text:
+                    "PDF 1.6 supports interactive 3D documents embedded in the PDF - 3D drawings can be embedded using U3D or PRC and various other data formats."),
+            Paragraph(
+                text:
+                    "Two PDF files that look similar on a computer screen may be of very different sizes. For example, a high resolution raster image takes more space than a low resolution one. Typically higher resolution is needed for printing documents than for displaying them on screen. Other things that may increase the size of a file is embedding full fonts, especially for Asiatic scripts, and storing text as graphics. "),
+            Header(level: 1, text: "File formats and Adobe Acrobat versions"),
+            Paragraph(
+                text:
+                    "The PDF file format has changed several times, and continues to evolve, along with the release of new versions of Adobe Acrobat. There have been nine versions of PDF and the corresponding version of the software:"),
+            Table.fromTextArray(context: context, data: [
+              ["Date", "PDF Version", "Acrobat Version"],
+              ["1993", "PDF 1.0", "Acrobat 1"],
+              ["1994", "PDF 1.1", "Acrobat 2"],
+              ["1996", "PDF 1.2", "Acrobat 3"],
+              ["1999", "PDF 1.3", "Acrobat 4"],
+              ["2001", "PDF 1.4", "Acrobat 5"],
+              ["2003", "PDF 1.5", "Acrobat 6"],
+              ["2005", "PDF 1.6", "Acrobat 7"],
+              ["2006", "PDF 1.7", "Acrobat 8"],
+              ["2008", "PDF 1.7", "Acrobat 9"],
+              ["2009", "PDF 1.7", "Acrobat 9.1"],
+              ["2010", "PDF 1.7", "Acrobat X"],
+              ["2012", "PDF 1.7", "Acrobat XI"],
+              ["2017", "PDF 2.0", "Acrobat DC"],
+            ]),
+            Padding(padding: EdgeInsets.all(10)),
+            Paragraph(
+                text:
+                    "Text is available under the Creative Commons Attribution Share Alike License.")
+          ]));
 
 
   var file = File('example.pdf');
   var file = File('example.pdf');
-  file.writeAsBytesSync(pdf.save());
+  file.writeAsBytesSync(pdf.document.save());
 }
 }

+/*
+ * Copyright (C) 2017, David PHAM-VAN <dev.nfet.net@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+library widget;
+
+import 'dart:math' as math;
+
+import 'package:meta/meta.dart';
+import 'package:pdf/pdf.dart';
+import 'package:vector_math/vector_math_64.dart';
+
+part 'widgets/basic.dart';
+part 'widgets/clip.dart';
+part 'widgets/container.dart';
+part 'widgets/content.dart';
+part 'widgets/document.dart';
+part 'widgets/flex.dart';
+part 'widgets/geometry.dart';
+part 'widgets/grid_view.dart';
+part 'widgets/image.dart';
+part 'widgets/placeholders.dart';
+part 'widgets/table.dart';
+part 'widgets/text.dart';
+part 'widgets/theme.dart';
+part 'widgets/widget.dart';

+/*
+ * Copyright (C) 2017, David PHAM-VAN <dev.nfet.net@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+part of widget;
+
+enum BoxFit { fill, contain, cover, fitWidth, fitHeight, none, scaleDown }
+
+class LimitedBox extends SingleChildWidget {
+  LimitedBox({
+    this.maxWidth = double.infinity,
+    this.maxHeight = double.infinity,
+    Widget child,
+  })  : assert(maxWidth != null && maxWidth >= 0.0),
+        assert(maxHeight != null && maxHeight >= 0.0),
+        super(child: child);
+
+  final double maxWidth;
+
+  final double maxHeight;
+
+  BoxConstraints _limitConstraints(BoxConstraints constraints) {
+    return BoxConstraints(
+        minWidth: constraints.minWidth,
+        maxWidth: constraints.hasBoundedWidth
+            ? constraints.maxWidth
+            : constraints.constrainWidth(maxWidth),
+        minHeight: constraints.minHeight,
+        maxHeight: constraints.hasBoundedHeight
+            ? constraints.maxHeight
+            : constraints.constrainHeight(maxHeight));
+  }
+
+  @override
+  void layout(Context context, BoxConstraints constraints,
+      {parentUsesSize = false}) {
+    PdfPoint size;
+    if (child != null) {
+      child.layout(context, _limitConstraints(constraints),
+          parentUsesSize: true);
+      size = constraints.constrain(child.box.size);
+    } else {
+      size = _limitConstraints(constraints).constrain(PdfPoint.zero);
+    }
+    box = PdfRect.fromPoints(PdfPoint.zero, size);
+  }
+}
+
+class Padding extends SingleChildWidget {
+  Padding({
+    @required this.padding,
+    Widget child,
+  })  : assert(padding != null),
+        super(child: child);
+
+  final EdgeInsets padding;
+
+  @override
+  void layout(Context context, BoxConstraints constraints,
+      {parentUsesSize = false}) {
+    if (child != null) {
+      final childConstraints = constraints.deflate(padding);
+      child.layout(context, childConstraints, parentUsesSize: parentUsesSize);
+      box = constraints.constrainRect(
+          width: child.box.width + padding.horizontal,
+          height: child.box.height + padding.vertical);
+    } else {
+      box = constraints.constrainRect(
+          width: padding.horizontal, height: padding.vertical);
+    }
+  }
+
+  @override
+  void debugPaint(Context context) {
+    context.canvas
+      ..setFillColor(PdfColor.lime)
+      ..moveTo(box.x, box.y)
+      ..lineTo(box.right, box.y)
+      ..lineTo(box.right, box.top)
+      ..lineTo(box.x, box.top)
+      ..moveTo(box.x + padding.left, box.y + padding.bottom)
+      ..lineTo(box.x + padding.left, box.top - padding.top)
+      ..lineTo(box.right - padding.right, box.top - padding.top)
+      ..lineTo(box.right - padding.right, box.y + padding.bottom)
+      ..fillPath();
+  }
+
+  @override
+  void paint(Context context) {
+    assert(() {
+      if (Document.debug) debugPaint(context);
+      return true;
+    }());
+
+    if (child != null) {
+      final mat = Matrix4.identity();
+      mat.translate(box.x + padding.left, box.y + padding.bottom);
+      context.canvas
+        ..saveContext()
+        ..setTransform(mat);
+      child.paint(context);
+      context.canvas.restoreContext();
+    }
+  }
+}
+
+class Transform extends SingleChildWidget {
+  Transform({
+    @required this.transform,
+    this.origin,
+    this.alignment,
+    Widget child,
+  })  : assert(transform != null),
+        super(child: child);
+
+  /// Creates a widget that transforms its child using a rotation around the
+  /// center.
+  Transform.rotate({
+    @required double angle,
+    this.origin,
+    this.alignment = Alignment.center,
+    Widget child,
+  })  : transform = Matrix4.rotationZ(angle),
+        super(child: child);
+
+  /// Creates a widget that transforms its child using a translation.
+  Transform.translate({
+    @required PdfPoint offset,
+    Widget child,
+  })  : transform = Matrix4.translationValues(offset.x, offset.y, 0.0),
+        origin = null,
+        alignment = null,
+        super(child: child);
+
+  /// Creates a widget that scales its child uniformly.
+  Transform.scale({
+    @required double scale,
+    this.origin,
+    this.alignment = Alignment.center,
+    Widget child,
+  })  : transform = Matrix4.diagonal3Values(scale, scale, 1.0),
+        super(child: child);
+
+  /// The matrix to transform the child by during painting.
+  final Matrix4 transform;
+
+  /// The origin of the coordinate system
+  final PdfPoint origin;
+
+  /// The alignment of the origin, relative to the size of the box.
+  final Alignment alignment;
+
+  Matrix4 get _effectiveTransform {
+    if (origin == null && alignment == null) return transform;
+    final Matrix4 result = Matrix4.identity();
+    if (origin != null) result.translate(origin.x, origin.y);
+    PdfPoint translation;
+    if (alignment != null) {
+      translation = alignment.alongSize(box.size);
+      result.translate(translation.x, translation.y);
+    }
+    result.multiply(transform);
+    if (alignment != null) result.translate(-translation.x, -translation.y);
+    if (origin != null) result.translate(-origin.x, -origin.y);
+    return result;
+  }
+
+  @override
+  void paint(Context context) {
+    assert(() {
+      if (Document.debug) debugPaint(context);
+      return true;
+    }());
+
+    if (child != null) {
+      final mat = _effectiveTransform;
+      context.canvas
+        ..saveContext()
+        ..setTransform(mat);
+      child.paint(context);
+      context.canvas.restoreContext();
+    }
+  }
+}
+
+/// A widget that aligns its child within itself and optionally sizes itself
+/// based on the child's size.
+class Align extends SingleChildWidget {
+  Align(
+      {this.alignment = Alignment.center,
+      this.widthFactor,
+      this.heightFactor,
+      Widget child})
+      : assert(alignment != null),
+        assert(widthFactor == null || widthFactor >= 0.0),
+        assert(heightFactor == null || heightFactor >= 0.0),
+        super(child: child);
+
+  /// How to align the child.
+  final Alignment alignment;
+
+  /// If non-null, sets its width to the child's width multiplied by this factor.
+  final double widthFactor;
+
+  /// If non-null, sets its height to the child's height multiplied by this factor.
+  final double heightFactor;
+
+  @override
+  void layout(Context context, BoxConstraints constraints,
+      {parentUsesSize = false}) {
+    final bool shrinkWrapWidth =
+        widthFactor != null || constraints.maxWidth == double.infinity;
+    final bool shrinkWrapHeight =
+        heightFactor != null || constraints.maxHeight == double.infinity;
+
+    if (child != null) {
+      child.layout(context, constraints.loosen(), parentUsesSize: true);
+
+      box = constraints.constrainRect(
+          width: shrinkWrapWidth
+              ? child.box.width * (widthFactor ?? 1.0)
+              : double.infinity,
+          height: shrinkWrapHeight
+              ? child.box.height * (heightFactor ?? 1.0)
+              : double.infinity);
+
+      child.box = alignment.inscribe(child.box.size, box);
+    } else {
+      box = constraints.constrainRect(
+          width: shrinkWrapWidth ? 0.0 : double.infinity,
+          height: shrinkWrapHeight ? 0.0 : double.infinity);
+    }
+  }
+}
+
+/// A widget that imposes additional constraints on its child.
+class ConstrainedBox extends SingleChildWidget {
+  ConstrainedBox({@required this.constraints, Widget child})
+      : assert(constraints != null),
+        super(child: child);
+
+  /// The additional constraints to impose on the child.
+  final BoxConstraints constraints;
+
+  @override
+  void layout(Context context, BoxConstraints constraints,
+      {parentUsesSize = false}) {
+    if (child != null) {
+      child.layout(context, this.constraints.enforce(constraints),
+          parentUsesSize: true);
+      box = child.box;
+    } else {
+      box = PdfRect.fromPoints(PdfPoint.zero,
+          this.constraints.enforce(constraints).constrain(PdfPoint.zero));
+    }
+  }
+}
+
+class Center extends Align {
+  Center({double widthFactor, double heightFactor, Widget child})
+      : super(
+            widthFactor: widthFactor, heightFactor: heightFactor, child: child);
+}
+
+/// Scales and positions its child within itself according to [fit].
+class FittedBox extends SingleChildWidget {
+  FittedBox({
+    this.fit = BoxFit.contain,
+    this.alignment = Alignment.center,
+    Widget child,
+  })  : assert(fit != null),
+        assert(alignment != null),
+        super(child: child);
+
+  /// How to inscribe the child into the space allocated during layout.
+  final BoxFit fit;
+
+  /// How to align the child within its parent's bounds.
+  final Alignment alignment;
+
+  @override
+  void layout(Context context, BoxConstraints constraints,
+      {parentUsesSize = false}) {
+    PdfPoint size;
+    if (child != null) {
+      child.layout(context, const BoxConstraints(), parentUsesSize: true);
+      size = constraints
+          .constrainSizeAndAttemptToPreserveAspectRatio(child.box.size);
+    } else {
+      size = constraints.smallest;
+    }
+    box = PdfRect.fromPoints(PdfPoint.zero, size);
+  }
+
+  @override
+  void paint(Context context) {
+    if (child != null) {
+      final PdfPoint childSize = child.box.size;
+      final FittedSizes sizes = applyBoxFit(fit, childSize, box.size);
+      final double scaleX = sizes.destination.x / sizes.source.x;
+      final double scaleY = sizes.destination.y / sizes.source.y;
+      final PdfRect sourceRect = alignment.inscribe(
+          sizes.source, PdfRect.fromPoints(PdfPoint.zero, childSize));
+      final PdfRect destinationRect =
+          alignment.inscribe(sizes.destination, box);
+
+      final mat =
+          Matrix4.translationValues(destinationRect.x, destinationRect.y, 0.0)
+            ..scale(scaleX, scaleY, 1.0)
+            ..translate(-sourceRect.x, -sourceRect.y);
+
+      context.canvas
+        ..saveContext()
+        ..drawRect(box.x, box.y, box.width, box.height)
+        ..clipPath()
+        ..setTransform(mat);
+      child.paint(context);
+      context.canvas.restoreContext();
+    }
+  }
+}
+
+class AspectRatio extends SingleChildWidget {
+  AspectRatio({@required this.aspectRatio, Widget child})
+      : assert(aspectRatio != null),
+        super(child: child);
+
+  /// The aspect ratio to attempt to use.
+  final double aspectRatio;
+
+  PdfPoint _applyAspectRatio(BoxConstraints constraints) {
+    if (constraints.isTight) return constraints.smallest;
+
+    double width = constraints.maxWidth;
+    double height;
+
+    if (width.isFinite) {
+      height = width / aspectRatio;
+    } else {
+      height = constraints.maxHeight;
+      width = height * aspectRatio;
+    }
+
+    if (width > constraints.maxWidth) {
+      width = constraints.maxWidth;
+      height = width / aspectRatio;
+    }
+
+    if (height > constraints.maxHeight) {
+      height = constraints.maxHeight;
+      width = height * aspectRatio;
+    }
+
+    if (width < constraints.minWidth) {
+      width = constraints.minWidth;
+      height = width / aspectRatio;
+    }
+
+    if (height < constraints.minHeight) {
+      height = constraints.minHeight;
+      width = height * aspectRatio;
+    }
+
+    return constraints.constrain(PdfPoint(width, height));
+  }
+
+  @override
+  void layout(Context context, BoxConstraints constraints,
+      {parentUsesSize = false}) {
+    box = PdfRect.fromPoints(PdfPoint.zero, _applyAspectRatio(constraints));
+    if (child != null)
+      child.layout(context,
+          BoxConstraints.tightFor(width: box.width, height: box.height));
+  }
+}
+
+typedef CustomPainter(PdfGraphics canvas, PdfPoint size);
+
+class CustomPaint extends SingleChildWidget {
+  CustomPaint(
+      {this.painter,
+      this.foregroundPainter,
+      this.size = PdfPoint.zero,
+      Widget child})
+      : super(child: child);
+
+  final CustomPainter painter;
+  final CustomPainter foregroundPainter;
+  final PdfPoint size;
+
+  @override
+  void layout(Context context, BoxConstraints constraints,
+      {parentUsesSize = false}) {
+    if (child != null) {
+      child.layout(context, constraints.tighten(width: size.x, height: size.y),
+          parentUsesSize: parentUsesSize);
+      box = child.box;
+    } else {
+      box = PdfRect.fromPoints(PdfPoint.zero, constraints.constrain(size));
+    }
+  }
+
+  @override
+  void paint(Context context) {
+    assert(() {
+      if (Document.debug) debugPaint(context);
+      return true;
+    }());
+
+    final mat = Matrix4.identity();
+    mat.translate(box.x, box.y);
+    context.canvas
+      ..saveContext()
+      ..setTransform(mat);
+    if (painter != null) painter(context.canvas, box.size);
+    if (child != null) child.paint(context);
+    if (foregroundPainter != null) foregroundPainter(context.canvas, box.size);
+    context.canvas.restoreContext();
+  }
+}

+/*
+ * Copyright (C) 2017, David PHAM-VAN <dev.nfet.net@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+part of widget;
+
+class ClipRect extends SingleChildWidget {
+  ClipRect({Widget child}) : super(child: child);
+
+  @protected
+  void debugPaint(Context context) {
+    context.canvas
+      ..setStrokeColor(PdfColor.deepPurple)
+      ..drawRect(box.x, box.y, box.width, box.height)
+      ..strokePath();
+  }
+
+  @override
+  void paint(Context context) {
+    assert(() {
+      if (Document.debug) debugPaint(context);
+      return true;
+    }());
+
+    if (child != null) {
+      final mat = Matrix4.identity();
+      mat.translate(box.x, box.y);
+      context.canvas
+        ..saveContext()
+        ..drawRect(box.x, box.y, box.width, box.height)
+        ..clipPath()
+        ..setTransform(mat);
+      child.paint(context);
+      context.canvas.restoreContext();
+    }
+  }
+}
+
+class ClipRRect extends SingleChildWidget {
+  ClipRRect({
+    Widget child,
+    this.horizontalRadius,
+    this.verticalRadius,
+  }) : super(child: child);
+
+  final double horizontalRadius;
+  final double verticalRadius;
+
+  @protected
+  void debugPaint(Context context) {
+    context.canvas
+      ..setStrokeColor(PdfColor.deepPurple)
+      ..drawRRect(
+          box.x, box.y, box.width, box.height, horizontalRadius, verticalRadius)
+      ..strokePath();
+  }
+
+  @override
+  void paint(Context context) {
+    assert(() {
+      if (Document.debug) debugPaint(context);
+      return true;
+    }());
+
+    if (child != null) {
+      final mat = Matrix4.identity();
+      mat.translate(box.x, box.y);
+      context.canvas
+        ..saveContext()
+        ..drawRRect(box.x, box.y, box.width, box.height, horizontalRadius,
+            verticalRadius)
+        ..clipPath()
+        ..setTransform(mat);
+      child.paint(context);
+      context.canvas.restoreContext();
+    }
+  }
+}
+
+class ClipOval extends SingleChildWidget {
+  ClipOval({Widget child}) : super(child: child);
+
+  @protected
+  void debugPaint(Context context) {
+    final rx = box.width / 2.0;
+    final ry = box.height / 2.0;
+
+    context.canvas
+      ..setStrokeColor(PdfColor.deepPurple)
+      ..drawEllipse(box.x + rx, box.y + ry, rx, ry)
+      ..strokePath();
+  }
+
+  @override
+  void paint(Context context) {
+    assert(() {
+      if (Document.debug) debugPaint(context);
+      return true;
+    }());
+
+    final rx = box.width / 2.0;
+    final ry = box.height / 2.0;
+
+    if (child != null) {
+      final mat = Matrix4.identity();
+      mat.translate(box.x, box.y);
+      context.canvas
+        ..saveContext()
+        ..drawEllipse(box.x + rx, box.y + ry, rx, ry)
+        ..clipPath()
+        ..setTransform(mat);
+      child.paint(context);
+      context.canvas.restoreContext();
+    }
+  }
+}

+/*
+ * Copyright (C) 2017, David PHAM-VAN <dev.nfet.net@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+part of widget;
+
+enum DecorationPosition { background, foreground }
+
+@immutable
+class BoxBorder {
+  const BoxBorder(
+      {this.left = false,
+      this.top = false,
+      this.right = false,
+      this.bottom = false,
+      this.color = PdfColor.black,
+      this.width = 1.0})
+      : assert(color != null),
+        assert(width != null),
+        assert(width >= 0.0);
+
+  final bool top;
+  final bool bottom;
+  final bool left;
+  final bool right;
+
+  /// The color of the
+  final PdfColor color;
+
+  /// The width of the
+  final double width;
+
+  void paintBorders(Context context, PdfRect box) {
+    assert(box.x != null);
+    assert(box.y != null);
+    assert(box.width != null);
+    assert(box.height != null);
+
+    if (top || bottom || left || right) {
+      context.canvas
+        ..setStrokeColor(color)
+        ..setLineWidth(width);
+
+      if (top) {
+        context.canvas.drawLine(box.x, box.top, box.right, box.top);
+      }
+
+      if (right) {
+        if (!top) {
+          context.canvas.moveTo(box.right, box.top);
+        }
+        context.canvas.lineTo(box.right, box.y);
+      }
+
+      if (bottom) {
+        if (!right) {
+          context.canvas.moveTo(box.right, box.y);
+        }
+        context.canvas.lineTo(box.x, box.y);
+      }
+
+      if (left) {
+        if (!bottom) {
+          context.canvas.moveTo(box.x, box.y);
+          context.canvas.lineTo(box.x, box.top);
+        } else if (right && top) {
+          context.canvas.closePath();
+        } else
+          context.canvas.lineTo(box.x, box.top);
+      }
+
+      context.canvas.strokePath();
+    }
+  }
+}
+
+enum BoxShape { circle, rectangle }
+
+@immutable
+class BoxDecoration {
+  const BoxDecoration(
+      {this.color,
+      this.border,
+      this.borderRadius,
+      this.shape = BoxShape.rectangle});
+
+  /// The color to fill in the background of the box.
+  final PdfColor color;
+  final BoxBorder border;
+  final double borderRadius;
+  final BoxShape shape;
+
+  void paintBackground(Context context, PdfRect box) {
+    assert(box.x != null);
+    assert(box.y != null);
+    assert(box.width != null);
+    assert(box.height != null);
+
+    if (color != null) {
+      switch (shape) {
+        case BoxShape.rectangle:
+          if (borderRadius == null)
+            context.canvas.drawRect(box.x, box.y, box.width, box.height);
+          else
+            context.canvas.drawRRect(box.x, box.y, box.width, box.height,
+                borderRadius, borderRadius);
+
+          break;
+        case BoxShape.circle:
+          context.canvas.drawEllipse(box.x + box.width / 2.0,
+              box.y + box.height / 2.0, box.width / 2.0, box.height / 2.0);
+          break;
+      }
+      context.canvas
+        ..setFillColor(color)
+        ..fillPath();
+    }
+  }
+}
+
+class DecoratedBox extends SingleChildWidget {
+  DecoratedBox(
+      {@required this.decoration,
+      this.position = DecorationPosition.background,
+      Widget child})
+      : assert(decoration != null),
+        assert(position != null),
+        super(child: child);
+
+  /// What decoration to paint.
+  final BoxDecoration decoration;
+
+  /// Whether to paint the box decoration behind or in front of the child.
+  final DecorationPosition position;
+
+  @override
+  void paint(Context context) {
+    if (position == DecorationPosition.background) {
+      decoration.paintBackground(context, box);
+      decoration.border?.paintBorders(context, box);
+    }
+    super.paint(context);
+    if (position == DecorationPosition.foreground) {
+      decoration.paintBackground(context, box);
+      decoration.border?.paintBorders(context, box);
+    }
+  }
+}
+
+class Container extends StatelessWidget {
+  Container({
+    this.alignment,
+    this.padding,
+    PdfColor color,
+    BoxDecoration decoration,
+    this.foregroundDecoration,
+    double width,
+    double height,
+    BoxConstraints constraints,
+    this.margin,
+    this.transform,
+    this.child,
+  })  : assert(
+            color == null || decoration == null,
+            'Cannot provide both a color and a decoration\n'
+            'The color argument is just a shorthand for "decoration: new BoxDecoration(color: color)".'),
+        decoration =
+            decoration ?? (color != null ? BoxDecoration(color: color) : null),
+        constraints = (width != null || height != null)
+            ? constraints?.tighten(width: width, height: height) ??
+                BoxConstraints.tightFor(width: width, height: height)
+            : constraints,
+        super();
+
+  final Widget child;
+
+  final Alignment alignment;
+
+  final EdgeInsets padding;
+
+  /// The decoration to paint behind the [child].
+  final BoxDecoration decoration;
+
+  /// The decoration to paint in front of the [child].
+  final BoxDecoration foregroundDecoration;
+
+  /// Additional constraints to apply to the child.
+  final BoxConstraints constraints;
+
+  /// Empty space to surround the [decoration] and [child].
+  final EdgeInsets margin;
+
+  /// The transformation matrix to apply before painting the container.
+  final Matrix4 transform;
+
+  @override
+  Widget build(Context context) {
+    Widget current = child;
+
+    if (child == null && (constraints == null || !constraints.isTight)) {
+      current = LimitedBox(
+          maxWidth: 0.0,
+          maxHeight: 0.0,
+          child: ConstrainedBox(constraints: const BoxConstraints.expand()));
+    }
+
+    if (alignment != null)
+      current = Align(alignment: alignment, child: current);
+
+    if (padding != null) current = Padding(padding: padding, child: current);
+
+    if (decoration != null)
+      current = DecoratedBox(decoration: decoration, child: current);
+
+    if (foregroundDecoration != null) {
+      current = DecoratedBox(
+          decoration: foregroundDecoration,
+          position: DecorationPosition.foreground,
+          child: current);
+    }
+
+    if (constraints != null)
+      current = ConstrainedBox(constraints: constraints, child: current);
+
+    if (margin != null) current = Padding(padding: margin, child: current);
+
+    if (transform != null)
+      current = Transform(transform: transform, child: current);
+
+    return current;
+  }
+}

+/*
+ * Copyright (C) 2017, David PHAM-VAN <dev.nfet.net@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+part of widget;
+
+class Header extends StatelessWidget {
+  final String text;
+  final Widget child;
+  final int level;
+
+  Header({this.level = 1, this.text, this.child})
+      : assert(level >= 0 && level <= 5);
+
+  @override
+  Widget build(Context context) {
+    BoxDecoration _decoration;
+    EdgeInsets _margin;
+    EdgeInsets _padding;
+    double _textSize;
+    switch (level) {
+      case 0:
+        _margin = EdgeInsets.only(bottom: 5.0 * PdfPageFormat.mm);
+        _padding = EdgeInsets.only(bottom: 1.0 * PdfPageFormat.mm);
+        _decoration =
+            BoxDecoration(border: BoxBorder(bottom: true, width: 1.0));
+        _textSize = 2.0;
+        break;
+      case 1:
+        _margin = EdgeInsets.only(
+            top: 3.0 * PdfPageFormat.mm, bottom: 5.0 * PdfPageFormat.mm);
+        _decoration =
+            BoxDecoration(border: BoxBorder(bottom: true, width: 0.2));
+        _textSize = 1.5;
+        break;
+      case 2:
+        _margin = EdgeInsets.only(
+            top: 2.0 * PdfPageFormat.mm, bottom: 4.0 * PdfPageFormat.mm);
+        _textSize = 1.4;
+        break;
+      case 3:
+        _margin = EdgeInsets.only(
+            top: 2.0 * PdfPageFormat.mm, bottom: 4.0 * PdfPageFormat.mm);
+        _textSize = 1.3;
+        break;
+      case 4:
+        _margin = EdgeInsets.only(
+            top: 2.0 * PdfPageFormat.mm, bottom: 4.0 * PdfPageFormat.mm);
+        _textSize = 1.2;
+        break;
+      case 5:
+        _margin = EdgeInsets.only(
+            top: 2.0 * PdfPageFormat.mm, bottom: 4.0 * PdfPageFormat.mm);
+        _textSize = 1.1;
+        break;
+    }
+    return Container(
+      alignment: Alignment.topLeft,
+      margin: _margin,
+      padding: _padding,
+      decoration: _decoration,
+      child: child ?? Text(text, textScaleFactor: _textSize),
+    );
+  }
+}
+
+class Paragraph extends StatelessWidget {
+  final String text;
+
+  Paragraph({this.text});
+
+  @override
+  Widget build(Context context) {
+    return Container(
+      margin: EdgeInsets.only(bottom: 5.0 * PdfPageFormat.mm),
+      child: Text(
+        text,
+        textAlign: TextAlign.justify,
+        style: Theme.of(context).paragraphStyle,
+      ),
+    );
+  }
+}
+
+class Bullet extends StatelessWidget {
+  final String text;
+
+  Bullet({this.text});
+
+  @override
+  Widget build(Context context) {
+    return Container(
+        margin: EdgeInsets.only(bottom: 2.0 * PdfPageFormat.mm),
+        child: Row(
+            crossAxisAlignment: CrossAxisAlignment.start,
+            children: <Widget>[
+              Container(
+                width: 2.0 * PdfPageFormat.mm,
+                height: 2.0 * PdfPageFormat.mm,
+                margin: EdgeInsets.only(
+                  top: 0.5 * PdfPageFormat.mm,
+                  left: 5.0 * PdfPageFormat.mm,
+                  right: 2.0 * PdfPageFormat.mm,
+                ),
+                decoration: BoxDecoration(
+                    color: PdfColor.black, shape: BoxShape.circle),
+              ),
+              Expanded(child: Text(text, style: Theme.of(context).bulletStyle))
+            ]));
+  }
+}

+/*
+ * Copyright (C) 2017, David PHAM-VAN <dev.nfet.net@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+part of widget;
+
+abstract class BasePage {
+  final PdfPageFormat pageFormat;
+
+  BasePage({this.pageFormat}) : assert(pageFormat != null);
+
+  @protected
+  void generate(Document document);
+}
+
+class Document {
+  static var debug = false;
+
+  final PdfDocument document;
+
+  final Theme theme;
+
+  Document(
+      {PdfPageMode pageMode = PdfPageMode.none,
+      DeflateCallback deflate,
+      this.theme})
+      : document = PdfDocument(pageMode: pageMode, deflate: deflate);
+
+  void addPage(BasePage page) {
+    page.generate(this);
+  }
+}
+
+typedef Widget BuildCallback(Context context);
+typedef List<Widget> BuildListCallback(Context context);
+
+class Page extends BasePage {
+  final EdgeInsets margin;
+  final BuildCallback _build;
+  final Theme theme;
+
+  Page(
+      {PdfPageFormat pageFormat = PdfPageFormat.a4,
+      BuildCallback build,
+      this.theme,
+      EdgeInsets margin})
+      : margin = margin ??
+            EdgeInsets.fromLTRB(pageFormat.marginLeft, pageFormat.marginTop,
+                pageFormat.marginRight, pageFormat.marginBottom),
+        _build = build,
+        super(pageFormat: pageFormat);
+
+  void debugPaint(Context context) {
+    context.canvas
+      ..setFillColor(PdfColor.lightGreen)
+      ..moveTo(0.0, 0.0)
+      ..lineTo(pageFormat.width, 0.0)
+      ..lineTo(pageFormat.width, pageFormat.height)
+      ..lineTo(0.0, pageFormat.height)
+      ..moveTo(margin.left, margin.bottom)
+      ..lineTo(margin.left, pageFormat.height - margin.top)
+      ..lineTo(pageFormat.width - margin.right, pageFormat.height - margin.top)
+      ..lineTo(pageFormat.width - margin.right, margin.bottom)
+      ..fillPath();
+  }
+
+  @override
+  void generate(Document document) {
+    final pdfPage = PdfPage(document.document, pageFormat: pageFormat);
+    final canvas = pdfPage.getGraphics();
+    final constraints = BoxConstraints(
+        maxWidth: pageFormat.width, maxHeight: pageFormat.height);
+
+    final calculatedTheme = theme ?? document.theme ?? Theme(document.document);
+    final inherited = Map<Type, Inherited>();
+    inherited[calculatedTheme.runtimeType] = calculatedTheme;
+    final context =
+        Context(page: pdfPage, canvas: canvas, inherited: inherited);
+    if (_build != null) {
+      final child = _build(context);
+      layout(child, context, constraints);
+      paint(child, context);
+    }
+  }
+
+  @protected
+  void layout(Widget child, Context context, BoxConstraints constraints,
+      {parentUsesSize = false}) {
+    if (child != null) {
+      final childConstraints = BoxConstraints(
+          minWidth: constraints.minWidth,
+          minHeight: constraints.minHeight,
+          maxWidth: constraints.hasBoundedWidth
+              ? constraints.maxWidth - margin.horizontal
+              : margin.horizontal,
+          maxHeight: constraints.hasBoundedHeight
+              ? constraints.maxHeight - margin.vertical
+              : margin.vertical);
+      child.layout(context, childConstraints, parentUsesSize: parentUsesSize);
+      child.box = PdfRect(
+          margin.left,
+          pageFormat.height - child.box.height - margin.top,
+          child.box.width,
+          child.box.height);
+    }
+  }
+
+  @protected
+  void paint(Widget child, Context context) {
+    assert(() {
+      if (Document.debug) debugPaint(context);
+      return true;
+    }());
+
+    if (child != null) {
+      child.paint(context);
+    }
+  }
+}
+
+class MultiPage extends Page {
+  final BuildListCallback _buildList;
+  final CrossAxisAlignment crossAxisAlignment;
+  final BuildCallback header;
+  final BuildCallback footer;
+
+  MultiPage(
+      {PdfPageFormat pageFormat = PdfPageFormat.a4,
+      BuildListCallback build,
+      this.crossAxisAlignment = CrossAxisAlignment.start,
+      this.header,
+      this.footer,
+      EdgeInsets margin})
+      : _buildList = build,
+        super(pageFormat: pageFormat, margin: margin);
+
+  @override
+  void generate(Document document) {
+    if (_buildList == null) return;
+
+    final constraints = BoxConstraints(
+        maxWidth: pageFormat.width, maxHeight: pageFormat.height);
+    final childConstraints =
+        BoxConstraints(maxWidth: constraints.maxWidth - margin.horizontal);
+    final calculatedTheme = theme ?? document.theme ?? Theme(document.document);
+    final inherited = Map<Type, Inherited>();
+    inherited[calculatedTheme.runtimeType] = calculatedTheme;
+    Context context;
+    double offsetEnd;
+    double offsetStart;
+    var index = 0;
+    final children = _buildList(Context(inherited: inherited));
+    WidgetContext widgetContext;
+
+    while (index < children.length) {
+      final child = children[index];
+
+      if (context == null) {
+        final pdfPage = PdfPage(document.document, pageFormat: pageFormat);
+        final canvas = pdfPage.getGraphics();
+        context = Context(page: pdfPage, canvas: canvas, inherited: inherited);
+        assert(() {
+          if (Document.debug) debugPaint(context);
+          return true;
+        }());
+        offsetStart = pageFormat.height - margin.top;
+        offsetEnd = margin.bottom;
+        if (header != null) {
+          final headerWidget = header(context);
+          if (headerWidget != null) {
+            headerWidget.layout(context, childConstraints,
+                parentUsesSize: false);
+            headerWidget.box = PdfRect(
+                margin.left,
+                offsetStart - headerWidget.box.height,
+                headerWidget.box.width,
+                headerWidget.box.height);
+            headerWidget.paint(context);
+            offsetStart -= headerWidget.box.height;
+          }
+        }
+
+        if (footer != null) {
+          final footerWidget = footer(context);
+          if (footerWidget != null) {
+            footerWidget.layout(context, childConstraints,
+                parentUsesSize: false);
+            footerWidget.box = PdfRect(margin.left, margin.bottom,
+                footerWidget.box.width, footerWidget.box.height);
+            footerWidget.paint(context);
+            offsetEnd += footerWidget.box.height;
+          }
+        }
+      }
+
+      if (widgetContext != null && child is SpanningWidget) {
+        (child as SpanningWidget).restoreContext(widgetContext);
+        widgetContext = null;
+      }
+
+      child.layout(context, childConstraints, parentUsesSize: false);
+
+      if (offsetStart - child.box.height < offsetEnd) {
+        if (child.box.height < pageFormat.height - margin.vertical) {
+          context = null;
+          continue;
+        }
+
+        if (!(child is SpanningWidget)) {
+          throw Exception("Widget won't fit into the page");
+        }
+
+        final span = child as SpanningWidget;
+
+        child.layout(context,
+            childConstraints.copyWith(maxHeight: offsetStart - offsetEnd),
+            parentUsesSize: false);
+        child.box = PdfRect(margin.left, offsetStart - child.box.height,
+            child.box.width, child.box.height);
+        child.paint(context);
+
+        if (span.canSpan) {
+          widgetContext = span.saveContext();
+        } else {
+          index++;
+        }
+
+        context = null;
+        continue;
+      }
+
+      child.box = PdfRect(margin.left, offsetStart - child.box.height,
+          child.box.width, child.box.height);
+      child.paint(context);
+      offsetStart -= child.box.height;
+      index++;
+    }
+  }
+}

+/*
+ * Copyright (C) 2017, David PHAM-VAN <dev.nfet.net@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+part of widget;
+
+enum FlexFit {
+  tight,
+  loose,
+}
+
+enum Axis {
+  horizontal,
+  vertical,
+}
+
+enum MainAxisSize {
+  min,
+  max,
+}
+
+enum MainAxisAlignment {
+  start,
+  end,
+  center,
+  spaceBetween,
+  spaceAround,
+  spaceEvenly,
+}
+
+enum CrossAxisAlignment {
+  start,
+  end,
+  center,
+  stretch,
+}
+
+enum VerticalDirection {
+  up,
+  down,
+}
+
+typedef _ChildSizingFunction = double Function(Widget child, double extent);
+
+class Flex extends MultiChildWidget {
+  Flex({
+    @required this.direction,
+    this.mainAxisAlignment = MainAxisAlignment.start,
+    this.mainAxisSize = MainAxisSize.max,
+    this.crossAxisAlignment = CrossAxisAlignment.center,
+    this.verticalDirection = VerticalDirection.down,
+    List<Widget> children = const <Widget>[],
+  })  : assert(direction != null),
+        assert(mainAxisAlignment != null),
+        assert(mainAxisSize != null),
+        assert(crossAxisAlignment != null),
+        super(children: children);
+
+  final Axis direction;
+
+  final MainAxisAlignment mainAxisAlignment;
+
+  final MainAxisSize mainAxisSize;
+
+  final CrossAxisAlignment crossAxisAlignment;
+
+  final VerticalDirection verticalDirection;
+
+  double _getIntrinsicSize(
+      {Axis sizingDirection,
+      double
+          extent, // the extent in the direction that isn't the sizing direction
+      _ChildSizingFunction
+          childSize // a method to find the size in the sizing direction
+      }) {
+    if (direction == sizingDirection) {
+      // INTRINSIC MAIN SIZE
+      // Intrinsic main size is the smallest size the flex container can take
+      // while maintaining the min/max-content contributions of its flex items.
+      double totalFlex = 0.0;
+      double inflexibleSpace = 0.0;
+      double maxFlexFractionSoFar = 0.0;
+
+      for (var child in children) {
+        final int flex = child._flex;
+        totalFlex += flex;
+        if (flex > 0) {
+          final double flexFraction = childSize(child, extent) / child._flex;
+          maxFlexFractionSoFar = math.max(maxFlexFractionSoFar, flexFraction);
+        } else {
+          inflexibleSpace += childSize(child, extent);
+        }
+      }
+      return maxFlexFractionSoFar * totalFlex + inflexibleSpace;
+    } else {
+      // INTRINSIC CROSS SIZE
+      // Intrinsic cross size is the max of the intrinsic cross sizes of the
+      // children, after the flexible children are fit into the available space,
+      // with the children sized using their max intrinsic dimensions.
+
+      // Get inflexible space using the max intrinsic dimensions of fixed children in the main direction.
+      final double availableMainSpace = extent;
+      int totalFlex = 0;
+      double inflexibleSpace = 0.0;
+      double maxCrossSize = 0.0;
+      for (var child in children) {
+        final int flex = child._flex;
+        totalFlex += flex;
+        double mainSize;
+        double crossSize;
+        if (flex == 0) {
+          switch (direction) {
+            case Axis.horizontal:
+              mainSize = child.box.width;
+              crossSize = childSize(child, mainSize);
+              break;
+            case Axis.vertical:
+              mainSize = child.box.height;
+              crossSize = childSize(child, mainSize);
+              break;
+          }
+          inflexibleSpace += mainSize;
+          maxCrossSize = math.max(maxCrossSize, crossSize);
+        }
+      }
+
+      // Determine the spacePerFlex by allocating the remaining available space.
+      // When you're over-constrained spacePerFlex can be negative.
+      final double spacePerFlex =
+          math.max(0.0, (availableMainSpace - inflexibleSpace) / totalFlex);
+
+      // Size remaining (flexible) items, find the maximum cross size.
+      for (var child in children) {
+        final int flex = child._flex;
+        if (flex > 0)
+          maxCrossSize =
+              math.max(maxCrossSize, childSize(child, spacePerFlex * flex));
+      }
+
+      return maxCrossSize;
+    }
+  }
+
+  double computeMinIntrinsicWidth(double height) {
+    return _getIntrinsicSize(
+        sizingDirection: Axis.horizontal,
+        extent: height,
+        childSize: (Widget child, double extent) => child.box.width);
+  }
+
+  double computeMaxIntrinsicWidth(double height) {
+    return _getIntrinsicSize(
+        sizingDirection: Axis.horizontal,
+        extent: height,
+        childSize: (Widget child, double extent) => child.box.width);
+  }
+
+  double computeMinIntrinsicHeight(double width) {
+    return _getIntrinsicSize(
+        sizingDirection: Axis.vertical,
+        extent: width,
+        childSize: (Widget child, double extent) => child.box.height);
+  }
+
+  double computeMaxIntrinsicHeight(double width) {
+    return _getIntrinsicSize(
+        sizingDirection: Axis.vertical,
+        extent: width,
+        childSize: (Widget child, double extent) => child.box.height);
+  }
+
+  double _getCrossSize(Widget child) {
+    switch (direction) {
+      case Axis.horizontal:
+        return child.box.height;
+      case Axis.vertical:
+        return child.box.width;
+    }
+    return null;
+  }
+
+  double _getMainSize(Widget child) {
+    switch (direction) {
+      case Axis.horizontal:
+        return child.box.width;
+      case Axis.vertical:
+        return child.box.height;
+    }
+    return null;
+  }
+
+  @override
+  void layout(Context context, BoxConstraints constraints,
+      {parentUsesSize = false}) {
+    // Determine used flex factor, size inflexible items, calculate free space.
+    int totalFlex = 0;
+    final totalChildren = children.length;
+    Widget lastFlexChild;
+    assert(constraints != null);
+    final double maxMainSize = direction == Axis.horizontal
+        ? constraints.maxWidth
+        : constraints.maxHeight;
+    final bool canFlex = maxMainSize < double.infinity;
+
+    double crossSize = 0.0;
+    double allocatedSize =
+        0.0; // Sum of the sizes of the non-flexible children.
+
+    for (var child in children) {
+      final int flex = child._flex;
+      if (flex > 0) {
+        assert(() {
+          final String dimension =
+              direction == Axis.horizontal ? 'width' : 'height';
+          if (!canFlex &&
+              (mainAxisSize == MainAxisSize.max ||
+                  child._fit == FlexFit.tight)) {
+            throw Exception(
+                'Flex children have non-zero flex but incoming $dimension constraints are unbounded.');
+          } else {
+            return true;
+          }
+        }());
+        totalFlex += child._flex;
+      } else {
+        BoxConstraints innerConstraints;
+        if (crossAxisAlignment == CrossAxisAlignment.stretch) {
+          switch (direction) {
+            case Axis.horizontal:
+              innerConstraints = BoxConstraints(
+                  minHeight: constraints.maxHeight,
+                  maxHeight: constraints.maxHeight);
+              break;
+            case Axis.vertical:
+              innerConstraints = BoxConstraints(
+                  minWidth: constraints.maxWidth,
+                  maxWidth: constraints.maxWidth);
+              break;
+          }
+        } else {
+          switch (direction) {
+            case Axis.horizontal:
+              innerConstraints =
+                  BoxConstraints(maxHeight: constraints.maxHeight);
+              break;
+            case Axis.vertical:
+              innerConstraints = BoxConstraints(maxWidth: constraints.maxWidth);
+              break;
+          }
+        }
+        child.layout(context, innerConstraints, parentUsesSize: true);
+        allocatedSize += _getMainSize(child);
+        crossSize = math.max(crossSize, _getCrossSize(child));
+      }
+      lastFlexChild = child;
+    }
+
+    // Distribute free space to flexible children, and determine baseline.
+    final double freeSpace =
+        math.max(0.0, (canFlex ? maxMainSize : 0.0) - allocatedSize);
+    double allocatedFlexSpace = 0.0;
+    if (totalFlex > 0) {
+      final double spacePerFlex =
+          canFlex && totalFlex > 0 ? (freeSpace / totalFlex) : double.nan;
+
+      for (var child in children) {
+        final int flex = child._flex;
+        if (flex > 0) {
+          final double maxChildExtent = canFlex
+              ? (child == lastFlexChild
+                  ? (freeSpace - allocatedFlexSpace)
+                  : spacePerFlex * flex)
+              : double.infinity;
+          double minChildExtent;
+          switch (child._fit) {
+            case FlexFit.tight:
+              assert(maxChildExtent < double.infinity);
+              minChildExtent = maxChildExtent;
+              break;
+            case FlexFit.loose:
+              minChildExtent = 0.0;
+              break;
+          }
+          assert(minChildExtent != null);
+          BoxConstraints innerConstraints;
+          if (crossAxisAlignment == CrossAxisAlignment.stretch) {
+            switch (direction) {
+              case Axis.horizontal:
+                innerConstraints = BoxConstraints(
+                    minWidth: minChildExtent,
+                    maxWidth: maxChildExtent,
+                    minHeight: constraints.maxHeight,
+                    maxHeight: constraints.maxHeight);
+                break;
+              case Axis.vertical:
+                innerConstraints = BoxConstraints(
+                    minWidth: constraints.maxWidth,
+                    maxWidth: constraints.maxWidth,
+                    minHeight: minChildExtent,
+                    maxHeight: maxChildExtent);
+                break;
+            }
+          } else {
+            switch (direction) {
+              case Axis.horizontal:
+                innerConstraints = BoxConstraints(
+                    minWidth: minChildExtent,
+                    maxWidth: maxChildExtent,
+                    maxHeight: constraints.maxHeight);
+                break;
+              case Axis.vertical:
+                innerConstraints = BoxConstraints(
+                    maxWidth: constraints.maxWidth,
+                    minHeight: minChildExtent,
+                    maxHeight: maxChildExtent);
+                break;
+            }
+          }
+          child.layout(context, innerConstraints, parentUsesSize: true);
+          final double childSize = _getMainSize(child);
+          assert(childSize <= maxChildExtent);
+          allocatedSize += childSize;
+          allocatedFlexSpace += maxChildExtent;
+          crossSize = math.max(crossSize, _getCrossSize(child));
+        }
+      }
+    }
+
+    // Align items along the main axis.
+    final double idealSize = canFlex && mainAxisSize == MainAxisSize.max
+        ? maxMainSize
+        : allocatedSize;
+    double actualSize;
+    double actualSizeDelta;
+    PdfPoint size;
+    switch (direction) {
+      case Axis.horizontal:
+        size = constraints.constrain(PdfPoint(idealSize, crossSize));
+        actualSize = size.x;
+        crossSize = size.y;
+        break;
+      case Axis.vertical:
+        size = constraints.constrain(PdfPoint(crossSize, idealSize));
+        actualSize = size.y;
+        crossSize = size.x;
+        break;
+    }
+
+    box = PdfRect.fromPoints(PdfPoint.zero, size);
+    actualSizeDelta = actualSize - allocatedSize;
+
+    final double remainingSpace = math.max(0.0, actualSizeDelta);
+    double leadingSpace;
+    double betweenSpace;
+    final bool flipMainAxis = (verticalDirection == VerticalDirection.down &&
+            direction == Axis.vertical) ||
+        (verticalDirection == VerticalDirection.up &&
+            direction == Axis.horizontal);
+    switch (mainAxisAlignment) {
+      case MainAxisAlignment.start:
+        leadingSpace = 0.0;
+        betweenSpace = 0.0;
+        break;
+      case MainAxisAlignment.end:
+        leadingSpace = remainingSpace;
+        betweenSpace = 0.0;
+        break;
+      case MainAxisAlignment.center:
+        leadingSpace = remainingSpace / 2.0;
+        betweenSpace = 0.0;
+        break;
+      case MainAxisAlignment.spaceBetween:
+        leadingSpace = 0.0;
+        betweenSpace =
+            totalChildren > 1 ? remainingSpace / (totalChildren - 1) : 0.0;
+        break;
+      case MainAxisAlignment.spaceAround:
+        betweenSpace = totalChildren > 0 ? remainingSpace / totalChildren : 0.0;
+        leadingSpace = betweenSpace / 2.0;
+        break;
+      case MainAxisAlignment.spaceEvenly:
+        betweenSpace =
+            totalChildren > 0 ? remainingSpace / (totalChildren + 1) : 0.0;
+        leadingSpace = betweenSpace;
+        break;
+    }
+
+    // Position elements
+    final bool flipCrossAxis = (verticalDirection == VerticalDirection.down &&
+            direction == Axis.horizontal) ||
+        (verticalDirection == VerticalDirection.up &&
+            direction == Axis.vertical);
+    double childMainPosition =
+        flipMainAxis ? actualSize - leadingSpace : leadingSpace;
+    for (var child in children) {
+      double childCrossPosition;
+      switch (crossAxisAlignment) {
+        case CrossAxisAlignment.start:
+          childCrossPosition =
+              flipCrossAxis ? crossSize - _getCrossSize(child) : 0.0;
+          break;
+        case CrossAxisAlignment.end:
+          childCrossPosition =
+              !flipCrossAxis ? crossSize - _getCrossSize(child) : 0.0;
+          break;
+        case CrossAxisAlignment.center:
+          childCrossPosition = crossSize / 2.0 - _getCrossSize(child) / 2.0;
+          break;
+        case CrossAxisAlignment.stretch:
+          childCrossPosition = 0.0;
+          break;
+      }
+
+      if (flipMainAxis) childMainPosition -= _getMainSize(child);
+      switch (direction) {
+        case Axis.horizontal:
+          child.box = PdfRect(box.x + childMainPosition,
+              box.y + childCrossPosition, child.box.width, child.box.height);
+          break;
+        case Axis.vertical:
+          child.box = PdfRect(childCrossPosition, childMainPosition,
+              child.box.width, child.box.height);
+          break;
+      }
+      if (flipMainAxis) {
+        childMainPosition -= betweenSpace;
+      } else {
+        childMainPosition += _getMainSize(child) + betweenSpace;
+      }
+    }
+  }
+
+  @override
+  void paint(Context context) {
+    super.paint(context);
+
+    final mat = Matrix4.identity();
+    mat.translate(box.x, box.y);
+    context.canvas
+      ..saveContext()
+      ..setTransform(mat);
+    for (var child in children) {
+      child.paint(context);
+    }
+    context.canvas.restoreContext();
+  }
+}
+
+class Row extends Flex {
+  Row({
+    MainAxisAlignment mainAxisAlignment = MainAxisAlignment.start,
+    MainAxisSize mainAxisSize = MainAxisSize.max,
+    CrossAxisAlignment crossAxisAlignment = CrossAxisAlignment.center,
+    VerticalDirection verticalDirection = VerticalDirection.down,
+    List<Widget> children = const <Widget>[],
+  }) : super(
+          children: children,
+          direction: Axis.horizontal,
+          mainAxisAlignment: mainAxisAlignment,
+          mainAxisSize: mainAxisSize,
+          crossAxisAlignment: crossAxisAlignment,
+          verticalDirection: verticalDirection,
+        );
+}
+
+class Column extends Flex {
+  Column({
+    MainAxisAlignment mainAxisAlignment = MainAxisAlignment.start,
+    MainAxisSize mainAxisSize = MainAxisSize.max,
+    CrossAxisAlignment crossAxisAlignment = CrossAxisAlignment.center,
+    VerticalDirection verticalDirection = VerticalDirection.down,
+    List<Widget> children = const <Widget>[],
+  }) : super(
+          children: children,
+          direction: Axis.vertical,
+          mainAxisAlignment: mainAxisAlignment,
+          mainAxisSize: mainAxisSize,
+          crossAxisAlignment: crossAxisAlignment,
+          verticalDirection: verticalDirection,
+        );
+}
+
+class Expanded extends SingleChildWidget {
+  Expanded({
+    int flex = 1,
+    @required Widget child,
+  }) : super(child: child) {
+    this._flex = flex;
+    this._fit = FlexFit.tight;
+  }
+}
+
+class ListView extends Flex {
+  ListView(
+      {Axis direction = Axis.vertical,
+      EdgeInsets padding,
+      double spacing = 0.0,
+      List<Widget> children = const []})
+      : super(
+            direction: direction,
+            mainAxisAlignment: MainAxisAlignment.start,
+            mainAxisSize: MainAxisSize.max,
+            crossAxisAlignment: CrossAxisAlignment.center,
+            verticalDirection: VerticalDirection.down,
+            children: children);
+}

+/*
+ * Copyright (C) 2017, David PHAM-VAN <dev.nfet.net@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+part of widget;
+
+@immutable
+class BoxConstraints {
+  /// The minimum width that satisfies the constraints.
+  final double minWidth;
+
+  /// The maximum width that satisfies the constraints.
+  ///
+  /// Might be [double.infinity].
+  final double maxWidth;
+
+  /// The minimum height that satisfies the constraints.
+  final double minHeight;
+
+  /// The maximum height that satisfies the constraints.
+  ///
+  /// Might be [double.infinity].
+  final double maxHeight;
+
+  /// Creates box constraints with the given constraints.
+  const BoxConstraints(
+      {this.minWidth = 0.0,
+      this.maxWidth = double.infinity,
+      this.minHeight = 0.0,
+      this.maxHeight = double.infinity});
+
+  bool get hasBoundedWidth => maxWidth < double.infinity;
+
+  bool get hasBoundedHeight => maxHeight < double.infinity;
+
+  bool get hasInfiniteWidth => minWidth >= double.infinity;
+
+  bool get hasInfiniteHeight => minHeight >= double.infinity;
+
+  /// The biggest size that satisfies the constraints.
+  PdfPoint get biggest => PdfPoint(constrainWidth(), constrainHeight());
+
+  /// The smallest size that satisfies the constraints.
+  PdfPoint get smallest => PdfPoint(constrainWidth(0.0), constrainHeight(0.0));
+
+  /// Whether there is exactly one width value that satisfies the constraints.
+  bool get hasTightWidth => minWidth >= maxWidth;
+
+  /// Whether there is exactly one height value that satisfies the constraints.
+  bool get hasTightHeight => minHeight >= maxHeight;
+
+  /// Whether there is exactly one size that satisfies the constraints.
+  bool get isTight => hasTightWidth && hasTightHeight;
+
+  PdfPoint constrain(PdfPoint size) {
+    final result = PdfPoint(constrainWidth(size.x), constrainHeight(size.y));
+    return result;
+  }
+
+  PdfRect constrainRect(
+      {double width = double.infinity, double height = double.infinity}) {
+    final result = PdfPoint(constrainWidth(width), constrainHeight(height));
+    return PdfRect.fromPoints(PdfPoint.zero, result);
+  }
+
+  double constrainWidth([double width = double.infinity]) {
+    return width.clamp(minWidth, maxWidth);
+  }
+
+  double constrainHeight([double height = double.infinity]) {
+    return height.clamp(minHeight, maxHeight);
+  }
+
+  /// Returns a size that attempts to meet the conditions
+  PdfPoint constrainSizeAndAttemptToPreserveAspectRatio(PdfPoint size) {
+    if (isTight) {
+      PdfPoint result = smallest;
+
+      return result;
+    }
+
+    double width = size.x;
+    double height = size.y;
+    assert(width > 0.0);
+    assert(height > 0.0);
+    final double aspectRatio = width / height;
+
+    if (width > maxWidth) {
+      width = maxWidth;
+      height = width / aspectRatio;
+    }
+
+    if (height > maxHeight) {
+      height = maxHeight;
+      width = height * aspectRatio;
+    }
+
+    if (width < minWidth) {
+      width = minWidth;
+      height = width / aspectRatio;
+    }
+
+    if (height < minHeight) {
+      height = minHeight;
+      width = height * aspectRatio;
+    }
+
+    PdfPoint result = PdfPoint(constrainWidth(width), constrainHeight(height));
+    return result;
+  }
+
+  /// Returns new box constraints with a tight width and/or height as close to
+  /// the given width and height as possible while still respecting the original
+  /// box constraints.
+  BoxConstraints tighten({double width, double height}) {
+    return BoxConstraints(
+        minWidth: width == null ? minWidth : width.clamp(minWidth, maxWidth),
+        maxWidth: width == null ? maxWidth : width.clamp(minWidth, maxWidth),
+        minHeight:
+            height == null ? minHeight : height.clamp(minHeight, maxHeight),
+        maxHeight:
+            height == null ? maxHeight : height.clamp(minHeight, maxHeight));
+  }
+
+  /// Creates box constraints that require the given width or height.
+  const BoxConstraints.tightFor({double width, double height})
+      : minWidth = width != null ? width : 0.0,
+        maxWidth = width != null ? width : double.infinity,
+        minHeight = height != null ? height : 0.0,
+        maxHeight = height != null ? height : double.infinity;
+
+  /// Creates box constraints that expand to fill another box constraints.
+  const BoxConstraints.expand({double width, double height})
+      : minWidth = width != null ? width : double.infinity,
+        maxWidth = width != null ? width : double.infinity,
+        minHeight = height != null ? height : double.infinity,
+        maxHeight = height != null ? height : double.infinity;
+
+  /// Returns new box constraints that are smaller by the given edge dimensions.
+  BoxConstraints deflate(EdgeInsets edges) {
+    assert(edges != null);
+    final double horizontal = edges.horizontal;
+    final double vertical = edges.vertical;
+    final double deflatedMinWidth = math.max(0.0, minWidth - horizontal);
+    final double deflatedMinHeight = math.max(0.0, minHeight - vertical);
+    return BoxConstraints(
+        minWidth: deflatedMinWidth,
+        maxWidth: math.max(deflatedMinWidth, maxWidth - horizontal),
+        minHeight: deflatedMinHeight,
+        maxHeight: math.max(deflatedMinHeight, maxHeight - vertical));
+  }
+
+  /// Returns new box constraints that remove the minimum width and height requirements.
+  BoxConstraints loosen() {
+    return BoxConstraints(
+        minWidth: 0.0,
+        maxWidth: maxWidth,
+        minHeight: 0.0,
+        maxHeight: maxHeight);
+  }
+
+  /// Returns new box constraints that respect the given constraints while being
+  /// as close as possible to the original constraints.
+  BoxConstraints enforce(BoxConstraints constraints) {
+    return BoxConstraints(
+        minWidth: minWidth.clamp(constraints.minWidth, constraints.maxWidth),
+        maxWidth: maxWidth.clamp(constraints.minWidth, constraints.maxWidth),
+        minHeight:
+            minHeight.clamp(constraints.minHeight, constraints.maxHeight),
+        maxHeight:
+            maxHeight.clamp(constraints.minHeight, constraints.maxHeight));
+  }
+
+  BoxConstraints copyWith(
+      {double minWidth, double maxWidth, double minHeight, double maxHeight}) {
+    return BoxConstraints(
+        minWidth: minWidth ?? this.minWidth,
+        maxWidth: maxWidth ?? this.maxWidth,
+        minHeight: minHeight ?? this.minHeight,
+        maxHeight: maxHeight ?? this.maxHeight);
+  }
+
+  @override
+  String toString() {
+    return "BoxConstraint <$minWidth, $maxWidth> <$minHeight, $maxHeight>";
+  }
+}
+
+@immutable
+class EdgeInsets {
+  const EdgeInsets.fromLTRB(this.left, this.top, this.right, this.bottom);
+
+  const EdgeInsets.all(double value)
+      : left = value,
+        top = value,
+        right = value,
+        bottom = value;
+
+  const EdgeInsets.only(
+      {this.left = 0.0, this.top = 0.0, this.right = 0.0, this.bottom = 0.0});
+
+  const EdgeInsets.symmetric({double vertical = 0.0, double horizontal = 0.0})
+      : left = horizontal,
+        top = vertical,
+        right = horizontal,
+        bottom = vertical;
+
+  static const EdgeInsets zero = EdgeInsets.only();
+
+  final double left;
+
+  final double top;
+
+  final double right;
+
+  final double bottom;
+
+  /// The total offset in the horizontal direction.
+  double get horizontal => left + right;
+
+  /// The total offset in the vertical direction.
+  double get vertical => top + bottom;
+
+  EdgeInsets copyWith({
+    double left,
+    double top,
+    double right,
+    double bottom,
+  }) {
+    return EdgeInsets.only(
+      left: left ?? this.left,
+      top: top ?? this.top,
+      right: right ?? this.right,
+      bottom: bottom ?? this.bottom,
+    );
+  }
+
+  /// Returns the sum of two [EdgeInsets] objects.
+  EdgeInsets add(EdgeInsets other) {
+    return EdgeInsets.fromLTRB(
+      left + other.left,
+      top + other.top,
+      right + other.right,
+      bottom + other.bottom,
+    );
+  }
+}
+
+class Alignment {
+  const Alignment(this.x, this.y)
+      : assert(x != null),
+        assert(y != null);
+
+  /// The distance fraction in the horizontal direction.
+  final double x;
+
+  /// The distance fraction in the vertical direction.
+  final double y;
+
+  /// The top left corner.
+  static const Alignment topLeft = Alignment(-1.0, 1.0);
+
+  /// The center point along the top edge.
+  static const Alignment topCenter = Alignment(0.0, 1.0);
+
+  /// The top right corner.
+  static const Alignment topRight = Alignment(1.0, 1.0);
+
+  /// The center point along the left edge.
+  static const Alignment centerLeft = Alignment(-1.0, 0.0);
+
+  /// The center point, both horizontally and vertically.
+  static const Alignment center = Alignment(0.0, 0.0);
+
+  /// The center point along the right edge.
+  static const Alignment centerRight = Alignment(1.0, 0.0);
+
+  /// The bottom left corner.
+  static const Alignment bottomLeft = Alignment(-1.0, -1.0);
+
+  /// The center point along the bottom edge.
+  static const Alignment bottomCenter = Alignment(0.0, -1.0);
+
+  /// The bottom right corner.
+  static const Alignment bottomRight = Alignment(1.0, -1.0);
+
+  /// Returns the offset that is this fraction within the given size.
+  PdfPoint alongSize(PdfPoint other) {
+    final double centerX = other.x / 2.0;
+    final double centerY = other.y / 2.0;
+    return PdfPoint(centerX + x * centerX, centerY + y * centerY);
+  }
+
+  /// Returns the point that is this fraction within the given rect.
+  PdfPoint withinRect(PdfRect rect) {
+    final double halfWidth = rect.width / 2.0;
+    final double halfHeight = rect.height / 2.0;
+    return PdfPoint(
+      rect.left + halfWidth + x * halfWidth,
+      rect.top + halfHeight + y * halfHeight,
+    );
+  }
+
+  /// Returns a rect of the given size, aligned within given rect as specified
+  /// by this alignment.
+  PdfRect inscribe(PdfPoint size, PdfRect rect) {
+    final double halfWidthDelta = (rect.width - size.x) / 2.0;
+    final double halfHeightDelta = (rect.height - size.y) / 2.0;
+    return PdfRect(
+      rect.x + halfWidthDelta + x * halfWidthDelta,
+      rect.y + halfHeightDelta + y * halfHeightDelta,
+      size.x,
+      size.y,
+    );
+  }
+
+  @override
+  String toString() => "($x, $y)";
+}
+
+/// The pair of sizes returned by [applyBoxFit].
+@immutable
+class FittedSizes {
+  const FittedSizes(this.source, this.destination);
+
+  /// The size of the part of the input to show on the output.
+  final PdfPoint source;
+
+  /// The size of the part of the output on which to show the input.
+  final PdfPoint destination;
+}
+
+FittedSizes applyBoxFit(BoxFit fit, PdfPoint inputSize, PdfPoint outputSize) {
+  if (inputSize.y <= 0.0 ||
+      inputSize.x <= 0.0 ||
+      outputSize.y <= 0.0 ||
+      outputSize.x <= 0.0)
+    return const FittedSizes(PdfPoint.zero, PdfPoint.zero);
+
+  PdfPoint sourceSize, destinationSize;
+  switch (fit) {
+    case BoxFit.fill:
+      sourceSize = inputSize;
+      destinationSize = outputSize;
+      break;
+    case BoxFit.contain:
+      sourceSize = inputSize;
+      if (outputSize.x / outputSize.y > sourceSize.x / sourceSize.y)
+        destinationSize =
+            PdfPoint(sourceSize.x * outputSize.y / sourceSize.y, outputSize.y);
+      else
+        destinationSize =
+            PdfPoint(outputSize.x, sourceSize.y * outputSize.x / sourceSize.x);
+      break;
+    case BoxFit.cover:
+      if (outputSize.x / outputSize.y > inputSize.x / inputSize.y) {
+        sourceSize =
+            PdfPoint(inputSize.x, inputSize.x * outputSize.y / outputSize.x);
+      } else {
+        sourceSize =
+            PdfPoint(inputSize.y * outputSize.x / outputSize.y, inputSize.y);
+      }
+      destinationSize = outputSize;
+      break;
+    case BoxFit.fitWidth:
+      sourceSize =
+          PdfPoint(inputSize.x, inputSize.x * outputSize.y / outputSize.x);
+      destinationSize =
+          PdfPoint(outputSize.x, sourceSize.y * outputSize.x / sourceSize.x);
+      break;
+    case BoxFit.fitHeight:
+      sourceSize =
+          PdfPoint(inputSize.y * outputSize.x / outputSize.y, inputSize.y);
+      destinationSize =
+          PdfPoint(sourceSize.x * outputSize.y / sourceSize.y, outputSize.y);
+      break;
+    case BoxFit.none:
+      sourceSize = PdfPoint(math.min(inputSize.x, outputSize.x),
+          math.min(inputSize.y, outputSize.y));
+      destinationSize = sourceSize;
+      break;
+    case BoxFit.scaleDown:
+      sourceSize = inputSize;
+      destinationSize = inputSize;
+      final double aspectRatio = inputSize.x / inputSize.y;
+      if (destinationSize.y > outputSize.y)
+        destinationSize = PdfPoint(outputSize.y * aspectRatio, outputSize.y);
+      if (destinationSize.x > outputSize.x)
+        destinationSize = PdfPoint(outputSize.x, outputSize.x / aspectRatio);
+      break;
+  }
+  return FittedSizes(sourceSize, destinationSize);
+}
+
+PdfPoint transformPoint(Matrix4 transform, PdfPoint point) {
+  final Vector3 position3 = Vector3(point.x, point.y, 0.0);
+  final Vector3 transformed3 = transform.perspectiveTransform(position3);
+  return PdfPoint(transformed3.x, transformed3.y);
+}
+
+PdfRect transformRect(Matrix4 transform, PdfRect rect) {
+  final point1 = transformPoint(transform, rect.topLeft);
+  final point2 = transformPoint(transform, rect.topRight);
+  final point3 = transformPoint(transform, rect.bottomLeft);
+  final point4 = transformPoint(transform, rect.bottomRight);
+  return PdfRect.fromLTRB(
+      math.min(point1.x, math.min(point2.x, math.min(point3.x, point4.x))),
+      math.min(point1.y, math.min(point2.y, math.min(point3.y, point4.y))),
+      math.max(point1.x, math.max(point2.x, math.max(point3.x, point4.x))),
+      math.max(point1.y, math.max(point2.y, math.max(point3.y, point4.y))));
+}

+/*
+ * Copyright (C) 2017, David PHAM-VAN <dev.nfet.net@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+part of widget;
+
+class GridView extends MultiChildWidget {
+  GridView(
+      {this.direction = Axis.vertical,
+      this.padding = EdgeInsets.zero,
+      @required this.crossAxisCount,
+      this.mainAxisSpacing = 0.0,
+      this.crossAxisSpacing = 0.0,
+      this.childAspectRatio = double.infinity,
+      List<Widget> children = const []})
+      : assert(padding != null),
+        super(children: children);
+
+  final Axis direction;
+  final EdgeInsets padding;
+  final int crossAxisCount;
+  final double mainAxisSpacing;
+  final double crossAxisSpacing;
+  final double childAspectRatio;
+
+  double _childCrossAxis;
+  double _childMainAxis;
+  double _totalMain;
+  double _totalCross;
+  int _mainAxisCount;
+
+  @override
+  void layout(Context context, BoxConstraints constraints,
+      {parentUsesSize = false}) {
+    double mainAxisExtent;
+    double crossAxisExtent;
+    switch (direction) {
+      case Axis.vertical:
+        mainAxisExtent = constraints.maxHeight - padding.vertical;
+        crossAxisExtent = constraints.maxWidth - padding.horizontal;
+        break;
+      case Axis.horizontal:
+        mainAxisExtent = constraints.maxWidth - padding.horizontal;
+        crossAxisExtent = constraints.maxHeight - padding.vertical;
+        break;
+    }
+
+    _mainAxisCount = (children.length / crossAxisCount).ceil();
+    _childCrossAxis = crossAxisExtent / crossAxisCount -
+        (crossAxisSpacing * (crossAxisCount - 1) / crossAxisCount);
+    _childMainAxis = math.min(
+        _childCrossAxis * childAspectRatio,
+        mainAxisExtent / _mainAxisCount -
+            (mainAxisSpacing * (_mainAxisCount - 1) / _mainAxisCount));
+    _totalMain =
+        (_childMainAxis + mainAxisSpacing) * _mainAxisCount - mainAxisSpacing;
+    _totalCross = (_childCrossAxis + crossAxisSpacing) * crossAxisCount -
+        crossAxisSpacing;
+
+    var startX = padding.left;
+    var startY = 0.0;
+    var mainAxis;
+    var crossAxis;
+    BoxConstraints innerConstraints;
+    switch (direction) {
+      case Axis.vertical:
+        innerConstraints = BoxConstraints.tightFor(
+            width: _childCrossAxis, height: _childMainAxis);
+        crossAxis = startX;
+        mainAxis = startY;
+        break;
+      case Axis.horizontal:
+        innerConstraints = BoxConstraints.tightFor(
+            width: _childMainAxis, height: _childCrossAxis);
+        mainAxis = startX;
+        crossAxis = startY;
+        break;
+    }
+
+    var c = 0;
+    for (var child in children) {
+      child.layout(context, innerConstraints);
+
+      switch (direction) {
+        case Axis.vertical:
+          child.box = PdfRect.fromPoints(
+              PdfPoint(
+                  (_childCrossAxis - child.box.width) / 2.0 + crossAxis,
+                  _totalMain +
+                      padding.bottom -
+                      (_childMainAxis - child.box.height) / 2.0 -
+                      mainAxis -
+                      child.box.height),
+              child.box.size);
+          break;
+        case Axis.horizontal:
+          child.box = PdfRect.fromPoints(
+              PdfPoint(
+                  (_childMainAxis - child.box.width) / 2.0 + mainAxis,
+                  _totalCross +
+                      padding.bottom -
+                      (_childCrossAxis - child.box.height) / 2.0 -
+                      crossAxis -
+                      child.box.height),
+              child.box.size);
+          break;
+      }
+
+      if (++c >= crossAxisCount) {
+        mainAxis += _childMainAxis + mainAxisSpacing;
+        crossAxis = startX;
+        c = 0;
+      } else {
+        crossAxis += _childCrossAxis + crossAxisSpacing;
+      }
+    }
+
+    switch (direction) {
+      case Axis.vertical:
+        box = constraints.constrainRect(
+            width: _totalCross + padding.horizontal,
+            height: _totalMain + padding.vertical);
+        break;
+      case Axis.horizontal:
+        box = constraints.constrainRect(
+            width: _totalMain + padding.horizontal,
+            height: _totalCross + padding.vertical);
+        break;
+    }
+  }
+
+  @override
+  void debugPaint(Context context) {
+    super.debugPaint(context);
+
+    context.canvas
+      ..setFillColor(PdfColor.lime)
+      ..moveTo(box.left, box.bottom)
+      ..lineTo(box.right, box.bottom)
+      ..lineTo(box.right, box.top)
+      ..lineTo(box.left, box.top)
+      ..moveTo(box.left + padding.left, box.bottom + padding.bottom)
+      ..lineTo(box.left + padding.left, box.top - padding.top)
+      ..lineTo(box.right - padding.right, box.top - padding.top)
+      ..lineTo(box.right - padding.right, box.bottom + padding.bottom)
+      ..fillPath();
+
+    for (var c = 1; c < crossAxisCount; c++) {
+      switch (direction) {
+        case Axis.vertical:
+          context.canvas
+            ..drawRect(
+                box.left +
+                    padding.left +
+                    (_childCrossAxis + crossAxisSpacing) * c -
+                    crossAxisSpacing,
+                box.bottom + padding.bottom,
+                math.max(crossAxisSpacing, 1.0),
+                box.height - padding.vertical)
+            ..fillPath();
+          break;
+        case Axis.horizontal:
+          break;
+      }
+    }
+
+    for (var c = 1; c < _mainAxisCount; c++) {
+      switch (direction) {
+        case Axis.vertical:
+          context.canvas
+            ..drawRect(
+                box.left + padding.left,
+                box.bottom +
+                    padding.bottom +
+                    (_childMainAxis + mainAxisSpacing) * c -
+                    mainAxisSpacing,
+                box.width - padding.horizontal,
+                math.max(mainAxisSpacing, 1.0))
+            ..fillPath();
+          break;
+        case Axis.horizontal:
+          break;
+      }
+    }
+  }
+
+  @override
+  void paint(Context context) {
+    super.paint(context);
+
+    final mat = Matrix4.identity();
+    mat.translate(box.x, box.y);
+    context.canvas
+      ..saveContext()
+      ..setTransform(mat);
+    for (var child in children) {
+      child.paint(context);
+    }
+    context.canvas.restoreContext();
+  }
+}

+/*
+ * Copyright (C) 2017, David PHAM-VAN <dev.nfet.net@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+part of widget;
+
+class Image extends Widget {
+  final PdfImage image;
+  final double aspectRatio;
+  final BoxFit fit;
+
+  Image(this.image, {this.fit = BoxFit.contain})
+      : assert(image != null),
+        aspectRatio = (image.height.toDouble() / image.width.toDouble());
+
+  @override
+  void layout(Context context, BoxConstraints constraints,
+      {parentUsesSize = false}) {
+    final w = constraints.hasBoundedWidth
+        ? constraints.maxWidth
+        : constraints.constrainWidth(image.width.toDouble());
+    final h = constraints.hasBoundedHeight
+        ? constraints.maxHeight
+        : constraints.constrainHeight(image.height.toDouble());
+
+    final FittedSizes sizes = applyBoxFit(
+        fit,
+        PdfPoint(image.width.toDouble(), image.height.toDouble()),
+        PdfPoint(w, h));
+    box = PdfRect.fromPoints(PdfPoint.zero, sizes.destination);
+  }
+
+  @override
+  void paint(Context context) {
+    super.paint(context);
+
+    context.canvas.drawImage(image, box.x, box.y, box.width, box.height);
+  }
+}
+
+class Shape extends Widget {
+  final String shape;
+  final PdfColor strokeColor;
+  final PdfColor fillColor;
+  final double width;
+  final double height;
+  final double aspectRatio;
+  final BoxFit fit;
+
+  Shape(
+    this.shape, {
+    this.strokeColor,
+    this.fillColor,
+    this.width = 1.0,
+    this.height = 1.0,
+    this.fit = BoxFit.contain,
+  })  : assert(width != null && width > 0.0),
+        assert(height != null && height > 0.0),
+        aspectRatio = height / width;
+
+  @override
+  void layout(Context context, BoxConstraints constraints,
+      {parentUsesSize = false}) {
+    final w = constraints.hasBoundedWidth
+        ? constraints.maxWidth
+        : constraints.constrainWidth(width);
+    final h = constraints.hasBoundedHeight
+        ? constraints.maxHeight
+        : constraints.constrainHeight(height);
+
+    final FittedSizes sizes =
+        applyBoxFit(fit, PdfPoint(width, height), PdfPoint(w, h));
+    box = PdfRect.fromPoints(PdfPoint.zero, sizes.destination);
+  }
+
+  @override
+  void paint(Context context) {
+    super.paint(context);
+
+    final mat = Matrix4.identity();
+    mat.translate(box.x, box.y + box.height);
+    mat.scale(box.width / width, -box.height / height);
+    context.canvas
+      ..saveContext()
+      ..setTransform(mat);
+
+    if (fillColor != null) {
+      context.canvas
+        ..setFillColor(fillColor)
+        ..drawShape(shape, stroke: false)
+        ..fillPath();
+    }
+
+    if (strokeColor != null) {
+      context.canvas
+        ..setStrokeColor(strokeColor)
+        ..drawShape(shape, stroke: true);
+    }
+
+    context.canvas.restoreContext();
+  }
+}

+/*
+ * Copyright (C) 2017, David PHAM-VAN <dev.nfet.net@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+part of widget;
+
+class Placeholder extends Widget {
+  final PdfColor color;
+  final double strokeWidth;
+  final double fallbackWidth;
+  final double fallbackHeight;
+
+  Placeholder(
+      {this.color = const PdfColor.fromInt(0xFF455A64),
+      this.strokeWidth = 2.0,
+      this.fallbackWidth = 400.0,
+      this.fallbackHeight = 400.0});
+
+  @override
+  void layout(Context context, BoxConstraints constraints,
+      {parentUsesSize = false}) {
+    box = PdfRect(
+        0.0,
+        0.0,
+        constraints.constrainWidth(
+            constraints.hasBoundedWidth ? constraints.maxWidth : fallbackWidth),
+        constraints.constrainHeight(constraints.hasBoundedHeight
+            ? constraints.maxHeight
+            : fallbackHeight));
+  }
+
+  @protected
+  void paint(Context context) {
+    super.paint(context);
+
+    context.canvas
+      ..setStrokeColor(color)
+      ..moveTo(box.x, box.y)
+      ..lineTo(box.right, box.top)
+      ..moveTo(box.x, box.top)
+      ..lineTo(box.right, box.y)
+      ..drawRect(box.x, box.y, box.width, box.height)
+      ..setLineWidth(strokeWidth)
+      ..strokePath();
+  }
+}
+
+class PdfLogo extends StatelessWidget {
+  PdfLogo({this.color = PdfColor.red, this.fit = BoxFit.contain});
+
+  final PdfColor color;
+  final BoxFit fit;
+
+  static const pdf =
+      "M 2.424 26.712 L 2.424 26.712 C 2.076 26.712 1.742 26.599 1.457 26.386 C 0.416 25.605 0.276 24.736 0.342 24.144 C 0.524 22.516 2.537 20.812 6.327 19.076 C 7.831 15.78 9.262 11.719 10.115 8.326 C 9.117 6.154 8.147 3.336 8.854 1.683 C 9.102 1.104 9.411 0.66 9.988 0.468 C 10.216 0.392 10.792 0.296 11.004 0.296 C 11.508 0.296 11.951 0.945 12.265 1.345 C 12.56 1.721 13.229 2.518 11.892 8.147 C 13.24 10.931 15.15 13.767 16.98 15.709 C 18.291 15.472 19.419 15.351 20.338 15.351 C 21.904 15.351 22.853 15.716 23.24 16.468 C 23.56 17.09 23.429 17.817 22.85 18.628 C 22.293 19.407 21.525 19.819 20.63 19.819 C 19.414 19.819 17.998 19.051 16.419 17.534 C 13.582 18.127 10.269 19.185 7.591 20.356 C 6.755 22.13 5.954 23.559 5.208 24.607 C 4.183 26.042 3.299 26.712 2.424 26.712 Z M 5.086 21.586 C 2.949 22.787 2.078 23.774 2.015 24.33 C 2.005 24.422 1.978 24.664 2.446 25.022 C 2.595 24.975 3.465 24.578 5.086 21.586 Z M 18.723 17.144 C 19.538 17.771 19.737 18.088 20.27 18.088 C 20.504 18.088 21.171 18.078 21.48 17.647 C 21.629 17.438 21.687 17.304 21.71 17.232 C 21.587 17.167 21.424 17.035 20.535 17.035 C 20.03 17.036 19.395 17.058 18.723 17.144 Z M 11.253 10.562 C 10.538 13.036 9.594 15.707 8.579 18.126 C 10.669 17.315 12.941 16.607 15.075 16.106 C 13.725 14.538 12.376 12.58 11.253 10.562 Z M 10.646 2.1 C 10.548 2.133 9.316 3.857 10.742 5.316 C 11.691 3.201 10.689 2.086 10.646 2.1 Z";
+
+  @override
+  Widget build(Context context) {
+    return Shape(pdf, width: 24.0, height: 27.0, fillColor: color, fit: fit);
+  }
+}
+
+class FlutterLogo extends PdfLogo {}
+
+class LoremText {
+  LoremText({math.Random random}) : random = random ?? math.Random(978);
+
+  final math.Random random;
+
+  static final words =
+      "ad adipiscing aliqua aliquip amet anim aute cillum commodo consectetur consequat culpa cupidatat deserunt do dolor dolore duis ea eiusmod elit enim esse est et eu ex excepteur exercitation fugiat id in incididunt ipsum irure labore laboris laborum lorem magna minim mollit nisi non nostrud nulla occaecat officia pariatur proident qui quis reprehenderit sed sint sit sunt tempor ullamco ut velit veniam voluptate"
+          .split(" ");
+
+  String word() {
+    return words[random.nextInt(words.length - 1)];
+  }
+
+  String sentence(int length) {
+    final wordList = List<String>();
+    for (var i = 0; i < length; i++) {
+      var w = word();
+      if (i < length - 1 && random.nextInt(10) == 0) w += ",";
+      wordList.add(w);
+    }
+    var text = wordList.join(" ") + ".";
+    return text[0].toUpperCase() + text.substring(1);
+  }
+
+  String paragraph(int length) {
+    var wordsCount = 0;
+    final sentenceList = List<String>();
+    var n = 0;
+    while (wordsCount < length) {
+      n++;
+      if (n > 100) break;
+      var count = math.min(length,
+          math.max(10, math.min(3, random.nextInt(length - wordsCount))));
+      sentenceList.add(sentence(count));
+      wordsCount += count;
+    }
+    return sentenceList.join(" ");
+  }
+}
+
+class Lorem extends StatelessWidget {
+  Lorem(
+      {this.length = 50,
+      this.random,
+      this.style,
+      this.textAlign = TextAlign.left,
+      this.softWrap = true,
+      this.textScaleFactor = 1.0,
+      this.maxLines});
+
+  final int length;
+  final math.Random random;
+  final TextStyle style;
+  final TextAlign textAlign;
+  final bool softWrap;
+  final double textScaleFactor;
+  final int maxLines;
+
+  @override
+  Widget build(Context context) {
+    final lorem = LoremText(random: random);
+    final text = lorem.paragraph(length);
+
+    return Text(text,
+        style: style,
+        textAlign: textAlign,
+        softWrap: softWrap,
+        textScaleFactor: textScaleFactor,
+        maxLines: maxLines);
+  }
+}

+/*
+ * Copyright (C) 2017, David PHAM-VAN <dev.nfet.net@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+part of widget;
+
+/// A horizontal group of cells in a [Table].
+@immutable
+class TableRow {
+  const TableRow({this.children, this.repeat = false});
+
+  /// The widgets that comprise the cells in this row.
+  final List<Widget> children;
+
+  /// Repeat this row on all pages
+  final bool repeat;
+}
+
+enum TableCellVerticalAlignment { bottom, middle, top }
+
+enum TableWidth { min, max }
+
+class TableBorder extends BoxBorder {
+  const TableBorder(
+      {bool left = true,
+      bool top = true,
+      bool right = true,
+      bool bottom = true,
+      this.horizontalInside = true,
+      this.verticalInside = true,
+      PdfColor color = PdfColor.black,
+      double width = 1.0})
+      : super(
+            left: left,
+            top: top,
+            right: right,
+            bottom: bottom,
+            color: color,
+            width: width);
+
+  final bool horizontalInside;
+  final bool verticalInside;
+
+  @override
+  void paintBorders(Context context, PdfRect box,
+      [List<double> widths, List<double> heights]) {
+    super.paintBorders(context, box);
+
+    if (verticalInside) {
+      var offset = box.x;
+      for (var width in widths.sublist(0, widths.length - 1)) {
+        offset += width;
+        context.canvas.moveTo(offset, box.y);
+        context.canvas.lineTo(offset, box.top);
+      }
+      context.canvas.strokePath();
+    }
+
+    if (horizontalInside) {
+      var offset = box.top;
+      for (var height in heights.sublist(0, heights.length - 1)) {
+        offset -= height;
+        context.canvas.moveTo(box.x, offset);
+        context.canvas.lineTo(box.right, offset);
+      }
+      context.canvas.strokePath();
+    }
+  }
+}
+
+class _TableContext extends WidgetContext {
+  var firstLine = 0;
+  var lastLine = 0;
+}
+
+/// A widget that uses the table layout algorithm for its children.
+class Table extends Widget implements SpanningWidget {
+  Table(
+      {this.children = const <TableRow>[],
+      this.border,
+      this.defaultVerticalAlignment = TableCellVerticalAlignment.top,
+      this.tableWidth = TableWidth.max})
+      : assert(children != null),
+        super();
+
+  @override
+  bool get canSpan => true;
+
+  /// The rows of the table.
+  final List<TableRow> children;
+
+  final TableBorder border;
+
+  final TableCellVerticalAlignment defaultVerticalAlignment;
+
+  final TableWidth tableWidth;
+
+  final _widths = List<double>();
+  final _heights = List<double>();
+
+  var _context = _TableContext();
+
+  @override
+  WidgetContext saveContext() {
+    return _context;
+  }
+
+  @override
+  void restoreContext(WidgetContext context) {
+    _context = context;
+    _context.firstLine = _context.lastLine;
+  }
+
+  @override
+  void layout(Context context, BoxConstraints constraints,
+      {parentUsesSize = false}) {
+    // Compute required width for all row/columns width flex
+    final flex = List<double>();
+    _widths.clear();
+    _heights.clear();
+    var index = 0;
+
+    for (var row in children) {
+      var n = 0;
+      for (var child in row.children) {
+        child.layout(context, BoxConstraints());
+        final calculatedWidth =
+            child.box.width == double.infinity ? 0.0 : child.box.width;
+        final childFlex = child._flex.toDouble();
+        if (flex.length < n + 1) {
+          flex.add(childFlex);
+          _widths.add(calculatedWidth);
+        } else {
+          if (childFlex > 0) {
+            flex[n] *= childFlex;
+          }
+          _widths[n] = math.max(_widths[n], calculatedWidth);
+        }
+        n++;
+      }
+    }
+
+    final maxWidth = _widths.reduce((a, b) => a + b);
+
+    // Compute column widths using flex and estimated width
+    if (constraints.hasBoundedWidth) {
+      final totalFlex = flex.reduce((a, b) => a + b);
+      var flexSpace = 0.0;
+      for (var n = 0; n < _widths.length; n++) {
+        if (flex[n] == 0.0) {
+          var newWidth = _widths[n] / maxWidth * constraints.maxWidth;
+          if ((tableWidth == TableWidth.max && totalFlex == 0.0) ||
+              newWidth < _widths[n]) {
+            _widths[n] = newWidth;
+          }
+          flexSpace += _widths[n];
+        }
+      }
+      final spacePerFlex = totalFlex > 0.0
+          ? ((constraints.maxWidth - flexSpace) / totalFlex)
+          : double.nan;
+
+      for (var n = 0; n < _widths.length; n++) {
+        if (flex[n] > 0.0) {
+          var newWidth = spacePerFlex * flex[n];
+          _widths[n] = newWidth;
+        }
+      }
+    }
+
+    final totalWidth = _widths.reduce((a, b) => a + b);
+
+    // Compute final widths
+    var totalHeight = 0.0;
+    index = 0;
+    for (var row in children) {
+      if (index++ < _context.firstLine && !row.repeat) continue;
+
+      var n = 0;
+      var x = 0.0;
+
+      var lineHeight = 0.0;
+      for (var child in row.children) {
+        final childConstraints = BoxConstraints.tightFor(width: _widths[n]);
+        child.layout(context, childConstraints);
+        child.box = PdfRect(x, totalHeight, child.box.width, child.box.height);
+        x += _widths[n];
+        lineHeight = math.max(lineHeight, child.box.height);
+        n++;
+      }
+
+      if (totalHeight + lineHeight > constraints.maxHeight) {
+        index--;
+        break;
+      }
+      totalHeight += lineHeight;
+      _heights.add(lineHeight);
+    }
+    _context.lastLine = index;
+
+    // Compute final y position
+    index = 0;
+    for (var row in children) {
+      if (index++ < _context.firstLine && !row.repeat) continue;
+
+      for (var child in row.children) {
+        child.box = PdfRect(
+            child.box.x,
+            totalHeight - child.box.y - child.box.height,
+            child.box.width,
+            child.box.height);
+      }
+
+      if (index >= _context.lastLine) break;
+    }
+
+    box = PdfRect(0.0, 0.0, totalWidth, totalHeight);
+  }
+
+  @override
+  void paint(Context context) {
+    super.paint(context);
+
+    final mat = Matrix4.identity();
+    mat.translate(box.x, box.y);
+    context.canvas
+      ..saveContext()
+      ..setTransform(mat);
+
+    var index = 0;
+    for (var row in children) {
+      if (index++ < _context.firstLine && !row.repeat) continue;
+      for (var child in row.children) {
+        child.paint(context);
+      }
+      if (index >= _context.lastLine) break;
+    }
+    context.canvas.restoreContext();
+
+    if (border != null) {
+      border.paintBorders(context, box, _widths, _heights);
+    }
+  }
+
+  factory Table.fromTextArray(
+      {@required Context context, @required List<List<String>> data}) {
+    final rows = List<TableRow>();
+    for (var row in data) {
+      final tableRow = List<Widget>();
+      if (row == data.first) {
+        for (var cell in row) {
+          tableRow.add(Container(
+              alignment: Alignment.center,
+              margin: EdgeInsets.all(5),
+              child: Text(cell, style: Theme.of(context).tableHeader)));
+        }
+      } else {
+        for (var cell in row) {
+          tableRow.add(Container(
+              margin: EdgeInsets.all(5),
+              child: Text(cell, style: Theme.of(context).tableCell)));
+        }
+      }
+      rows.add(TableRow(children: tableRow, repeat: row == data.first));
+    }
+    return Table(
+        border: TableBorder(), tableWidth: TableWidth.max, children: rows);
+  }
+}

+/*
+ * Copyright (C) 2017, David PHAM-VAN <dev.nfet.net@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+part of widget;
+
+@immutable
+class TextStyle {
+  const TextStyle({
+    this.color = PdfColor.black,
+    this.font,
+    this.fontSize = _defaultFontSize,
+    this.letterSpacing = 1.0,
+    this.wordSpacing = 1.0,
+    this.lineSpacing = 0.0,
+    this.height = 1.0,
+    this.background,
+  })  : assert(font != null),
+        assert(color != null);
+
+  final PdfColor color;
+
+  final PdfFont font;
+
+  final double fontSize;
+
+  static const double _defaultFontSize = 12.0 * PdfPageFormat.point;
+
+  final double letterSpacing;
+
+  final double lineSpacing;
+
+  final double wordSpacing;
+
+  final double height;
+
+  final PdfColor background;
+
+  TextStyle copyWith({
+    PdfColor color,
+    PdfFont font,
+    double fontSize,
+    double letterSpacing,
+    double wordSpacing,
+    double lineSpacing,
+    double height,
+    PdfColor background,
+  }) {
+    return TextStyle(
+      color: color ?? this.color,
+      font: font ?? this.font,
+      fontSize: fontSize ?? this.fontSize,
+      letterSpacing: letterSpacing ?? this.letterSpacing,
+      wordSpacing: wordSpacing ?? this.wordSpacing,
+      lineSpacing: lineSpacing ?? this.lineSpacing,
+      height: height ?? this.height,
+      background: background ?? this.background,
+    );
+  }
+}
+
+enum TextAlign { left, right, center, justify }
+
+class _Word {
+  final String text;
+  PdfRect _box;
+
+  _Word(this.text, this._box);
+
+  String toString() {
+    return "Word $text $_box";
+  }
+}
+
+class Text extends Widget {
+  final String data;
+
+  TextStyle style;
+
+  final TextAlign textAlign;
+
+  final double textScaleFactor;
+
+  final int maxLines;
+
+  Text(
+    this.data, {
+    this.style,
+    this.textAlign = TextAlign.left,
+    softWrap = true,
+    this.textScaleFactor = 1.0,
+    int maxLines,
+  })  : maxLines = !softWrap ? 1 : maxLines,
+        assert(data != null);
+
+  final _words = List<_Word>();
+
+  double _realignLine(
+      List<_Word> words, double totalWidth, double wordsWidth, bool last) {
+    var delta = 0.0;
+    switch (textAlign) {
+      case TextAlign.left:
+        return wordsWidth;
+      case TextAlign.right:
+        delta = totalWidth - wordsWidth;
+        break;
+      case TextAlign.center:
+        delta = (totalWidth - wordsWidth) / 2.0;
+        break;
+      case TextAlign.justify:
+        if (last) return wordsWidth;
+        delta = (totalWidth - wordsWidth) / (words.length - 1);
+        var x = 0.0;
+        for (var word in words) {
+          word._box = PdfRect(
+              word._box.x + x, word._box.y, word._box.width, word._box.height);
+          x += delta;
+        }
+        return totalWidth;
+    }
+    for (var word in words) {
+      word._box = PdfRect(
+          word._box.x + delta, word._box.y, word._box.width, word._box.height);
+    }
+    return totalWidth;
+  }
+
+  @override
+  void layout(Context context, BoxConstraints constraints,
+      {parentUsesSize = false}) {
+    _words.clear();
+
+    if (style == null) {
+      style = Theme.of(context).defaultTextStyle;
+    }
+
+    final cw = constraints.hasBoundedWidth
+        ? constraints.maxWidth
+        : constraints.constrainWidth();
+    final ch = constraints.hasBoundedHeight
+        ? constraints.maxHeight
+        : constraints.constrainHeight();
+
+    var x = 0.0;
+    var y = 0.0;
+    var w = 0.0;
+    var h = 0.0;
+    var lh = 0.0;
+
+    final space =
+        style.font.stringBounds(" ") * (style.fontSize * textScaleFactor);
+
+    var lines = 1;
+    var wCount = 0;
+    var lineStart = 0;
+
+    for (var word in data.split(" ")) {
+      final box =
+          style.font.stringBounds(word) * (style.fontSize * textScaleFactor);
+
+      var ww = box.width;
+      var wh = box.height;
+
+      if (x + ww > cw) {
+        if (wCount == 0) break;
+        w = math.max(
+            w,
+            _realignLine(
+                _words.sublist(lineStart), cw, x - space.width, false));
+        lineStart += wCount;
+        if (maxLines != null && ++lines > maxLines) break;
+
+        x = 0.0;
+        y += lh + style.lineSpacing;
+        h += lh + style.lineSpacing;
+        lh = 0.0;
+        if (y > ch) break;
+        wCount = 0;
+      }
+
+      var wx = x;
+      var wy = y;
+
+      x += ww + space.width;
+      lh = math.max(lh, wh);
+
+      final wd = _Word(word, PdfRect(box.x + wx, box.y + wy + wh, ww, wh));
+      _words.add(wd);
+      wCount++;
+    }
+    w = math.max(
+        w, _realignLine(_words.sublist(lineStart), cw, x - space.width, true));
+    h += lh;
+    box = PdfRect(0.0, 0.0, constraints.constrainWidth(w),
+        constraints.constrainHeight(h));
+  }
+
+  @protected
+  void debugPaint(Context context) {
+    context.canvas
+      ..setStrokeColor(PdfColor.blue)
+      ..drawRect(box.x, box.y, box.width, box.height)
+      ..strokePath();
+  }
+
+  @override
+  void paint(Context context) {
+    super.paint(context);
+    context.canvas.setFillColor(style.color);
+
+    for (var word in _words) {
+      context.canvas.drawString(style.font, style.fontSize * textScaleFactor,
+          word.text, box.x + word._box.x, box.y + box.height - word._box.y);
+    }
+  }
+}

+/*
+ * Copyright (C) 2017, David PHAM-VAN <dev.nfet.net@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+part of widget;
+
+class Theme extends Inherited {
+  final PdfDocument document;
+
+  Theme(this.document);
+
+  static Theme of(Context context) {
+    return context.inherited[Theme];
+  }
+
+  TextStyle _defaultTextStyle;
+
+  TextStyle get defaultTextStyle {
+    if (_defaultTextStyle == null) {
+      _defaultTextStyle = TextStyle(font: PdfFont.helvetica(document));
+    }
+    return _defaultTextStyle;
+  }
+
+  TextStyle _defaultTextStyleBold;
+
+  TextStyle get defaultTextStyleBold {
+    if (_defaultTextStyleBold == null) {
+      _defaultTextStyleBold =
+          defaultTextStyle.copyWith(font: PdfFont.helveticaBold(document));
+    }
+    return _defaultTextStyleBold;
+  }
+
+  TextStyle _paragraphStyle;
+
+  TextStyle get paragraphStyle {
+    if (_paragraphStyle == null) {
+      _paragraphStyle = defaultTextStyle.copyWith(lineSpacing: 5.0);
+    }
+    return _paragraphStyle;
+  }
+
+  TextStyle _bulletStyle;
+
+  TextStyle get bulletStyle {
+    if (_bulletStyle == null) {
+      _bulletStyle = defaultTextStyle.copyWith(lineSpacing: 5.0);
+    }
+    return _bulletStyle;
+  }
+
+  TextStyle _tableHeader;
+
+  TextStyle get tableHeader {
+    if (_tableHeader == null) {
+      _tableHeader = defaultTextStyleBold;
+    }
+    return _tableHeader;
+  }
+
+  TextStyle _tableCell;
+
+  TextStyle get tableCell {
+    if (_tableCell == null) {
+      _tableCell = defaultTextStyle;
+    }
+    return _tableCell;
+  }
+}

+/*
+ * Copyright (C) 2017, David PHAM-VAN <dev.nfet.net@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+part of widget;
+
+@immutable
+class Context {
+  final PdfPage page;
+  final PdfGraphics canvas;
+
+  final Map<Type, Inherited> inherited;
+
+  get pageNumber => page.pdfDocument.pdfPageList.pages.indexOf(page) + 1;
+
+  const Context({this.page, this.canvas, this.inherited});
+
+  Context copyWith(
+      {PdfPage page, PdfGraphics canvas, Map<Type, Inherited> inherited}) {
+    return Context(
+        page: page ?? this.page,
+        canvas: canvas ?? this.canvas,
+        inherited: inherited ?? this.inherited);
+  }
+
+  Context inheritFrom(Inherited object) {
+    final inherited = this.inherited;
+    inherited[object.runtimeType] = object;
+    return copyWith(inherited: inherited);
+  }
+}
+
+class Inherited {}
+
+abstract class Widget {
+  PdfRect box;
+  var _flex = 0;
+  FlexFit _fit = FlexFit.loose;
+
+  Widget();
+
+  @protected
+  void layout(Context context, BoxConstraints constraints,
+      {parentUsesSize = false});
+
+  @protected
+  void paint(Context context) {
+    assert(() {
+      if (Document.debug) debugPaint(context);
+      return true;
+    }());
+  }
+
+  @protected
+  void debugPaint(Context context) {
+    context.canvas
+      ..setStrokeColor(PdfColor.purple)
+      ..drawRect(box.x, box.y, box.width, box.height)
+      ..strokePath();
+  }
+}
+
+class WidgetContext {}
+
+abstract class SpanningWidget {
+  bool get canSpan => false;
+
+  @protected
+  WidgetContext saveContext();
+
+  @protected
+  void restoreContext(WidgetContext context);
+}
+
+abstract class StatelessWidget extends Widget {
+  Widget _child;
+
+  StatelessWidget() : super();
+
+  @override
+  void layout(Context context, BoxConstraints constraints,
+      {parentUsesSize = false}) {
+    if (_child == null) _child = build(context);
+
+    if (_child != null) {
+      _child.layout(context, constraints, parentUsesSize: parentUsesSize);
+      box = _child.box;
+    } else {
+      box = PdfRect.fromPoints(PdfPoint.zero, constraints.smallest);
+    }
+  }
+
+  @override
+  void paint(Context context) {
+    super.paint(context);
+
+    if (_child != null) {
+      final mat = Matrix4.identity();
+      mat.translate(box.x, box.y);
+      context.canvas
+        ..saveContext()
+        ..setTransform(mat);
+      _child.paint(context);
+      context.canvas.restoreContext();
+    }
+  }
+
+  @protected
+  Widget build(Context context);
+}
+
+abstract class SingleChildWidget extends Widget {
+  SingleChildWidget({this.child}) : super();
+
+  final Widget child;
+
+  @override
+  void layout(Context context, BoxConstraints constraints,
+      {parentUsesSize = false}) {
+    if (child != null) {
+      child.layout(context, constraints, parentUsesSize: parentUsesSize);
+      box = child.box;
+    } else {
+      box = PdfRect.fromPoints(PdfPoint.zero, constraints.smallest);
+    }
+  }
+
+  @override
+  void paint(Context context) {
+    super.paint(context);
+
+    if (child != null) {
+      final mat = Matrix4.identity();
+      mat.translate(box.x, box.y);
+      context.canvas
+        ..saveContext()
+        ..setTransform(mat);
+      child.paint(context);
+      context.canvas.restoreContext();
+    }
+  }
+}
+
+abstract class MultiChildWidget extends Widget {
+  MultiChildWidget({this.children = const <Widget>[]}) : super();
+
+  final List<Widget> children;
+}

@@ -2,7 +2,7 @@ name: pdf
 author: David PHAM-VAN <dev.nfet.net@gmail.com>
 author: David PHAM-VAN <dev.nfet.net@gmail.com>
 description: A pdf producer for Dart. It can create pdf files for both web or flutter.
 description: A pdf producer for Dart. It can create pdf files for both web or flutter.
 homepage: https://github.com/DavBfr/dart_pdf/tree/master/pdf
 homepage: https://github.com/DavBfr/dart_pdf/tree/master/pdf
-version: 1.2.0
+version: 1.3.0
 
 
 environment:
 environment:
   sdk: ">=1.8.0 <3.0.0"
   sdk: ">=1.8.0 <3.0.0"

+/*
+ * Copyright (C) 2017, David PHAM-VAN <dev.nfet.net@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:pdf/pdf.dart';
+import 'package:pdf/widgets.dart';
+import 'package:test/test.dart';
+
+void main() {
+  test('Pdf', () {
+    Document.debug = true;
+
+    var pdf = Document();
+
+    final symbol = TextStyle(font: PdfFont.zapfDingbats(pdf.document));
+
+    final imData = zlib.decode(base64.decode(
+        "eJz7//8/w388uOTCT6a4Ez96Q47++I+OI479mEVALyNU7z9seuNP/mAm196Ekz8YR+0dWHtBmJC9S+7/Zog89iMIKLYaHQPVJGLTD7MXpDfq+I9goNhPdPPDjv3YlnH6Jye6+2H21l/6yeB/4HsSDr1bQXrRwq8HqHcGyF6QXp9933N0tn/7Y7vn+/9gLPaih0PDlV9MIAzVm6ez7dsfzW3f/oMwzAx0e7FhoJutdbcj9MKw9frnL2J2POfBpxeEg478YLba/X0Wsl6lBXf+s0bP/s8ePXeWePJCvPEJNYMRZIYWSO/cq/9Z/Nv+M4bO+M8YDjFDJGkhzvSE7A6jRTdnsQR2wfXCMLHuMC5byyidvGgWE5JeZDOIcYdR+TpmkBno+mFmAAC+DGhl"));
+    final im = PdfImage(pdf.document, image: imData, width: 16, height: 20);
+
+    pdf.addPage(Page(
+        pageFormat: PdfPageFormat(400.0, 400.0),
+        margin: EdgeInsets.all(10.0),
+        build: (Context context) => Column(children: <Widget>[
+              Container(
+                  padding: EdgeInsets.all(5),
+                  margin: EdgeInsets.only(bottom: 10),
+                  decoration: BoxDecoration(
+                      color: PdfColor.amber,
+                      border: BoxBorder(
+                          top: true,
+                          bottom: true,
+                          left: true,
+                          right: true,
+                          width: 2.0)),
+                  child: Text("Hello World",
+                      textScaleFactor: 2.0, textAlign: TextAlign.center)),
+              Align(alignment: Alignment.topLeft, child: Text("Left align")),
+              Padding(padding: EdgeInsets.all(5.0)),
+              Row(
+                  mainAxisAlignment: MainAxisAlignment.spaceEvenly,
+                  children: <Widget>[
+                    Image(im),
+                    PdfLogo(),
+                    Column(children: <Widget>[
+                      Text("(", style: symbol),
+                      Text("4", style: symbol),
+                    ]),
+                  ]),
+              Padding(
+                  padding: EdgeInsets.only(left: 30, top: 20),
+                  child: Lorem(textAlign: TextAlign.justify)),
+              Expanded(
+                  child: Transform.scale(
+                      child: Transform.rotate(
+                          child: FittedBox(child: Text("Expanded")),
+                          angle: 0.2),
+                      scale: 0.9)),
+              Container(
+                  padding: EdgeInsets.only(top: 5),
+                  decoration:
+                      BoxDecoration(border: BoxBorder(top: true, width: 1.0)),
+                  child: Text("That's all Folks!",
+                      textAlign: TextAlign.center,
+                      style: Theme.of(context).defaultTextStyle.copyWith(
+                          font: PdfFont.timesBoldItalic(pdf.document)),
+                      textScaleFactor: 3.0)),
+            ])));
+
+    pdf.addPage(Page(
+        pageFormat: PdfPageFormat(400.0, 400.0),
+        margin: EdgeInsets.all(10.0),
+        build: (Context context) => Center(
+            child: GridView(
+                crossAxisCount: 3,
+                direction: Axis.vertical,
+                crossAxisSpacing: 10.0,
+                mainAxisSpacing: 10.0,
+                padding: EdgeInsets.all(10.0),
+                children: List<Widget>.generate(
+                    9, (n) => FittedBox(child: Text("${n + 1}")))))));
+
+    pdf.addPage(MultiPage(
+        pageFormat: PdfPageFormat(400.0, 200.0),
+        margin: EdgeInsets.all(10.0),
+        build: (Context context) => <Widget>[
+              Table.fromTextArray(context: context, data: [
+                ["Company", "Contact", "Country"],
+                ["Alfreds Futterkiste", "Maria Anders", "Germany"],
+                ["Centro comercial Moctezuma", "Francisco Chang", "Mexico"],
+                ["Ernst Handel", "Roland Mendel", "Austria"],
+                ["Island Trading", "Helen Bennett", "UK"],
+                ["Laughing Bacchus Winecellars", "Yoshi Tannamuri", "Canada"],
+                ["Magazzini Alimentari Riuniti", "Giovanni Rovelli", "Italy"],
+                ["Spaceage Stereo", "Igor Cavalcanti Pereira", "Brasil"],
+                ["Team Uno", "Frantisek Stefánek", "Czech Republic"],
+                ["Isaly's", "Michelle J. Kristensen", "Danmark"],
+                ["Albers", "Marjolaine Laramée", "France"],
+                ["Dynatronics Accessories", "Cong Ch'en", "China"],
+                ["York Steak House", "Outi Vuorinen", "Finland"],
+                ["Weathervane", "Else Jeremiassen", "Iceland"],
+              ]),
+              CustomPaint(
+                  size: PdfPoint(50, 50),
+                  painter: (PdfGraphics canvas, PdfPoint size) {
+                    canvas
+                      ..setColor(PdfColor.indigo)
+                      ..drawRRect(0, 0, size.x, size.y, 10, 10)
+                      ..fillPath();
+                  }),
+            ]));
+
+    var file = File('widgets.pdf');
+    file.writeAsBytesSync(pdf.document.save());
+  });
+}

+# 1.3.0
+* Add a Flutter like widget system
+
 # 1.2.0
 # 1.2.0
 * Fix compileSdkVersion to match appcompat
 * Fix compileSdkVersion to match appcompat
 * Change license to Apache 2.0
 * Change license to Apache 2.0

 # Pdf Printing Example
 # Pdf Printing Example
 
 
-Flutter example project
-
-## Getting Started
-
-1. to run the example, start a simulator and run:
-
-  ```shell
-  flutter run
-  ```
+```dart
+void printPdf() {
+  Printing.layoutPdf(onLayout: (PdfPageFormat format) {
+    final pdf = Document()
+      ..addPage(Page(
+          pageFormat: PdfPageFormat.a4,
+          build: (Context context) {
+            return Center(
+              child: Text("Hello World"),
+            ); // Center
+          }));
+    return pdf.save();
+  }); // Page
+}
+```

-import 'dart:io';
 import 'dart:async';
 import 'dart:async';
 
 
+import 'package:flutter/widgets.dart' as fw;
+
 import 'package:pdf/pdf.dart';
 import 'package:pdf/pdf.dart';
+import 'package:pdf/widgets.dart';
+import 'package:printing/printing.dart';
 
 
-Future<PdfDocument> generateDocument(PdfPageFormat format) async {
-  final pdf = PdfDocument(deflate: zlib.encode);
-  final page = PdfPage(pdf,
-      pageFormat: format.applyMargin(
-          left: 2.0 * PdfPageFormat.cm,
-          top: 2.0 * PdfPageFormat.cm,
-          right: 2.0 * PdfPageFormat.cm,
-          bottom: 2.0 * PdfPageFormat.cm));
-  final g = page.getGraphics();
-  final font = PdfFont.helvetica(pdf);
-  final top = page.pageFormat.height - page.pageFormat.marginTop;
+const green = PdfColor.fromInt(0xff9ce5d0);
+const lightGreen = PdfColor.fromInt(0xffcdf1e7);
 
 
-  g.setColor(PdfColor.orange);
-  g.drawRect(
-      page.pageFormat.marginLeft,
-      page.pageFormat.marginBottom,
-      page.pageFormat.width -
-          page.pageFormat.marginRight -
-          page.pageFormat.marginLeft,
-      page.pageFormat.height -
-          page.pageFormat.marginTop -
-          page.pageFormat.marginBottom);
-  g.strokePath();
+class MyPage extends Page {
+  MyPage(
+      {PdfPageFormat pageFormat = PdfPageFormat.a4,
+      BuildCallback build,
+      EdgeInsets margin})
+      : super(pageFormat: pageFormat, margin: margin, build: build);
 
 
-  g.setColor(PdfColor(0.0, 1.0, 1.0));
-  g.drawRRect(
-    50.0 * PdfPageFormat.mm,
-    top - 80.0 * PdfPageFormat.mm,
-    100.0 * PdfPageFormat.mm,
-    50.0 * PdfPageFormat.mm,
-    20.0,
-    20.0,
-  );
-  g.fillPath();
+  void paint(Widget child, Context context) {
+    context.canvas
+      ..setColor(lightGreen)
+      ..moveTo(0, pageFormat.height)
+      ..lineTo(0, pageFormat.height - 230)
+      ..lineTo(60, pageFormat.height)
+      ..fillPath()
+      ..setColor(green)
+      ..moveTo(0, pageFormat.height)
+      ..lineTo(0, pageFormat.height - 100)
+      ..lineTo(100, pageFormat.height)
+      ..fillPath()
+      ..setColor(lightGreen)
+      ..moveTo(30, pageFormat.height)
+      ..lineTo(110, pageFormat.height - 50)
+      ..lineTo(150, pageFormat.height)
+      ..fillPath()
+      ..moveTo(pageFormat.width, 0)
+      ..lineTo(pageFormat.width, 230)
+      ..lineTo(pageFormat.width - 60, 0)
+      ..fillPath()
+      ..setColor(green)
+      ..moveTo(pageFormat.width, 0)
+      ..lineTo(pageFormat.width, 100)
+      ..lineTo(pageFormat.width - 100, 0)
+      ..fillPath()
+      ..setColor(lightGreen)
+      ..moveTo(pageFormat.width - 30, 0)
+      ..lineTo(pageFormat.width - 110, 50)
+      ..lineTo(pageFormat.width - 150, 0)
+      ..fillPath();
 
 
-  g.setColor(PdfColor(0.3, 0.3, 0.3));
-  g.drawString(
-      font,
-      12.0,
-      "Hello World!",
-      page.pageFormat.marginLeft + 10.0 * PdfPageFormat.mm,
-      top - 10.0 * PdfPageFormat.mm);
+    super.paint(child, context);
+  }
+}
 
 
-  {
-    final page = PdfPage(pdf,
-        pageFormat: format.applyMargin(
-            left: 2.0 * PdfPageFormat.cm,
-            top: 2.0 * PdfPageFormat.cm,
-            right: 2.0 * PdfPageFormat.cm,
-            bottom: 2.0 * PdfPageFormat.cm));
-    final g = page.getGraphics();
-    final font = PdfFont.helvetica(pdf);
-    final top = page.pageFormat.height - page.pageFormat.marginTop;
+class Block extends StatelessWidget {
+  Block({this.title});
 
 
-    g.setColor(PdfColor.orange);
-    g.drawRect(
-        page.pageFormat.marginLeft,
-        page.pageFormat.marginBottom,
-        page.pageFormat.width -
-            page.pageFormat.marginRight -
-            page.pageFormat.marginLeft,
-        page.pageFormat.height -
-            page.pageFormat.marginTop -
-            page.pageFormat.marginBottom);
-    g.strokePath();
+  final String title;
+
+  @override
+  Widget build(Context context) {
+    return Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: <Widget>[
+          Row(crossAxisAlignment: CrossAxisAlignment.start, children: <Widget>[
+            Container(
+              width: 6,
+              height: 6,
+              margin: EdgeInsets.only(top: 2.5, left: 2, right: 5),
+              decoration: BoxDecoration(color: green, shape: BoxShape.circle),
+            ),
+            Text(title, style: Theme.of(context).defaultTextStyleBold),
+          ]),
+          Container(
+            decoration: BoxDecoration(
+                border: BoxBorder(left: true, color: green, width: 2)),
+            padding: EdgeInsets.only(left: 10, top: 5, bottom: 5),
+            margin: EdgeInsets.only(left: 5),
+            child: Column(
+                crossAxisAlignment: CrossAxisAlignment.start,
+                children: <Widget>[
+                  Lorem(length: 20),
+                ]),
+          ),
+        ]);
+  }
+}
 
 
-    g.setColor(PdfColor(0.0, 1.0, 1.0));
-    g.drawRRect(
-      50.0 * PdfPageFormat.mm,
-      top - 80.0 * PdfPageFormat.mm,
-      100.0 * PdfPageFormat.mm,
-      50.0 * PdfPageFormat.mm,
-      20.0,
-      20.0,
-    );
-    g.fillPath();
+class Category extends StatelessWidget {
+  Category({this.title});
 
 
-    g.setColor(PdfColor(0.3, 0.3, 0.3));
-    g.drawString(
-        font,
-        12.0,
-        "Hello World!",
-        page.pageFormat.marginLeft + 10.0 * PdfPageFormat.mm,
-        top - 10.0 * PdfPageFormat.mm);
+  final String title;
+
+  @override
+  Widget build(Context context) {
+    return Container(
+        decoration: BoxDecoration(color: lightGreen, borderRadius: 6),
+        margin: EdgeInsets.only(bottom: 10, top: 20),
+        padding: EdgeInsets.fromLTRB(10, 7, 10, 4),
+        child: Text(title, textScaleFactor: 1.5));
   }
   }
-  return pdf;
+}
+
+Future<PdfDocument> generateDocument(PdfPageFormat format) async {
+  final pdf = PdfDoc();
+
+  final profileImage = await pdfImageFromImageProvider(
+      pdf: pdf.document,
+      image: fw.NetworkImage(
+          "https://www.gravatar.com/avatar/00000000000000000000000000000000?d=mp&s=200"),
+      onError: (dynamic exception, StackTrace stackTrace) {
+        print("error");
+      });
+
+  pdf.addPage(MyPage(
+    pageFormat: format.applyMargin(
+        left: 2.0 * PdfPageFormat.cm,
+        top: 4.0 * PdfPageFormat.cm,
+        right: 2.0 * PdfPageFormat.cm,
+        bottom: 2.0 * PdfPageFormat.cm),
+    build: (Context context) => Row(children: <Widget>[
+          Expanded(
+              child: Column(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: <Widget>[
+                Container(
+                    padding: EdgeInsets.only(left: 30, bottom: 20),
+                    child: Column(
+                        crossAxisAlignment: CrossAxisAlignment.start,
+                        children: <Widget>[
+                          Text("Parnella Charlesbois",
+                              textScaleFactor: 2.0,
+                              style: Theme.of(context).defaultTextStyleBold),
+                          Padding(padding: EdgeInsets.only(top: 10)),
+                          Text("Electrotyper",
+                              textScaleFactor: 1.2,
+                              style: Theme.of(context)
+                                  .defaultTextStyleBold
+                                  .copyWith(color: green)),
+                          Padding(padding: EdgeInsets.only(top: 20)),
+                          Row(
+                              crossAxisAlignment: CrossAxisAlignment.start,
+                              mainAxisAlignment: MainAxisAlignment.spaceBetween,
+                              children: <Widget>[
+                                Column(
+                                    crossAxisAlignment:
+                                        CrossAxisAlignment.start,
+                                    children: <Widget>[
+                                      Text("568 Port Washington Road"),
+                                      Text("Nordegg, AB T0M 2H0"),
+                                      Text("Canada, ON"),
+                                    ]),
+                                Column(
+                                    crossAxisAlignment:
+                                        CrossAxisAlignment.start,
+                                    children: <Widget>[
+                                      Text("+1 403-721-6898"),
+                                      Text("p.charlesbois@yahoo.com"),
+                                      Text("wholeprices.ca")
+                                    ]),
+                                Padding(padding: EdgeInsets.zero)
+                              ]),
+                        ])),
+                Category(title: "Work Experience"),
+                Block(title: "Tour bus driver"),
+                Block(title: "Logging equipment operator"),
+                Block(title: "Foot doctor"),
+                Category(title: "Education"),
+                Block(title: "Bachelor Of Commerce"),
+                Block(title: "Bachelor Interior Design"),
+              ])),
+          Container(
+            height: double.infinity,
+            width: 10,
+            decoration: BoxDecoration(
+                border: BoxBorder(left: true, color: green, width: 2)),
+          ),
+          Column(
+              crossAxisAlignment: CrossAxisAlignment.start,
+              children: <Widget>[
+                ClipOval(
+                    child: Container(
+                        width: 100,
+                        height: 100,
+                        color: lightGreen,
+                        child: profileImage == null
+                            ? Container()
+                            : Image(profileImage)))
+              ])
+        ]),
+  ));
+  return pdf.document;
 }
 }

@@ -17,12 +17,15 @@
 library printing;
 library printing;
 
 
 import 'dart:async';
 import 'dart:async';
+import 'dart:io';
 import 'dart:typed_data';
 import 'dart:typed_data';
 import 'dart:ui' as ui;
 import 'dart:ui' as ui;
 
 
 import 'package:flutter/services.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter/widgets.dart';
 import 'package:flutter/widgets.dart';
 import 'package:pdf/pdf.dart';
 import 'package:pdf/pdf.dart';
+import 'package:pdf/widgets.dart';
 
 
 part 'src/asset_utils.dart';
 part 'src/asset_utils.dart';
 part 'src/printing.dart';
 part 'src/printing.dart';
+part 'src/widgets.dart';

+/*
+ * Copyright (C) 2017, David PHAM-VAN <dev.nfet.net@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+part of printing;
+
+class PdfDoc extends Document {
+  PdfDoc({bool compress = true})
+      : super(deflate: compress ? zlib.encode : null);
+}

@@ -2,7 +2,7 @@ name: printing
 author: David PHAM-VAN <dev.nfet.net@gmail.com>
 author: David PHAM-VAN <dev.nfet.net@gmail.com>
 description: Plugin that allows Flutter apps to generate and print documents to android or ios compatible printers
 description: Plugin that allows Flutter apps to generate and print documents to android or ios compatible printers
 homepage: https://github.com/DavBfr/dart_pdf/tree/master/printing
 homepage: https://github.com/DavBfr/dart_pdf/tree/master/printing
-version: 1.2.0
+version: 1.3.0
 
 
 environment:
 environment:
   sdk: ">=1.19.0 <3.0.0"
   sdk: ">=1.19.0 <3.0.0"
@@ -10,7 +10,7 @@ environment:
 dependencies:
 dependencies:
   flutter:
   flutter:
     sdk: flutter
     sdk: flutter
-  pdf: "^1.2.0"
+  pdf: "^1.3.0"
 
 
 flutter:
 flutter:
   plugin:
   plugin: