fis_lib_measure/lib/process/annotations/annotation.dart

import 'package:fis_common/event/event_type.dart';
import 'package:fis_measure/interfaces/date_types/point.dart';
import 'package:fis_measure/interfaces/enums/annotation.dart';
import 'package:fis_measure/interfaces/process/annotations/annotation.dart';
import 'package:fis_measure/interfaces/process/workspace/point_info.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/painting.dart';

abstract class AnnotationItem<T extends AnnotationItemFeature>
    implements IAnnotationItem {
  late AnnotationType _type;
  late AnnotationStates _state;
  final List<IAnnotationItemFeature> _features = [];
  T? _feature;
  String? _text;

  @override
  late final FEventHandler<IAnnotationItemFeature?> featureUpdated;

  AnnotationItem(AnnotationType type) {
    _type = type;
    _state = AnnotationStates.waiting;
    featureUpdated = FEventHandler<IAnnotationItemFeature?>();
  }

  @override
  AnnotationType get type => _type;

  @override
  AnnotationStates get state => _state;
  set state(AnnotationStates value) {
    if (value != _state) {
      _state = value;
    }
  }

  @override
  T? get feature => _feature;
  set feature(T? value) {
    if (value != _feature) {
      _feature = value;
    }
  }

  @override
  List<IAnnotationItemFeature> get features => _features;

  @override
  String? get text => _text;
  @override
  set text(String? value) {
    if (value != text) {
      _text = value;
    }
  }

  @override
  void finishLast() {
    doFeatureFinish();
  }

  @override
  bool execute(PointInfo args) {
    bool result = false;
    switch (args.pointType) {
      case PointInfoType.mouseUp:
      case PointInfoType.mouseDown:
      case PointInfoType.mouseMove:
        result = onExecuteMouse(args);
        break;
      case PointInfoType.touchUp:
      case PointInfoType.touchDown:
      case PointInfoType.touchMove:
        result = onExecuteTouch(args);
        break;
    }
    if (result) {
      doFeatureUpdate();
    }
    return result;
  }

  /// 处理鼠标手势
  @protected
  bool onExecuteMouse(PointInfo args);

  /// 处理触摸手势
  @protected
  bool onExecuteTouch(PointInfo args);

  @protected
  void doFeatureFinish([bool saveFeature = true]) {
    if (saveFeature && feature != null) {
      feature!.isActive = false;
      features.add(feature!);
    }
    feature = null;
    state = AnnotationStates.finish;
  }

  @protected
  void doFeatureUpdate() {
    featureUpdated.emit(this, feature);
  }
}

abstract class AnnotationItemFeature extends IAnnotationItemFeature {
  late IAnnotationItem _ref;
  final List<DPoint> _points = [];
  bool _isActive = true;

  AnnotationItemFeature(IAnnotationItem ref) {
    _ref = ref;
  }

  IAnnotationItem get ref => _ref;

  List<DPoint> get points => _points;

  @override
  bool get isActive => _isActive;
  set isActive(bool value) => _isActive = value;

  @override
  DPoint get position => _points[0];
  set position(DPoint value) {
    if (_points.isEmpty) {
      _points.add(value);
    } else {
      _points[0] = value;
    }
  }

  @protected
  DPoint convert2ViewPoint(Size size, DPoint logicPoint) {
    final x = size.width * logicPoint.x;
    final y = size.height * logicPoint.y;
    return DPoint(x, y);
  }
}