content: import 'package:flutter/material.dart';
  
  class ClickProps {
    /// Called when the user taps down this part of the material.
    final GestureTapDownCallback? onTapDown;
  
    /// Called when the user releases a tap that was started on this part of the
    /// material. [onTap] is called immediately after.
    final GestureTapUpCallback? onTapUp;
  
    /// Called when the user cancels a tap that was started on this part of the
    /// material.
    final GestureTapCallback? onTapCancel;
  
    /// Called when the user double taps this part of the material.
    final GestureTapCallback? onDoubleTap;
  
    /// Called when the user long-presses on this part of the material.
    final GestureLongPressCallback? onLongPress;
  
    /// Called when the user taps this part of the material with a secondary button.
    final GestureTapCallback? onSecondaryTap;
  
    /// Called when the user taps down on this part of the material with a
    /// secondary button.
    final GestureTapDownCallback? onSecondaryTapDown;
  
    /// Called when the user releases a secondary button tap that was started on
    /// this part of the material. [onSecondaryTap] is called immediately after.
    final GestureTapUpCallback? onSecondaryTapUp;
  
    /// Called when the user cancels a secondary button tap that was started on
    /// this part of the material.
    final GestureTapCallback? onSecondaryTapCancel;
  
    /// Called when this part of the material either becomes highlighted or stops
    /// being highlighted.
    ///
    /// The value passed to the callback is true if this part of the material has
    /// become highlighted and false if this part of the material has stopped
    /// being highlighted.
    ///
    /// If all of [onTap], [onDoubleTap], and [onLongPress] become null while a
    /// gesture is ongoing, then [onTapCancel] will be fired and
    /// [onHighlightChanged] will be fired with the value false _during the
    /// build_. This means, for instance, that in that scenario [State.setState]
    /// cannot be called.
    final ValueChanged<bool>? onHighlightChanged;
  
    /// Called when a pointer enters or exits the ink response area.
    ///
    /// The value passed to the callback is true if a pointer has entered this
    /// part of the material and false if a pointer has exited this part of the
    /// material.
    final ValueChanged<bool>? onHover;
  
    /// The cursor for a mouse pointer when it enters or is hovering over the
    /// widget.
    ///
    /// If [mouseCursor] is a [MaterialStateProperty &lt;MouseCursor&gt;],
    /// [WidgetStateProperty.resolve] is used for the following [WidgetState]s:
    ///
    ///  * [WidgetState.hovered].
    ///  * [WidgetState.focused].
    ///  * [WidgetState.disabled].
    ///
    /// If this property is null, [WidgetStateMouseCursor.clickable] will be used.
    final MouseCursor? mouseCursor;
  
    /// Whether this ink response should be clipped its bounds.
    ///
    /// This flag also controls whether the splash migrates to the center of the
    /// [InkResponse] or not. If [containedInkWell] is true, the splash remains
    /// centered around the tap location. If it is false, the splash migrates to
    /// the center of the [InkResponse] as it grows.
    ///
    /// See also:
    ///
    ///  * [highlightShape], the shape of the focus, hover, and pressed
    ///    highlights.
    ///  * [borderRadius], which controls the corners when the box is a rectangle.
    ///  * [getRectCallback], which controls the size and position of the box when
    ///    it is a rectangle.
    final bool containedInkWell;
  
    /// The shape (e.g., circle, rectangle) to use for the highlight drawn around
    /// this part of the material when pressed, hovered over, or focused.
    ///
    /// The same shape is used for the pressed highlight (see [highlightColor]),
    /// the focus highlight (see [focusColor]), and the hover highlight (see
    /// [hoverColor]).
    ///
    /// If the shape is [BoxShape.circle], then the highlight is centered on the
    /// [InkResponse]. If the shape is [BoxShape.rectangle], then the highlight
    /// fills the [InkResponse], or the rectangle provided by [getRectCallback] if
    /// the callback is specified.
    ///
    /// See also:
    ///
    ///  * [containedInkWell], which controls clipping behavior.
    ///  * [borderRadius], which controls the corners when the box is a rectangle.
    ///  * [highlightColor], the color of the highlight.
    ///  * [getRectCallback], which controls the size and position of the box when
    ///    it is a rectangle.
    final BoxShape highlightShape;
  
    /// The radius of the ink splash.
    ///
    /// Splashes grow up to this size. By default, this size is determined from
    /// the size of the rectangle provided by [getRectCallback], or the size of
    /// the [InkResponse] itself.
    ///
    /// See also:
    ///
    ///  * [splashColor], the color of the splash.
    ///  * [splashFactory], which defines the appearance of the splash.
    final double? radius;
  
    /// The border radius of the containing rectangle. This is effective only if
    /// [highlightShape] is [BoxShape.rectangle].
    ///
    /// If this is null, it is interpreted as [BorderRadius.zero].
    final BorderRadius? borderRadius;
  
    /// The custom clip border.
    ///
    /// If this is null, the ink response will not clip its content.
    final ShapeBorder? customBorder;
  
    /// The color of the ink response when the parent widget is focused. If this
    /// property is null then the focus color of the theme,
    /// [ThemeData.focusColor], will be used.
    ///
    /// See also:
    ///
    ///  * [highlightShape], the shape of the focus, hover, and pressed
    ///    highlights.
    ///  * [hoverColor], the color of the hover highlight.
    ///  * [splashColor], the color of the splash.
    ///  * [splashFactory], which defines the appearance of the splash.
    final Color? focusColor;
  
    /// The color of the ink response when a pointer is hovering over it. If this
    /// property is null then the hover color of the theme,
    /// [ThemeData.hoverColor], will be used.
    ///
    /// See also:
    ///
    ///  * [highlightShape], the shape of the focus, hover, and pressed
    ///    highlights.
    ///  * [highlightColor], the color of the pressed highlight.
    ///  * [focusColor], the color of the focus highlight.
    ///  * [splashColor], the color of the splash.
    ///  * [splashFactory], which defines the appearance of the splash.
    final Color? hoverColor;
  
    /// The highlight color of the ink response when pressed. If this property is
    /// null then the highlight color of the theme, [ThemeData.highlightColor],
    /// will be used.
    ///
    /// See also:
    ///
    ///  * [hoverColor], the color of the hover highlight.
    ///  * [focusColor], the color of the focus highlight.
    ///  * [highlightShape], the shape of the focus, hover, and pressed
    ///    highlights.
    ///  * [splashColor], the color of the splash.
    ///  * [splashFactory], which defines the appearance of the splash.
    final Color? highlightColor;
  
    /// Defines the ink response focus, hover, and splash colors.
    ///
    /// This default null property can be used as an alternative to
    /// [focusColor], [hoverColor], [highlightColor], and
    /// [splashColor]. If non-null, it is resolved against one of
    /// [WidgetState.focused], [WidgetState.hovered], and
    /// [WidgetState.pressed]. It's convenient to use when the parent
    /// widget can pass along its own MaterialStateProperty value for
    /// the overlay color.
    ///
    /// [WidgetState.pressed] triggers a ripple (an ink splash), per
    /// the current Material Design spec. The [overlayColor] doesn't map
    /// a state to [highlightColor] because a separate highlight is not
    /// used by the current design guidelines. See
    /// https://material.io/design/interaction/states.html#pressed
    ///
    /// If the overlay color is null or resolves to null, then [focusColor],
    /// [hoverColor], [splashColor] and their defaults are used instead.
    ///
    /// See also:
    ///
    ///  * The Material Design specification for overlay colors and how they
    ///    match a component's state:
    ///    <https://material.io/design/interaction/states.html#anatomy>.
    final WidgetStateProperty<Color?>? overlayColor;
  
    /// The splash color of the ink response. If this property is null then the
    /// splash color of the theme, [ThemeData.splashColor], will be used.
    ///
    /// See also:
    ///
    ///  * [splashFactory], which defines the appearance of the splash.
    ///  * [radius], the (maximum) size of the ink splash.
    ///  * [highlightColor], the color of the highlight.
    final Color? splashColor;
  
    /// Defines the appearance of the splash.
    ///
    /// Defaults to the value of the theme's splash factory: [ThemeData.splashFactory].
    ///
    /// See also:
    ///
    ///  * [radius], the (maximum) size of the ink splash.
    ///  * [splashColor], the color of the splash.
    ///  * [highlightColor], the color of the highlight.
    ///  * [InkSplash.splashFactory], which defines the default splash.
    ///  * [InkRipple.splashFactory], which defines a splash that spreads out
    ///    more aggressively than the default.
    final InteractiveInkFeatureFactory? splashFactory;
  
    /// Whether detected gestures should provide acoustic and/or haptic feedback.
    ///
    /// For example, on Android a tap will produce a clicking sound and a
    /// long-press will produce a short vibration, when feedback is enabled.
    ///
    /// See also:
    ///
    ///  * [Feedback] for providing platform-specific feedback to certain actions.
    final bool enableFeedback;
  
    /// Whether to exclude the gestures introduced by this widget from the
    /// semantics tree.
    ///
    /// For example, a long-press gesture for showing a tooltip is usually
    /// excluded because the tooltip itself is included in the semantics
    /// tree directly and so having a gesture to show it would result in
    /// duplication of information.
    final bool excludeFromSemantics;
  
    /// Handler called when the focus changes.
    ///
    /// Called with true if this widget's node gains focus, and false if it loses
    /// focus.
    final ValueChanged<bool>? onFocusChange;
  
    /// {@macro flutter.widgets.Focus.autofocus}
    final bool autofocus;
  
    /// {@macro flutter.widgets.Focus.focusNode}
    final FocusNode? focusNode;
  
    /// {@macro flutter.widgets.Focus.canRequestFocus}
    final bool canRequestFocus;
  
    /// The rectangle to use for the highlight effect and for clipping
    /// the splash effects if [containedInkWell] is true.
    ///
    /// This method is intended to be overridden by descendants that
    /// specialize [InkResponse] for unusual cases. For example,
    /// [TableRowInkWell] implements this method to return the rectangle
    /// corresponding to the row that the widget is in.
    ///
    /// The default behavior returns null, which is equivalent to
    /// returning the referenceBox argument's bounding box (though
    /// slightly more efficient).
    RectCallback? getRectCallback(RenderBox referenceBox) => null;
  
    /// Represents the interactive "state" of this widget in terms of
    /// a set of [WidgetState]s, like [WidgetState.pressed] and
    /// [WidgetState.focused].
    ///
    /// Classes based on this one can provide their own
    /// [WidgetStatesController] to which they've added listeners.
    /// They can also update the controller's [WidgetStatesController.value]
    /// however, this may only be done when it's safe to call
    /// [State.setState], like in an event handler.
    final WidgetStatesController? statesController;
  
    /// The duration of the animation that animates the hover effect.
    ///
    /// The default is 50ms.
    final Duration? hoverDuration;
  
    const ClickProps({
      this.containedInkWell = true,
      this.highlightShape = BoxShape.rectangle,
      this.onFocusChange,
      this.focusNode,
      this.statesController,
      this.borderRadius,
      this.customBorder,
      this.enableFeedback = true,
      this.excludeFromSemantics = false,
      this.splashFactory,
      this.autofocus = false,
      this.canRequestFocus = true,
      this.focusColor,
      this.highlightColor,
      this.hoverColor,
      this.hoverDuration,
      this.mouseCursor,
      this.onDoubleTap,
      this.onHover,
      this.onSecondaryTap,
      this.onLongPress,
      this.onSecondaryTapCancel,
      this.onSecondaryTapDown,
      this.onSecondaryTapUp,
      this.overlayColor,
      this.radius,
      this.splashColor,
      this.onHighlightChanged,
      this.onTapCancel,
      this.onTapUp,
      this.onTapDown,
    });
  }
  