fis_lib_measure/lib/process/workspace/third_part/calibration_controller.dart

import 'package:fis_common/event/event_type.dart';
import 'package:fis_measure/interfaces/date_types/point.dart';

import 'package:fis_measure/interfaces/process/standard_line/calibration.dart';
import 'package:fis_measure/interfaces/process/workspace/application.dart';
import 'package:fis_measure/interfaces/process/workspace/point_info.dart';
import 'package:flutter/material.dart';
import 'package:flutter/painting.dart';
import 'package:get/get.dart';

import 'standard_line.dart';

/// 参考线校准控制器
class StandardLineCalibrationController
    implements IStandardLineCalibrationController {
  final IApplication application;
  final StandardLine standardLine;

  StandardLineCalibrationEditState _editState =
      StandardLineCalibrationEditState.inactive;
  final List<DPoint> _drawPoints = [];

  StandardLineCalibrationController(
    this.application,
    this.standardLine,
  ) {
    updateReady = FEventHandler<void>();
    editStateChanged = FEventHandler<StandardLineCalibrationEditState>();
  }

  @override
  StandardLineCalibrationEditState get editState => _editState;

  @override
  bool get isEditing => editState != StandardLineCalibrationEditState.inactive;

  @override
  List<DPoint> get drawPoints => _drawPoints;

  @override
  double get displayLengthInPhysics {
    final pixelLengthInPhysics =
        standardLine.pixelLength / standardLine.physicsLength;
    final length = application.displayScaleRatio * pixelLengthInPhysics;
    return length;
  }

  @override
  late final FEventHandler<void> updateReady;
  @override
  late final FEventHandler<StandardLineCalibrationEditState> editStateChanged;

  @override
  void enterEditMode() {
    drawPoints.clear();
    _changeState(StandardLineCalibrationEditState.ready);
  }

  @override
  void cancelEdit() {
    _changeState(StandardLineCalibrationEditState.inactive);
  }

  @override
  void confirmEdit(double physicalLength) {
    standardLine.pixelLength = _getPixelLength();
    standardLine.physicsLength = physicalLength;
    _changeState(StandardLineCalibrationEditState.done);
    Future.delayed(const Duration(milliseconds: 100), () {
      _changeState(StandardLineCalibrationEditState.inactive);
    });
  }

  @override
  void executeGesturePoint(Offset offset, PointInfoType type) {
    if (editState != StandardLineCalibrationEditState.ready &&
        editState != StandardLineCalibrationEditState.drawing) {
      return;
    }

    if (editState == StandardLineCalibrationEditState.ready) {
      _changeState(StandardLineCalibrationEditState.drawing);
    }
    final point = _convert2Point(offset);
    if (type == PointInfoType.mouseDown) {
      if (drawPoints.length >= 2) {
        drawPoints[1] = point;
        _doLineDrawn();
      } else {
        drawPoints.add(point);
        _update();
      }
    } else if (type == PointInfoType.mouseMove) {
      if (drawPoints.length == 2) {
        drawPoints[1] = point;
      } else if (drawPoints.length == 1) {
        drawPoints.add(point);
      }
      _update();
    }
  }

  void _doLineDrawn() {
    _changeState(StandardLineCalibrationEditState.drawn);
  }

  void _changeState(StandardLineCalibrationEditState state) {
    _editState = state;
    editStateChanged.emit(this, state);
    _update();
  }

  void _update() {
    updateReady.emit(this, null);
  }

  double _getPixelLength() {
    final frame = application.frameData!;
    final size = Size(frame.width.toDouble(), frame.height.toDouble());

    final p1 = drawPoints[0].scale2Size(size);
    final p2 = drawPoints[1].scale2Size(size);

    final length = (p2 - p1).length.abs();
    return length;
  }

  DPoint _convert2Point(Offset offset) {
    final displaySize = application.displaySize;
    final x = offset.dx / displaySize.width;
    final y = offset.dy / displaySize.height;
    return DPoint(x, y);
  }
}