standard_statefulImageView<ChildData extends WithLangText, DDModel extends DropDownModel<ChildData, WithOffline?>> function

Implementation

Widget standard_statefulImageView<ChildData extends WithLangText,
            DDModel extends DropDownModel<ChildData, WithOffline?>>(
        DDModel model, ChildData? data,
        {bool addImgIntent = false}) =>
    ChangeNotifierProvider<DDModel>.value(
        value: model,
        // child: ChangeNotifierProvider<ChildData>.value(
        //   value: data,
        child: Builder(builder: (context) {
          return Consumer<DDModel>(builder: (context, model, child) {
            // return Consumer<ChildData>(builder: (context, data, child) {
            return FutureBuilder<ChildData?>(
                future: model.currentlyChosenChildData,
                builder: (context, snapshot) {
                  var hasMain = snapshot.data?.mainImage != null &&
                      (snapshot.data!.mainhash ??
                              Options().no_image_placeholder_name) !=
                          Options().no_image_placeholder_name;
                  Future<XFile?> _toShareXFile(Object hash) async {
                    final owner = snapshot.data ?? data;
                    if (owner == null) return null;

                    final scope =
                        API().local.scopeFor(owner, caller: model.currentData);
                    final file = await resolveImageFileByHash(
                      hash.toString(),
                      scope: scope,
                    );

                    if (file == null) return null;
                    final decoded =
                        imglib.decodeImage(await file.readAsBytes());
                    if (decoded == null) return null;

                    return XFile.fromData(
                      Uint8List.fromList(imglib.encodePng(decoded)),
                      name: 'mbg_${hash.hashCode.toRadixString(36)}.png',
                      mimeType: 'image/png',
                    );
                  }

                  Future<void> _deleteByHash(Object hash,
                      {bool withToast = true}) async {
                    if (withToast) {
                      showToast(S.of(context).deletingImageThisMayTakeASec);
                    }
                    final value = await model.updateCurrentChild(
                      (data) => API().deleteImageByHash(
                        data,
                        hash.toString(),
                        caller: model.currentData,
                        forceUpdate: true,
                      ),
                    );
                    _maybeShowToast(value);
                  }

                  Future<void> _deleteManyByHash(List<Object> hashes) async {
                    if (hashes.isEmpty) return;
                    showToast('Lösche ${hashes.length} Bilder...');
                    final value =
                        await model.updateCurrentChild<String?>((data) async {
                      String? lastResponse;
                      for (final hash in hashes) {
                        lastResponse = await API().deleteImageByHash(
                          data,
                          hash.toString(),
                          caller: model.currentData,
                          forceUpdate: true,
                        );
                      }
                      return lastResponse;
                    });
                    _maybeShowToast(value);
                  }

                  return Stack(
                    children: [
                      ImagesPage.futured(
                        intendsToAddPicture: addImgIntent,
                        hasMainImage: hasMain,
                        futureImages: [
                          if (hasMain) snapshot.data!.mainImage,
                          ...?((snapshot.data ?? data)?.imageFutures)
                        ],
                        onNewImages: (files) async {
                          showToast(
                              S.of(context).newImageSendingThisMayTakeASec);
                          var value = await model.updateCurrentChild(
                            (data) async {
                              var ret = await API().uploadNewImagesOrFiles(
                                  data, files,
                                  caller: model.currentData, forceUpdate: true);
                              // await Future.delayed(Duration(seconds: 5));
                              return ret;
                            },
                          );

                          _maybeShowToast(value);
                          return value;
                        },
                        onStar: (hash) {
                          showToast(
                              S.of(context).settingMainImageThisMayTakeASec);
                          model
                              .updateCurrentChild((data) => API()
                                  .setMainImageByHash(data, hash.toString(),
                                      caller: model.currentData,
                                      forceUpdate: true))
                              .then((value) {
                            _maybeShowToast(value);
                            return value;
                          });
                        },
                        onDelete: (hash) async {
                          await _deleteByHash(hash);
                        },
                        onRotate: (hash, deltaQuarterTurns) async {
                          showToast('Drehe Bild...');
                          final value = await model.updateCurrentChild(
                            (data) => API().rotateImageByHash(
                              data,
                              hash.toString(),
                              quarterTurns: deltaQuarterTurns,
                              caller: model.currentData,
                              forceUpdate: true,
                            ),
                          );
                          _maybeShowToast(value);
                        },
                        onDeleteMany: (hashes) async {
                          await _deleteManyByHash(hashes.cast<Object>());
                        },
                        onShare: (hash) async {
                          final xfile = await _toShareXFile(hash);
                          if (xfile == null) {
                            showToast(S.of(context).somethingWentWrong);
                            return;
                          }
                          await Share.shareXFiles([xfile],
                              text: 'Internes Bild');
                        },
                        onShareMany: (hashes) async {
                          final xfiles = <XFile>[];
                          for (final hash in hashes) {
                            final xfile = await _toShareXFile(hash);
                            if (xfile != null) xfiles.add(xfile);
                          }
                          if (xfiles.isEmpty) {
                            showToast(S.of(context).somethingWentWrong);
                            return;
                          }
                          await Share.shareXFiles(
                            xfiles,
                            text: xfiles.length == 1
                                ? 'Internes Bild'
                                : 'Interne Bilder',
                          );
                        },
                      ),
                      if (snapshot.connectionState == ConnectionState.waiting)
                        Card(
                          child:
                              Text(S.of(context).pleaseWaitDataIsBeeingSynced),
                        ),
                    ],
                  );
                });
          });
        })
        // ;
        // }),
        // ),
        );