profileView method

dynamic profileView()

Widgets themselves have no mutable state (all their fields must be final). If you wish to associate mutable state with a widget, consider using a StatefulWidget, which creates a State object (via StatefulWidget.createState) whenever it is inflated into an element and incorporated into the tree.

A given widget can be included in the tree zero or more times. In particular a given widget can be placed in the tree multiple times. Each time a widget is placed in the tree, it is inflated into an Element, which means a widget that is incorporated into the tree multiple times will be inflated multiple times.

The key property controls how one widget replaces another widget in the tree. If the runtimeType and key properties of the two widgets are operator==, respectively, then the new widget replaces the old widget by updating the underlying element (i.e., by calling Element.update with the new widget). Otherwise, the old element is removed from the tree, the new widget is inflated into an element, and the new element is inserted into the tree.

See also:

StatefulWidget and State, for widgets that can build differently several times over their lifetime.
InheritedWidget, for widgets that introduce ambient state that can be read by descendant widgets.
StatelessWidget, for widgets that always build the same way given a particular configuration and ambient state. /// Widgets themselves have no mutable state (all their fields must be final). If you wish to associate mutable state with a widget, consider using a StatefulWidget, which creates a State object (via StatefulWidget.createState) whenever it is inflated into an element and incorporated into the tree.

See also:

StatefulWidget and State, for widgets that can build differently several times over their lifetime.
InheritedWidget, for widgets that introduce ambient state that can be read by descendant widgets.
StatelessWidget, for widgets that always build the same way given a particular configuration and ambient state./// Widgets themselves have no mutable state (all their fields must be final). If you wish to associate mutable state with a widget, consider using a StatefulWidget, which creates a State object (via StatefulWidget.createState) whenever it is inflated into an element and incorporated into the tree.

See also:

StatefulWidget and State, for widgets that can build differently several times over their lifetime.
InheritedWidget, for widgets that introduce ambient state that can be read by descendant widgets.
StatelessWidget, for widgets that always build the same way given a particular configuration and ambient state. Widgets themselves have no mutable state (all their fields must be final). If you wish to associate mutable state with a widget, consider using a StatefulWidget, which creates a State object (via StatefulWidget.createState) whenever it is inflated into an element and incorporated into the tree.

See also:

StatefulWidget and State, for widgets that can build differently several times over their lifetime.
InheritedWidget, for widgets that introduce ambient state that can be read by descendant widgets.
StatelessWidget, for widgets that always build the same way given a particular configuration and ambient state. /// Widgets themselves have no mutable state (all their fields must be final). If you wish to associate mutable state with a widget, consider using a StatefulWidget, which creates a State object (via StatefulWidget.createState) whenever it is inflated into an element and incorporated into the tree.

See also:

StatefulWidget and State, for widgets that can build differently several times over their lifetime.
InheritedWidget, for widgets that introduce ambient state that can be read by descendant widgets.
StatelessWidget, for widgets that always build the same way given a particular configuration and ambient state. Widgets themselves have no mutable state (all their fields must be final). If you wish to associate mutable state with a widget, consider using a StatefulWidget, which creates a State object (via StatefulWidget.createState) whenever it is inflated into an element and incorporated into the tree.

See also:

StatefulWidget and State, for widgets that can build differently several times over their lifetime.
InheritedWidget, for widgets that introduce ambient state that can be read by descendant widgets.
StatelessWidget, for widgets that always build the same way given a particular configuration and ambient state. /// Widgets themselves have no mutable state (all their fields must be final). If you wish to associate mutable state with a widget, consider using a StatefulWidget, which creates a State object (via StatefulWidget.createState) whenever it is inflated into an element and incorporated into the tree.

See also:

StatefulWidget and State, for widgets that can build differently several times over their lifetime.
InheritedWidget, for widgets that introduce ambient state that can be read by descendant widgets.
StatelessWidget, for widgets that always build the same way given a particular configuration and ambient state./// Widgets themselves have no mutable state (all their fields must be final). If you wish to associate mutable state with a widget, consider using a StatefulWidget, which creates a State object (via StatefulWidget.createState) whenever it is inflated into an element and incorporated into the tree.

The key property controls how one widget replaces another widget in the tree. If the runtimeType and key properties of the two widgets are operator==, respectively, then the new widget replaces the old widget by build a widget, a State.setState call would require Flutter to entirely rebuild the returned wrapping widget. If a Widget was used instead, Flutter would be able to efficiently re-render only those parts that really need to be updated. Even better, if the created widget is const, Flutter would short-circuit most of the rebuild work.

Avoid changing the depth of any created subtrees or changing the type of any widgets in the subtree. For example, rather than returning either the child or the child wrapped in an IgnorePointer, always wrap the child widget in an IgnorePointer and control the IgnorePointer.ignoring property. This is because changing the depth of the subtree requires rebuilding, laying out, and painting the entire subtree, whereas just changing the property will require the least possible change to the render tree (in the case of IgnorePointer, for example, no layout or repaint is necessary at all).
If the depth must be changed for some reason, consider wrapping the common parts of the subtrees in widgets that have a GlobalKey that remains consistent for the life of the stateful widget. (The KeyedSubtree widget may be useful for this purpose if no other widget can conveniently be assigned the key.)

{@tool snippet}

This is a skeleton of a stateful widget subclass called YellowBird.

In this example. the State has no actual state. State is normally represented as private member fields. Also, normally widgets have more constructor arguments, each of which corresponds to a final property.

class YellowBird extends StatefulWidget {
  const YellowBird({ Key? key }) : super(key: key);

  @override
  State<YellowBird> createState() => _YellowBirdState();
}

class _YellowBirdState extends State<YellowBird> {
  @override
  Widget build(BuildContext context) {
    return Container(color: const Color(0xFFFFE306));
  }
}

{@end-tool} {@tool snippet}

This example shows the more generic widget Bird which can be given a color and a child, and which has some internal state with a method that can be called to mutate it:

class Bird extends StatefulWidget {
  const Bird({
    Key? key,
    this.color = const Color(0xFFFFE306),
    this.child,
  }) : super(key: key);

  final Color color;
  final Widget? child;

  @override
  State<Bird> createState() => _BirdState();
}

class _BirdState extends State<Bird> {
  double _size = 1.0;

  void grow() {
    setState(() { _size += 0.1; });
  }

  @override
  Widget build(BuildContext context) {
    return Container(
      color: widget.color,
      transform: Matrix4.diagonal3Values(_size, _size, 1.0),
      child: widget.child,
    );
  }
}

{@end-tool}

By convention, widget constructors only use named arguments. Also by convention, the first argument is key, and the last argument is child, children, or the equivalent.

See also:

State, where the logic behind a StatefulWidget is hosted.
StatelessWidget, for widgets that always build the same way given a particular configuration and ambient state.
InheritedWidget, for widgets that introduce ambient state that can be read by descendant widgets. Widgets themselves have no mutable state (all their fields must be final). If you wish to associate mutable state with a widget, consider using a StatefulWidget, which creates a State object (via StatefulWidget.createState) whenever it is inflated into an element and incorporated into the tree.

See also:

StatefulWidget and State, for widgets that can build differently several times over their lifetime.
InheritedWidget, for widgets that introduce ambient state that can be read by descendant widgets.
StatelessWidget, for widgets that always build the same way given a particular configuration and ambient state./// Widgets themselves have no mutable state (all their fields must be final). Widgets themselves have no mutable state (all their fields must be final). If you wish to associate mutable state with a widget, consider using a StatefulWidget, which creates a State object (via StatefulWidget.createState) whenever it is inflated into an element and incorporated into the tree.

See also:

StatefulWidget and State, for widgets that can build differently several times over their lifetime.
InheritedWidget, for widgets that introduce ambient state that can be read by descendant widgets.
StatelessWidget, for widgets that always build the same way given a particular configuration and ambient state. /// Widgets themselves have no mutable state (all their fields must be final).

Implementation

// /// updating the underlying element (i.e., by calling [Element.update] with the
// /// new widget). Otherwise, the old element is removed from the tree, the new
// /// widget is inflated into an element, and the new element is inserted into the
// /// tree.
// ///
// /// See also:
// ///
// ///  * [StatefulWidget] and [State], for widgets that can build differently
// ///    several times over their lifetime.
// ///  * [InheritedWidget], for widgets that introduce ambient state that can
// ///    be read by descendant widgets.
// ///  * [StatelessWidget], for widgets that always build the same way given a
// ///    particular configuration and ambient state.
/// Widgets themselves have no mutable state (all their fields must be final).
/// If you wish to associate mutable state with a widget, consider using a
/// [StatefulWidget], which creates a [State] object (via
/// [StatefulWidget.createState]) whenever it is inflated into an element and
/// incorporated into the tree.
///
/// A given widget can be included in the tree zero or more times. In particular
/// a given widget can be placed in the tree multiple times. Each time a widget
/// is placed in the tree, it is inflated into an [Element], which means a
/// widget that is incorporated into the tree multiple times will be inflated
/// multiple times.
///
/// The [key] property controls how one widget replaces another widget in the
/// tree. If the [runtimeType] and [key] properties of the two widgets are
/// [operator==], respectively, then the new widget replaces the old widget by
/// updating the underlying element (i.e., by calling [Element.update] with the
/// new widget). Otherwise, the old element is removed from the tree, the new
/// widget is inflated into an element, and the new element is inserted into the
/// tree.
///
/// See also:
///
///  * [StatefulWidget] and [State], for widgets that can build differently
///    several times over their lifetime.
///  * [InheritedWidget], for widgets that introduce ambient state that can
///    be read by descendant widgets.
///  * [StatelessWidget], for widgets that always build the same way given a
///    particular configuration and ambient state./// Widgets themselves have no mutable state (all their fields must be final).
// /// If you wish to associate mutable state with a widget, consider using a
// /// [StatefulWidget], which creates a [State] object (via
// /// [StatefulWidget.createState]) whenever it is inflated into an element and
// /// incorporated into the tree.
// ///
// /// A given widget can be included in the tree zero or more times. In particular
// /// a given widget can be placed in the tree multiple times. Each time a widget
// /// is placed in the tree, it is inflated into an [Element], which means a
// /// widget that is incorporated into the tree multiple times will be inflated
// /// multiple times.
// ///
// /// The [key] property controls how one widget replaces another widget in the
// /// tree. If the [runtimeType] and [key] properties of the two widgets are
// /// [operator==], respectively, then the new widget replaces the old widget by
// /// updating the underlying element (i.e., by calling [Element.update] with the
// /// new widget). Otherwise, the old element is removed from the tree, the new
// /// widget is inflated into an element, and the new element is inserted into the
// /// tree.
// ///
// /// See also:
// ///
// ///  * [StatefulWidget] and [State], for widgets that can build differently
// ///    several times over their lifetime.
// ///  * [InheritedWidget], for widgets that introduce ambient state that can
// ///    be read by descendant widgets.
// ///  * [StatelessWidget], for widgets that always build the same way given a
// ///    particular configuration and ambient state.
/// Widgets themselves have no mutable state (all their fields must be final).
/// If you wish to associate mutable state with a widget, consider using a
/// [StatefulWidget], which creates a [State] object (via
/// [StatefulWidget.createState]) whenever it is inflated into an element and
/// incorporated into the tree.
///
/// A given widget can be included in the tree zero or more times. In particular
/// a given widget can be placed in the tree multiple times. Each time a widget
/// is placed in the tree, it is inflated into an [Element], which means a
/// widget that is incorporated into the tree multiple times will be inflated
/// multiple times.
///
/// The [key] property controls how one widget replaces another widget in the
/// tree. If the [runtimeType] and [key] properties of the two widgets are
/// [operator==], respectively, then the new widget replaces the old widget by
/// updating the underlying element (i.e., by calling [Element.update] with the
/// new widget). Otherwise, the old element is removed from the tree, the new
/// widget is inflated into an element, and the new element is inserted into the
/// tree.
///
/// See also:
///
///  * [StatefulWidget] and [State], for widgets that can build differently
///    several times over their lifetime.
///  * [InheritedWidget], for widgets that introduce ambient state that can
///    be read by descendant widgets.
///  * [StatelessWidget], for widgets that always build the same way given a
///    particular configuration and ambient state.
///    /// Widgets themselves have no mutable state (all their fields must be final).
// /// If you wish to associate mutable state with a widget, consider using a
// /// [StatefulWidget], which creates a [State] object (via
// /// [StatefulWidget.createState]) whenever it is inflated into an element and
// /// incorporated into the tree.
// ///
// /// A given widget can be included in the tree zero or more times. In particular
// /// a given widget can be placed in the tree multiple times. Each time a widget
// /// is placed in the tree, it is inflated into an [Element], which means a
// /// widget that is incorporated into the tree multiple times will be inflated
// /// multiple times.
// ///
// /// The [key] property controls how one widget replaces another widget in the
// /// tree. If the [runtimeType] and [key] properties of the two widgets are
// /// [operator==], respectively, then the new widget replaces the old widget by
// /// updating the underlying element (i.e., by calling [Element.update] with the
// /// new widget). Otherwise, the old element is removed from the tree, the new
// /// widget is inflated into an element, and the new element is inserted into the
// /// tree.
// ///
// /// See also:
// ///
// ///  * [StatefulWidget] and [State], for widgets that can build differently
// ///    several times over their lifetime.
// ///  * [InheritedWidget], for widgets that introduce ambient state that can
// ///    be read by descendant widgets.
// ///  * [StatelessWidget], for widgets that always build the same way given a
// ///    particular configuration and ambient state.


profileView() {
  return Padding(
    padding: const EdgeInsets.only(left: 20, right: 20),
    child: Row(
      children: [
        GestureDetector(
          onTap: () {

          },
        ),
        const SizedBox(
          width: 10,
        ),
        Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Row(
              children: [

              ],
            ),
            Padding(
              padding: const EdgeInsets.only(top: 2.0),
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  Row(
                    children: [
                      Image.asset(
                        'assets/images/pin.png',
                        height: 16,
                      ),
                      const SizedBox(
                        width: 4,
                      ),
                      Container(
                        width:  2,
                        child: Text(
                          '}',
                          style: TextStyle(fontSize: 12),
                        ),
                      ),
                    ],
                  ),
                  const SizedBox(
                    height: 6,
                  ),
                  Row(
                    children: [
                      Image.asset(
                        'assets/images/book.png',
                        height: 16,
                      ),
                      SizedBox(
                        width: 4,
                      ),
                      Text(
                        '',
                        style: TextStyle(fontSize: 12),
                      ),
                    ],
                  ),
                  const SizedBox(
                    height: 6,
                  ),
                  Row(
                    children: [
                      Image.asset(
                        'assets/images/mpin.png',
                        height: 16,
                      ),
                      SizedBox(
                        width: 4,
                      ),

                    ],
                  )
                ],
              ),
            )
          ],
        )
      ],
    )
        ,
  );
}

profileView method

Implementation

Rj31 class