在 CUBA 应用程序中使用图片

<form id="fieldGroup" dataContainer="vetDc">
    <column width="250px">

        <textField property="firstName"/>
        <textField property="lastName"/>

        <upload id="imageField"
                property="image" (1)
                fileStoragePutMode="IMMEDIATE"
                showFileName="true"
        />

    </column>
</form>

public class VetBrowse extends StandardLookup<Vet> {

    @Inject
    protected GroupTable<Vet> vetsTable;

    @Inject
    protected UiComponents uiComponents;

    @Subscribe
    protected void onInit(InitEvent event) {
        vetsTable.addGeneratedColumn( (1)
                "image",
                this::renderAvatarImageComponent
        );
    }

    private Component renderAvatarImageComponent(Vet vet) {
        FileDescriptor imageFile = vet.getImage(); (2)
        if (imageFile == null) {
            return null;
        }
        Image image = smallAvatarImage();
        image.setSource(FileDescriptorResource.class)
                .setFileDescriptor(imageFile); (4)

        return image;
    }

    private Image smallAvatarImage() {
        Image image = uiComponents.create(Image.class);  (3)
        image.setScaleMode(Image.ScaleMode.CONTAIN);
        image.setHeight("40");
        image.setWidth("40");
        image.setStyleName("avatar-icon-small");
        return image;
    }
}

public class VisitEdit extends StandardEditor<Visit> {

    @Inject
    protected Form treatingVetForm;

    @Inject
    protected InstanceContainer<Visit> visitDc;

    // ...

    @Subscribe
    protected void renderTreatingVetLayout(AfterShowEvent event) {

        VetPreviewComponentFactory vetPreviewComponentFactory =
            new VetPreviewComponentFactory( (1)
                uiComponents,
                screenBuilders,
                messageBundle,
                this
            );

        Component vetPreview = vetPreviewComponentFactory.create(  (2)
                visitDc,
                vet -> getEditedEntity().setTreatingVet(vet)
        );

        treatingVetForm.add(vetPreview); (3)
    }
}

public class VetPreviewComponentFactory {

    private final UiComponents uiComponents;
    private final ScreenBuilders screenBuilders;
    private final FrameOwner frameOwner;

    public Component create( (1)
            InstanceContainer<Visit> visitDc,
            Consumer<Vet> vetSelectionHandler
    ){
        return verticalLayout(
                vetImage(visitDc),
                horizontalLayout(
                        treatingVetName(visitDc),
                        editVetButton(vetSelectionHandler)
                )
        );
    }

    // ...

    private Image vetImage(InstanceContainer<Visit> visitDc) {

        Image image = uiComponents.create(Image.class);
        // ...
        image.setValueSource(
                new ContainerValueSource<>(visitDc, "treatingVet.image") (2)
        );
        return image;
    }

    private Button editVetButton(Consumer<Vet> vetSelectionHandler) {

        LinkButton button = uiComponents.create(LinkButton.class);
        // ...
        button.setAction(
                new BaseAction("changeVet")
                .withHandler(event -> openVetLookup(event, vetSelectionHandler)) (3)
        );
        return button;
    }

    private void openVetLookup(
            Action.ActionPerformedEvent event,
            Consumer<Vet> vetSelectionHandler
    ) {
        screenBuilders.lookup(Vet.class, frameOwner)
                .withOpenMode(OpenMode.DIALOG)
                .withSelectHandler(
                        vets -> vetSelectionHandler.accept(vets.iterator().next())
                )
                .show();
    }
}

<upload id="upload"
        showClearButton="false"
        uploadButtonIcon="UPLOAD"
        uploadButtonCaption=""
        fileStoragePutMode="MANUAL" (1)
        permittedExtensions=".png,.jpg,.pdf" (2)
        dropZone="contentHBox" (3)
        showFileName="false"/>

public class VisitEdit extends StandardEditor<Visit> {

    @Inject
    protected CollectionPropertyContainer<FileDescriptor> xRayImagesDc;

    @Inject
    protected FileUploadField upload;

    @Inject
    protected DataContext dataContext;

    @Inject
    protected FileUploadingAPI fileUploadingAPI;

    @Subscribe("upload")
    protected void onUploadFileUploadSucceed(
            FileUploadField.FileUploadSucceedEvent event
    ) {
        FileDescriptor imageDescriptor = upload.getFileDescriptor(); (1)

        try {
            fileUploadingAPI.putFileIntoStorage(upload.getFileId(), imageDescriptor); (2)

            FileDescriptor savedImageDescriptor = dataManager.commit(imageDescriptor);
            newImageDescriptors.add(savedImageDescriptor);

            xRayImagesDc.getMutableItems().add(savedImageDescriptor); (3)
            /* ... */
        } catch (FileStorageException e) {
            /* ... */
        }
    }
}

<hbox id="contentHBox" spacing="true" width="100%">
    <table id="xRayImagesTable"
           dataContainer="xRayImagesDc"
           width="100%"
           height="100%"
           columnControlVisible="false">
        <actions>
            <action id="download" trackSelection="true" icon="DOWNLOAD"/>
            <action id="edit" type="edit"/>
            <action id="remove" type="remove"/>
        </actions>
        <columns>
            <column id="name"/>
        </columns>
    </table>
    <hbox id="xrayImageWrapperLayout"
          height="100%"
          width="100%"
          spacing="true">
    </hbox>
</hbox>

public class VisitEdit extends StandardEditor<Visit> {

    @Inject
    protected Table<FileDescriptor> xRayImagesTable;

    @Subscribe("xRayImagesTable")
    protected void onXRayImagesTableSelection(
            Table.SelectionEvent<FileDescriptor> event
    ) {
        xrayImageWrapperLayout.removeAll();
        Set<FileDescriptor> selectedXrayImages = event.getSelected(); (1)
        if (!selectedXrayImages.isEmpty()) {
            xrayImageWrapperLayout.add( (2)
                    xrayImage(
                            selectedXrayImages.iterator().next()
                    )
            );
        }
    }

    private Component xrayImage(FileDescriptor file) {
        XrayPreviewComponentFactory factory = new XrayPreviewComponentFactory(
                uiComponents,
                messageBundle
        );

        return factory.create(file); (3)
    }
}

public class XrayPreviewComponentFactory {

    public Component create(FileDescriptor file) {
        GroupBoxLayout groupBoxLayout = uiComponents.create(GroupBoxLayout.class);
        groupBoxLayout.setShowAsPanel(true); (1)
        groupBoxLayout.setStyleName("well");
        groupBoxLayout.setCaption(
                messageBundle.formatMessage("previewFile", file.getName())
        );
        if (isPdf(file)) {
            groupBoxLayout.add(xrayPdfComponent(file));
        }
        else if (isImage(file)){
            groupBoxLayout.add(xrayImageComponent(file));
        }
        return groupBoxLayout;
    }

    private boolean isPdf(FileDescriptor file) {
        return file.getExtension().contains("pdf");
    }

    // ...

    private Component xrayImageComponent(FileDescriptor imageFile) {
        Image image = uiComponents.create(Image.class);
        image.setScaleMode(Image.ScaleMode.SCALE_DOWN);
        image.setSource(FileDescriptorResource.class)
                .setFileDescriptor(imageFile); (2)
        return image;
    }

    private Component xrayPdfComponent(FileDescriptor imageFile) {
        BrowserFrame browserFrame = uiComponents.create(BrowserFrame.class);
        browserFrame.setSource(FileDescriptorResource.class)
                .setFileDescriptor(imageFile)
                .setMimeType(MediaType.APPLICATION_PDF_VALUE); (3)
        return browserFrame;
    }
}

public class VisitEdit extends StandardEditor<Visit> {

    @Inject
    protected ExportDisplay exportDisplay;

    @Subscribe("xRayImagesTable.download")
    protected void onXRayImagesTableDownload(Action.ActionPerformedEvent event) {
        downloadFile(xRayImagesTable.getSingleSelected());
    }

    private void downloadFile(FileDescriptor file) {
        exportDisplay.show(file, ExportFormat.OCTET_STREAM);
    }
}