搜尋套件、儲存庫與 APP 分類

draw_your_image 封面
套件詳情v0.12.1

draw_your_image

一個 Flutter 套件,可讓使用者在您設計的使用者介面中以手指進行繪圖。

AndroidiOSWebmacOSWindowsLinux
近 30 天下載
528
喜歡數
55
Pub 分數
160

安裝套件

flutter pub add draw_your_image

套件介紹

根據套件公開資料產生的選型評估,僅供參考。

Draw_Your_Image 是一個 Flutter 套件,允許使用者使用手指或觸控筆在自訂 UI 上直接繪製。它提供了一個簡單、互動式的畫布,用於在應用程式中進行草圖繪製、繪畫或簽名。適用於創意工具、筆記應用或數位簽名捕捉,支援多種平台,包括行動裝置、網頁和桌面。該套件與 Flutter 的小部件系統順暢整合,並提供可自訂的筆刷設定。它是開源的,由一位專注的開發者維護。

適用情境

  • 數位素描
  • 簽名捕獲
  • 互動式白板
  • 教育類繪圖應用
  • 創意設計工具

主要特色

  • 基於觸控的繪圖
  • 可自定的筆刷大小與顏色
  • 跨平台支援
  • 與 Flutter 的簡單整合
  • 開源程式碼庫

適合對象

  • 開發創意工具的應用程式開發者
  • 教育工作者建立互動式學習應用程式
  • 需要使用者簽名的應用程式
  • 需要繪圖功能的設計師
  • 原型設計互動式介面

使用建議

  • 效能可能在低階裝置上有所差異
  • 有限的高級編輯工具
  • 無內建匯出功能
  • 需要手動處理儲存/載入邏輯
  • 筆刷自定義選項相當基本

原始 README

以下為關聯原始碼儲存庫的 README 原文快照,最新內容請造訪原始碼儲存庫。

draw_your_image

A Flutter package for creating customizable drawing canvases with a declarative API.

demo gif of draw_your_image

Core Concept

Fully declarative, fully customizable

  • No controllers required - Manage stroke data in your widget state
  • Customize everything - Control stroke behavior through simple callbacks
  • Bring your own features - Implement undo/redo, zoom/pan, image export as your app needs

This package focuses on providing a flexible drawing widget, leaving app-specific features to you.

Features

✨ Device-aware drawing - Distinguish between stylus, finger, and mouse input
🎨 Flexible stroke handling - Customize behavior per input device or any other criteria
🖌️ Built-in smoothing - Catmull-Rom spline interpolation included
⚙️ Fully customizable - Colors, widths, smoothing algorithms
🔍 Intersection detection - Customizable stroke overlap detection

Quick Start

class MyDrawingPage extends StatefulWidget {
  @override
  _MyDrawingPageState createState() => _MyDrawingPageState();
}

class _MyDrawingPageState extends State<MyDrawingPage> {
  /// Store all the strokes on app side as state
  List<Stroke> _strokes = [];

  @override
  Widget build(BuildContext context) {
    return Draw(
      strokes: _strokes, // pass strokes via 
      onStrokeDrawn: (stroke) {
        // store new drawn stroke and rebuild
        setState(() {
          _strokes = [..._strokes, stroke];
        });
      },
    );
  }
}

That's it! The canvas accepts any input and draws with default settings.

Device-Aware Drawing with onStrokeStarted

The onStrokeStarted callback lets you control stroke behavior based on input devices or any other criteria.

Stroke? Function(Stroke newStroke, Stroke? currentStroke)

Parameters:

  • newStroke - The stroke about to be started
  • currentStroke - The stroke currently being drawn (null if none)

Return:

  • The stroke to draw (can be newStroke, currentStroke, or a modified version)
  • null to reject the stroke
Example: Stylus draws, finger erases

If you want to draw lines with stylus while erase them with a finger, the function can be implemented like below:

extension on PointerDeviceKind {
  bool get isStylus =>
      this == PointerDeviceKind.stylus ||
      this == PointerDeviceKind.invertedStylus;
}

Draw(
  strokes: _strokes,
  onStrokeDrawn: (stroke) => setState(() => _strokes = [..._strokes, stroke]),
  onStrokeStarted: (newStroke, currentStroke) {
    if (currentStroke != null) return currentStroke;

    if (newStroke.deviceKind.isStylus) {
      // if stylus, draw black line
      return newStroke.copyWith(color: Colors.black);
    } else {
      // if finger, pixel eraser — tag with data so strokePainter can identify it
      return newStroke.copyWith(data: {#erasing: true}, width: 20.0);
    }
  },
  strokePainter: (stroke) =>
      stroke.data?[#erasing] == true
          ? [eraseWithDefault(stroke)]
          : [paintWithDefault(stroke)],
)
Example: Stylus-only drawing

If pre-defined utility functions fit to your needs, you can pick one of them.

Draw(
  strokes: _strokes,
  onStrokeDrawn: (stroke) => setState(() => _strokes.add(stroke)),
  onStrokeStarted: stylusOnlyHandler,  // Pre-defined utility
)
Pre-defined Utilities
  • stylusOnlyHandler - Accept only stylus input
  • stylusPriorHandler - Prioritize stylus when drawing (palm rejection)

API Reference

Draw Widget Properties
Property Type Required Description
strokes List<Stroke> ✓ List of strokes to display
onStrokeDrawn void Function(Stroke) ✓ Called when a stroke is complete
onStrokeStarted Stroke? Function(Stroke, Stroke?) Control stroke behavior based on input
onStrokeUpdated Stroke? Function(Stroke) Modify stroke in real-time as points are added
onStrokesSelected void Function(List<Stroke>) Called when strokes are selected
strokeColor Color Default stroke color
strokeWidth double Default stroke width
backgroundColor Color Canvas background color
pathBuilder Path Function(Stroke) Function to build Path from a Stroke. Use for smoothing or pressure-sensitive effects
strokePainter List<Paint> Function(Stroke) Custom stroke painting function
intersectionDetector IntersectionDetector Custom intersection detection function
shouldAbsorbScale bool Function(PointerDownEvent) Control whether to absorb scale/pan pointer events from parent widgets like InteractiveViewer
shouldAbsorbLongPress bool Function(PointerDownEvent) Control whether to absorb long press pointer events from parent widgets like GestureDetector
Stroke Properties
class Stroke {
  PointerDeviceKind deviceKind;     // Input device type
  List<StrokePoint> points;         // Stroke points with pressure/tilt data
  Color color;                      // Stroke color
  double width;                     // Stroke width
}
StrokePoint

Each point in a stroke contains rich input data:

class StrokePoint {
  final Offset position;       // Position of the point
  final double pressure;       // Raw pressure (0.0 to 1.0+)
  final double pressureMin;    // Minimum pressure for this device
  final double pressureMax;    // Maximum pressure for this device
  final double tilt;           // Stylus tilt angle (0 to π/2 radians)
  final double orientation;    // Stylus orientation (-π to π radians)
  
  // Normalized pressure getter (0.0 to 1.0)
  double get normalizedPressure;
}

Note that all the parameters are originated in Flutter's PointerEvent. See documentation of PointerEvent for detailed information.

Key features:

  • tilt and orientation enable calligraphy-style effects
  • normalizedPressure automatically adjusts for device-specific pressure ranges
  • Works seamlessly with all input devices (stylus, touch, mouse)

Path Builder Modes

Path building algorithm is also customizable. You can choose pre-defined modes below or provide your own Path Function(Stroke).

PathBuilderMode.catmullRom.converter        // Smooth curves (default)
PathBuilderMode.none.converter              // No smoothing (straight lines)
PathBuilderMode.pressureSensitive.converter // Variable-width based on pressure

Pressure-Sensitive Drawing

Create variable-width strokes that respond to stylus pressure using PathBuilderMode.pressureSensitive:

Draw(
  strokes: _strokes,
  strokeWidth: 8.0,
  pathBuilder: PathBuilderMode.pressureSensitive.converter,
  onStrokeDrawn: (stroke) => setState(() => _strokes.add(stroke)),
)
Tilt-Based Effects

For advanced calligraphy effects using stylus tilt and orientation:

Path calligraphyPath(Stroke stroke) {
  for (final point in stroke.points) {
    // More tilt (flat stylus) = wider stroke
    final tiltFactor = 1.0 + (point.tilt / (math.pi / 2)) * 1.5;
    final width = baseWidth * tiltFactor * point.normalizedPressure;
    
    // Use orientation to rotate brush angle
    final angle = point.orientation;
    // ... create path with rotated brush shape
  }
}

Draw(
  pathBuilder: calligraphyPath,
  // ...
)

See example/lib/pages/tilt_demo_page.dart for a complete implementation.

Custom Stroke Painting with strokePainter

The strokePainter callback allows you to fully customize how strokes are rendered. You can create advanced visual effects like gradients, glows, shadows, and shader effects by returning multiple Paint objects.

Draw(
  strokePainter: (Stroke stroke) {
    final List<Paint> paint = _buildYourPaint(stroke);
    return paint;
  },
)

Parameters:

  • stroke - The stroke to be painted

Return:

  • A list of Paint objects to be applied to the stroke (in order)
Example: Gradient Effect
LayoutBuilder(
  builder: (context, constraints) {
    final canvasSize = Size(constraints.maxWidth, constraints.maxHeight);

    return Draw(
      strokes: _strokes,
      onStrokeDrawn: (stroke) => setState(() => _strokes.add(stroke)),
      strokePainter: (stroke) {
        final gradient = ui.Gradient.linear(
          Offset.zero,
          Offset(canvasSize.width, canvasSize.height),
          [Colors.blue, Colors.purple, Colors.pink],
        );

        return [
          Paint()
            ..shader = gradient
            ..strokeWidth = stroke.width
            ..strokeCap = StrokeCap.round
            ..style = PaintingStyle.stroke,
        ];
      },
    );
  },
)
Example: Multi-Layer Effect (Glow)
strokePainter: (stroke) {
  return [
    // Outer glow
    paintWithOverride(stroke, strokeWidth: stroke.width + 8, strokeColor: Colors.cyan)
      ..maskFilter = const MaskFilter.blur(BlurStyle.normal, 8),
    // Inner glow
    paintWithOverride(stroke, strokeWidth: stroke.width + 4, strokeColor: Colors.blue)
      ..maskFilter = const MaskFilter.blur(BlurStyle.normal, 4),
    // Core stroke
    paintWithDefault(stroke),
  ];
}
Helper Functions

The package provides utility functions for creating Paint objects:

  • paintWithDefault - Creates a paint with default properties
  • paintWithOverride - Creates a paint with overridden properties
  • eraseWithDefault - Creates a paint with BlendMode.clear for pixel-level erasing

Using with InteractiveViewer

The shouldAbsorbScale callback allows you to control which pointer events are handled by the Draw widget versus parent widgets like InteractiveViewer. This enables powerful combinations like:

  • Touch for pan/zoom, stylus for drawing
  • Device-specific gesture handling
  • Conditional pointer event absorption
InteractiveViewer(
  child: Draw(
    strokes: _strokes,
    shouldAbsorbScale: (event) {
      // Absorb stylus events for drawing, let touch events pass through for pan/zoom
      return event.kind == PointerDeviceKind.stylus ||
             event.kind == PointerDeviceKind.invertedStylus;
    },
    onStrokeDrawn: (stroke) => setState(() => _strokes.add(stroke)),
    onStrokeStarted: (newStroke, currentStroke) {
      if (currentStroke != null) return currentStroke;
      // Only draw with stylus (touch is for pan/zoom)
      return newStroke.deviceKind == PointerDeviceKind.stylus ? newStroke : null;
    },
  ),
)

See the example app for a complete implementation of touch-for-pan/stylus-for-draw functionality.

Working with AI Assistants

This package is designed to work well with AI coding assistants. If you want accurate response from AI agents, refer AI_GUIDE.md before asking.

所屬分類

原始碼儲存庫

使用此套件的專案

暫無相關資料。