Éditeur de feuille de calcul - Travailler avec des fichiers

Table des matières

Fichiers pris en charge

HTML5 Spreadsheet Editor peut ouvrir des fichiers dans les formats suivants :

  • Excel 1997-2003 XLS
  • Excel 2007-2013 XLSX
  • XLSM
  • XLSB
  • XLTX
  • SpreadsheetML
  • SVC
  • OuvrirDocument

Ouvrir les fichiers locaux

Pour télécharger un fichier depuis un ordinateur local :

  1. Basculer versOnglet Fichier en haut.
  2. Cliquez surOuvrir à partir de l’ordinateur pour ouvrir la boîte de dialogue Parcourir.
  3. Accédez à l’emplacement de fichier souhaité.
  4. Cliquez sur le fichier souhaité pour le sélectionner.
  5. Cliquez surOuvrir.

Le fichier sera ouvert dans l’éditeur.

tâche : image_autre_texte

Comment ça fonctionne?

Téléchargement de fichiers

L’utilisateur sélectionne un fichier à partir de l’ordinateur local qui est téléchargé du navigateur Web vers le serveur et reçu parFichier PrimeFacesTélécharger composant.

 <p:fileUpload fileUploadListener="#\{workbook.onFileUpload\}" update=":ribbon :intro :sheet" />

Gestion du classeur

Dès que le fichier est téléchargé complètement, la méthode WorkbookService.onFileUpload entre en action pour gérer la situation. WorkbookService reçoit les événements du navigateur Web et suit l’état de l’ensemble du classeur. Le WorkbookService.onFileUpload transmet le contrôle à LoaderService pour charger le classeur en mémoire. Comme letéléchargement de fichiers Le composant fournit le fichier téléchargé en tant queFlux d’entrée, le LoaderService le charge à l’aide de la méthode LoaderService.fromInputStream.

 public void onFileUpload(FileUploadEvent e) {

    this.current = loader.fromInputStream(e.getFile().getInputstream(), e.getFile().getFileName());

}

Chargement et déchargement

La méthodeLoaderService.fromInputStream lit leFlux d’entrée fourni par fileUploadcomposant créer une instance decom.aspose.cells.Workbookclasse. Cette instance est conservée en mémoire tant que l’utilisateur continue d’afficher ou de modifier la feuille de calcul dans le navigateur Web. Lorsque l’utilisateur quitte l’éditeur ou ferme le navigateur, les instances inutilisées sont automatiquement déchargées de la mémoire pour garder le serveur propre.

 public String fromInputStream(InputStream s, String name) {

    com.aspose.cells.Workbook w;

    try (InputStream i = s) {

        w = new com.aspose.cells.Workbook(i);

    } catch (Exception x) {

        return null;

    }

    String key = this.generateKey();

    this.workbooks.put(key, w);

    this.buildCellsCache(key);

    this.buildColumnWidthCache(key);

    this.buildRowHeightCache(key);

    return key;

}

Mise en cache

La mise en cache est très importante pour HTML5 Spreadsheet Editor. Cela fait que tout fonctionne en douceur. Le CellsService conserve les lignes, les colonnes, les cellules et les propriétés du cache de tous les classeurs chargés par l’éditeur. Lorsque LoaderService charge complètement une feuille de calcul, il la lit de haut en bas et remplit le cache en appelant LoaderService.buildCellsCache, LoaderService.buildColumnWidthCache, LoaderService.buildRowHeightCache

     public void buildCellsCache(String key) {

        com.aspose.cells.Workbook wb = workbooks.get(key);

        com.aspose.cells.Worksheet ws = wb.getWorksheets().get(wb.getWorksheets().getActiveSheetIndex());

        int maxColumn = ws.getCells().getMaxColumn() + 1;

        maxColumn = maxColumn + 26 - (maxColumn % 26);

        int maxRow = 20 + ws.getCells().getMaxRow() + 1;

        maxRow = maxRow + 10 - (maxRow % 10);

        ArrayList<Column> columns = new ArrayList<>(maxColumn);

        ArrayList<Row> rows = new ArrayList<>(maxRow);

        for (int i = 0; i < maxColumn; i++) {

            columns.add(i, new Column(i, com.aspose.cells.CellsHelper.columnIndexToName(i)));

        }

        for (int i = 0; i < maxRow; i++) {

            rows.add(i, new Row.Builder().setId(i).build());

        }

        for (Object o : ws.getCells()) {

            com.aspose.cells.Cell c = (com.aspose.cells.Cell) o;

            rows.get(c.getRow()).putCell(c.getColumn(), cells.fromAsposeCell(c));

        }

        for (int i = 0; i < maxRow; i++) {

            for (int j = 0; j < maxColumn; j++) {

                String col = com.aspose.cells.CellsHelper.columnIndexToName(j);

                if (!rows.get(i).getCellsMap().containsKey(col)) {

                    rows.get(i).putCell(col, cells.fromBlank(j, i));

                }

            }

        }

        cells.putColumns(key, columns);

        cells.putRows(key, rows);

    }

LoaderService.buildColumnWidthCache

     public void buildColumnWidthCache(String key) {

        com.aspose.cells.Workbook wb = workbooks.get(key);

        com.aspose.cells.Worksheet ws = wb.getWorksheets().get(wb.getWorksheets().getActiveSheetIndex());

        ArrayList<Integer> columnWidth = new ArrayList<>();

        for (int i = 0; i < cells.getColumns(key).size(); i++) {

            columnWidth.add(i, ws.getCells().getColumnWidthPixel(i));

        }

        cells.putColumnWidth(key, columnWidth);

    }

LoaderService.buildRowHeightCache

     public void buildRowHeightCache(String key) {

        com.aspose.cells.Workbook wb = workbooks.get(key);

        com.aspose.cells.Worksheet ws = wb.getWorksheets().get(wb.getWorksheets().getActiveSheetIndex());

        ArrayList<Integer> rowHeight = new ArrayList<>();

        for (int i = 0; i < cells.getRows(key).size(); i++) {

            rowHeight.add(i, ws.getCells().getRowHeightPixel(i));

        }

        cells.putRowHeight(key, rowHeight);

    }

Ouvrir depuis Dropbox

Pour ouvrir des fichiers depuis Dropbox :

  1. Basculer versOnglet Fichier en haut.
  2. Cliquez surOuvrir depuis Dropbox pour ouvrir le sélecteur de fichiers Dropbox.
  3. Si vous n’êtes pas déjà connecté, vous devrez vous connecter à votre compte Dropbox.
  4. Naviguez jusqu’au fichier souhaité et cliquez dessus pour le sélectionner.
  5. Cliquez surChoisir au fond.

Votre fichier sélectionné sera ouvert à partir de Dropbox.

tâche : image_autre_texte

Comment ça fonctionne?

LeOuvrir depuis Dropbox bouton utiliseSélecteur JavaScript Dropbox API pour ouvrir la boîte de dialogue Sélecteur de Dropbox. Le sélecteur fournit l’URL du fichier sélectionné, qui est capturé par la fonction de rappel et renvoyé au serveur. Le serveur crée une instance de feuille de calcul à partir de l’URL, initialise certains éléments d’entretien et renvoie les mises à jour DOM au navigateur. Le navigateur affiche et actualise le HTML et l’utilisateur est prêt à modifier le document chargé.

Ouvrir à partir de l’URL

Les fichiers peuvent être ouverts directement à partir d’URL. Cela permet à l’utilisateur de modifier n’importe quel fichier accessible au public sur Internet. Pour ouvrir le fichier ajouter**?url=emplacement** paramètre avec la valeur de votre choix**lieu** lors du chargement de l’éditeur. Par exemple:

 http://editor.aspose.com/?url=http://example.com/Sample.xlsx

tâche : image_autre_texte

Comment ça fonctionne?

Instancier au démarrage

LorsqueFeuille de calcul le bean backend est instancié par JSF lePost-construction méthodeinitialiser est appelé qui charge la feuille de calcul à l’aide de LoaderService.fromUrl.

Mise en cache

La mise en cache se produit juste après le chargement de la feuille de calcul. LeLoaderService appelsLoaderService.buildCellsCache, LoaderService.buildColumnWidthCache etLoaderService.buildRowHeightCache un par un pour mettre en cache le contenu de la feuille de calcul et maintenir toutes les opérations rapides et fluides.

Mises à jour DOM

Lorsque la feuille de calcul est prête côté serveur, les composants JSF sont utilisés pour générer de nouveaux HTML et envoyer les mises à jour DOM à l’utilisateur qui sont rendues par le navigateur Web.

     @PostConstruct

    private void init() {

        String requestedSourceUrl = FacesContext.getCurrentInstance().getExternalContext().getRequestParameterMap().get("url");

        if (requestedSourceUrl != null) {

            try {

                this.sourceUrl = new URL(requestedSourceUrl).toString();

                this.loadFromUrl();

            } catch (MalformedURLException x) {

                msg.sendMessageDialog("The specified URL is invalid", requestedSourceUrl);

            }

        }

    }

LoaderService.fromUrlLoaderService.fromUrl

     public String fromUrl(String url) {

        com.aspose.cells.Workbook w;

        try (InputStream i = new URL(url).openStream()) {

            w = new com.aspose.cells.Workbook(i);

        } catch (Exception x) {

            throw new RuntimeException(x);

        }

        String key = generateKey();

        workbooks.put(key, w);

        buildCellsCache(key);

        buildColumnWidthCache(key);

        buildRowHeightCache(key);

        return key;

    }

LoaderService.buildCellsCache

     public void buildCellsCache(String key) {

        com.aspose.cells.Workbook wb = workbooks.get(key);

        com.aspose.cells.Worksheet ws = wb.getWorksheets().get(wb.getWorksheets().getActiveSheetIndex());

        int maxColumn = ws.getCells().getMaxColumn() + 1;

        maxColumn = maxColumn + 26 - (maxColumn % 26);

        int maxRow = 20 + ws.getCells().getMaxRow() + 1;

        maxRow = maxRow + 10 - (maxRow % 10);

        ArrayList<Column> columns = new ArrayList<>(maxColumn);

        ArrayList<Row> rows = new ArrayList<>(maxRow);

        for (int i = 0; i < maxColumn; i++) {

            columns.add(i, new Column(i, com.aspose.cells.CellsHelper.columnIndexToName(i)));

        }

        for (int i = 0; i < maxRow; i++) {

            rows.add(i, new Row.Builder().setId(i).build());

        }

        for (Object o : ws.getCells()) {

            com.aspose.cells.Cell c = (com.aspose.cells.Cell) o;

            rows.get(c.getRow()).putCell(c.getColumn(), cells.fromAsposeCell(c));

        }

        for (int i = 0; i < maxRow; i++) {

            for (int j = 0; j < maxColumn; j++) {

                String col = com.aspose.cells.CellsHelper.columnIndexToName(j);

                if (!rows.get(i).getCellsMap().containsKey(col)) {

                    rows.get(i).putCell(col, cells.fromBlank(j, i));

                }

            }

        }

        cells.putColumns(key, columns);

        cells.putRows(key, rows);

    }

LoaderService.buildColumnWidthCache

     public void buildColumnWidthCache(String key) {

        com.aspose.cells.Workbook wb = workbooks.get(key);

        com.aspose.cells.Worksheet ws = wb.getWorksheets().get(wb.getWorksheets().getActiveSheetIndex());

        ArrayList<Integer> columnWidth = new ArrayList<>();

        for (int i = 0; i < cells.getColumns(key).size(); i++) {

            columnWidth.add(i, ws.getCells().getColumnWidthPixel(i));

        }

        cells.putColumnWidth(key, columnWidth);

    }

LoaderService.buildRowHeightCache

     public void buildRowHeightCache(String key) {

        com.aspose.cells.Workbook wb = workbooks.get(key);

        com.aspose.cells.Worksheet ws = wb.getWorksheets().get(wb.getWorksheets().getActiveSheetIndex());

        ArrayList<Integer> rowHeight = new ArrayList<>();

        for (int i = 0; i < cells.getRows(key).size(); i++) {

            rowHeight.add(i, ws.getCells().getRowHeightPixel(i));

        }

        cells.putRowHeight(key, rowHeight);

    }

Créer une nouvelle feuille de calcul

Pour créer une nouvelle feuille de calcul vide :

  1. Basculer versOnglet Fichier.
  2. Clique leNouveau bouton.

L’éditeur fermera la feuille de calcul ouverte, le cas échéant, et en ouvrira une nouvelle.

tâche : image_autre_texte

Comment ça fonctionne?

Instancier un nouvel objet

Quand leNouveau le bouton est cliqué par l’utilisateur,WorksheetView.loadBlankWorksheetView.loadBlank , qui finit par appelerLoaderService.fromBlank. LoaderService crée une nouvelle instance de feuille de calcul vierge.

Mise en cache

La mise en cache se produit juste après le chargement de la feuille de calcul. LeLoaderService appelsLoaderService.buildCellsCache, LoaderService.buildColumnWidthCache etLoaderService.buildRowHeightCache un par un pour mettre en cache le contenu de la feuille de calcul et maintenir toutes les opérations rapides et fluides.

Mises à jour DOM

Lorsque la feuille de calcul est prête côté serveur, les composants JSF sont utilisés pour générer de nouveaux HTML et envoyer les mises à jour DOM à l’utilisateur qui sont rendues par le navigateur Web.

     public void loadBlank() {

        this.loadedWorkbook = loader.fromBlank();

    }

LoaderService.fromBlank

     public String fromBlank() {

        com.aspose.cells.Workbook w = new com.aspose.cells.Workbook();

        String key = generateKey();

        workbooks.put(key, w);

        buildCellsCache(key);

        buildColumnWidthCache(key);

        buildRowHeightCache(key);

        return key;

    }

buildCellsCachebuildCellsCache

     public void buildCellsCache(String key) {

        com.aspose.cells.Workbook wb = workbooks.get(key);

        com.aspose.cells.Worksheet ws = wb.getWorksheets().get(wb.getWorksheets().getActiveSheetIndex());

        int maxColumn = ws.getCells().getMaxColumn() + 1;

        maxColumn = maxColumn + 26 - (maxColumn % 26);

        int maxRow = 20 + ws.getCells().getMaxRow() + 1;

        maxRow = maxRow + 10 - (maxRow % 10);

        ArrayList<Column> columns = new ArrayList<>(maxColumn);

        ArrayList<Row> rows = new ArrayList<>(maxRow);

        for (int i = 0; i < maxColumn; i++) {

            columns.add(i, new Column(i, com.aspose.cells.CellsHelper.columnIndexToName(i)));

        }

        for (int i = 0; i < maxRow; i++) {

            rows.add(i, new Row.Builder().setId(i).build());

        }

        for (Object o : ws.getCells()) {

            com.aspose.cells.Cell c = (com.aspose.cells.Cell) o;

            rows.get(c.getRow()).putCell(c.getColumn(), cells.fromAsposeCell(c));

        }

        for (int i = 0; i < maxRow; i++) {

            for (int j = 0; j < maxColumn; j++) {

                String col = com.aspose.cells.CellsHelper.columnIndexToName(j);

                if (!rows.get(i).getCellsMap().containsKey(col)) {

                    rows.get(i).putCell(col, cells.fromBlank(j, i));

                }

            }

        }

        cells.putColumns(key, columns);

        cells.putRows(key, rows);

    }

buildColumnWidthCachebuildColumnWidthCache

     public void buildColumnWidthCache(String key) {

        com.aspose.cells.Workbook wb = workbooks.get(key);

        com.aspose.cells.Worksheet ws = wb.getWorksheets().get(wb.getWorksheets().getActiveSheetIndex());

        ArrayList<Integer> columnWidth = new ArrayList<>();

        for (int i = 0; i < cells.getColumns(key).size(); i++) {

            columnWidth.add(i, ws.getCells().getColumnWidthPixel(i));

        }

        cells.putColumnWidth(key, columnWidth);

    }

buildRowHeightCachebuildRowHeightCache

     public void buildRowHeightCache(String key) {

        com.aspose.cells.Workbook wb = workbooks.get(key);

        com.aspose.cells.Worksheet ws = wb.getWorksheets().get(wb.getWorksheets().getActiveSheetIndex());

        ArrayList<Integer> rowHeight = new ArrayList<>();

        for (int i = 0; i < cells.getRows(key).size(); i++) {

            rowHeight.add(i, ws.getCells().getRowHeightPixel(i));

        }

        cells.putRowHeight(key, rowHeight);

    }

Exporter vers divers formats

Après avoir modifié les fichiers, l’utilisateur voudra enregistrer les modifications. L’éditeur permet à l’utilisateur d’exporter et de télécharger la feuille de calcul modifiée sur l’ordinateur local. Pour exporter le fichier :

  1. Basculer versOnglet Fichier en haut.
  2. Cliquez surExporter comme bouton.
  3. Choisissez le format souhaité dans la liste déroulante.

Le fichier modifié sera exporté pour téléchargement. Les formats suivants sont pris en charge pour l’exportation :

  • Excel 2007-2013 XLSX
  • Excel 1997-2003 XLS
  • Excel XLSM
  • Excel XLSB
  • Excel XLTX
  • Excel XLTM
  • SpreadsheetML
  • Format de document portable (PDF)
  • Feuille de calcul OpenDocument (ODS)

Comment ça fonctionne?

La feuille de calcul ouverte est convertie au format spécifié par l’utilisateur à l’aide deWorksheetView.getOutputFileWorksheetView.getOutputFile.

     public StreamedContent getOutputFile(int saveFormat) {

        byte[] buf;

        String ext = null;

        switch (saveFormat) {

            case com.aspose.cells.SaveFormat.EXCEL_97_TO_2003:

                ext = "xls";

                break;

            case com.aspose.cells.SaveFormat.XLSX:

                ext = "xlsx";

                break;

            case com.aspose.cells.SaveFormat.XLSM:

                ext = "xlsm";

                break;

            case com.aspose.cells.SaveFormat.XLSB:

                ext = "xlsb";

                break;

            case com.aspose.cells.SaveFormat.XLTX:

                ext = "xltx";

                break;

            case com.aspose.cells.SaveFormat.XLTM:

                ext = "xltm";

                break;

            case com.aspose.cells.SaveFormat.SPREADSHEET_ML:

                ext = "xml";

                break;

            case com.aspose.cells.SaveFormat.PDF:

                ext = "pdf";

                break;

            case com.aspose.cells.SaveFormat.ODS:

                ext = "ods";

                break;

        }

        try {

            ByteArrayOutputStream out = new ByteArrayOutputStream();

            getAsposeWorkbook().save(out, saveFormat);

            buf = out.toByteArray();

        } catch (Exception x) {

            throw new RuntimeException(x);

        }

        return new DefaultStreamedContent(new ByteArrayInputStream(buf), "application/octet-stream", "Spreadsheet." + ext);

    }
Éditeur de feuille de calcul - Travailler avec des feuilles