Die Bearbeitungs-Engine¶
Schreibzeug bearbeitet Dokumente mit sdkjs, der JavaScript-Engine von Euro-Office (einem Fork von ONLYOFFICE).
Sie läuft vollständig im Browser; einen Document Server gibt es nicht. Nur packages/editor-core spricht mit
ihr.
Woher sie kommt¶
engine/engine.json legt ein offizielles Release des Euro-Office Document Server fest.
bun run engine:prepare (engine/scripts/prepare.ts, das auch bun run dev ausführt) lädt dieses
Paket herunter, prüft seine SHA-256-Summe und baut engine/dist; dabei zeigt es jeden Schritt und den
Fortschritt des Downloads:
| Pfad | Was es ist |
|---|---|
sdkjs/{common,word,cell,slide,pdf} |
die gebaute Engine, wie das Release sie mitliefert (pdf enthält den PDF-Renderer drawingfile.wasm; der Code des PDF-Editors gehört zu word) |
sdkjs/common/AllFonts.js, fonts/ |
der Schriftindex und die Webfonts, erzeugt von allfontsgen aus dem Release aus dessen Open-Source-Schriften (core-fonts) |
sdkjs/slide/themes/ |
die Designs für Präsentationen (themes.js und ein Ordner pro Design), erzeugt von allthemesgen aus dem Release aus den mitgelieferten Designdateien, so wie es dessen Installationsskript tut (documentserver-generate-allfonts.sh) |
vendor/xregexp/, vendor/jquery/ |
globale Bibliotheken, die sdkjs benutzt, ohne sie zu laden (jQuery: das Seitenlayout des Texteditors) |
x2t/ |
der Konverter: x2t aus dem ONLYOFFICE-Core, nach WebAssembly kompiliert (cryptpad/onlyoffice-x2t-wasm), festgelegt in engine.json |
frame/x2t/worker.js |
der Worker, in dem x2t läuft (aus engine/frame) |
frame/editor/<editor>/main/index.html |
die Seiten, die die Engine beherbergen (aus engine/frame) |
dictionaries/<lang>/ |
Hunspell-Wörterbücher für die Rechtschreibprüfung, mit ihren Lizenzen (unten) |
licenses/ |
Lizenzen der Engine und der Schriften |
Ein neues Release von Euro-Office oder x2t kommt als Pull Request von Renovate, der version ändert;
der Workflow engine-pin.yml setzt dann auf dessen Branch asset und sha256 dieses Releases
(Abhängigkeiten aktualisieren).
allfontsgen ist ein Programm für Linux x86_64, deshalb braucht das Vorbereiten der Engine Linux (die CI
erledigt das und legt das Ergebnis im Cache ab, nach dem Hash der Spezifikation, der Skripte und der
Frame-Seiten).
Wie sie geladen wird¶
sdkjs findet seine eigenen Dateien relativ zur Seite unter ../../../../sdkjs/… und ../../../../fonts/
(common/libfont/loader.js, common/GlobalLoaders.js, common/zlib/zlib.js). Die Host-Seite liegt
deshalb vier Ordner unterhalb der Engine-Wurzel: <engine>/frame/editor/<editor>/main/index.html
(<engine> ist im Build /engine/<id>, siehe unten),
mit word für Textdokumente, cell für Tabellen, slide für Präsentationen und pdf für
PDFs (PDFs).
mountEngineFrame lädt diese Seite in einen iframe mit gleichem Ursprung (same-origin) und prüft, ob der
API-Konstruktor des Editors vorhanden ist (asc_docs_api für Texte und Präsentationen, spreadsheet_api für Tabellen). Der iframe hält die globalen Variablen der Engine
(Asc, AscCommon, AscFonts, …) aus der App heraus und gibt jedem Dokument eine eigene Engine.
Der iframe hat sein eigenes Object, Array und so weiter. sdkjs prüft Werte manchmal mit
instanceof (CNumInfo.Parse nimmt ein Objekt nur, wenn value instanceof Object gilt), und das schlägt
bei Objekten fehl, die im Fenster der App entstanden sind. Deshalb ist alles, was die Engine bekommt, ein
primitiver Wert, JSON-Text oder ein Objekt, das mit den Konstruktoren des Frames selbst erzeugt wurde
(new win.Asc.asc_CColor(…)).
Schnell geöffnet, auch auf dem Handy¶
Die Engine ist groß: Für ein Textdokument lädt der Browser etwa 68 MB (x2t.wasm 35 MB,
word/sdk-all.js 18 MB, fonts.wasm, die Schriften, die das Dokument benutzt). Folgendes sorgt dafür,
dass das nicht bei jedem Öffnen passiert und das erste Öffnen nicht aufhält:
- Dauerhaft behalten. Der Build legt die Engine in einen Ordner, der nach der vorbereiteten Engine
benannt ist,
/engine/<id>/(der Anfang des Stempels, denengine:preparenachengine/dist/.versionschreibt, ein Hash aus Release, Skripten und Frame-Seiten;apps/web/engine-plugin.ts), und die App lädt sie von dort (import.meta.env.ENGINE_PATH,apps/web/src/editor/engine.ts). Eine neue Engine bekommt einen neuen Namen, deshalb schickt der Server die Engine und die eigenen Skripte der App (/assets/, nach ihrem Inhalt benannt) mitCache-Control: immutablefür ein Jahr; alles andere, allen voranindex.html, mitno-cacheund einemETag, nach dem der Browser jedes Mal neu fragt und 304 bekommt, solange sich nichts geändert hat (apps/server/src/web.ts). Öffnest du ein Dokument ein zweites Mal, wird nichts von der Engine heruntergeladen. Dev und Preview liefern die Engine unter/engine/aus, mit oder ohne den Namen. - Komprimiert. Der Server komprimiert, was kleiner wird (Skripte, JSON, WebAssembly, die Schriften
der Engine), mit Brotli, wo der Browser es annimmt, sonst mit gzip, einmal pro Datei, und behält das
Ergebnis im Speicher (
apps/server/src/compression.ts): etwa 15 MB statt 68 beim ersten Öffnen. Brotli mit Qualität 5: x2t.wasm braucht etwa eine Sekunde, Qualität 11 würde zwei Minuten dauern. Deshalb legt das Docker-Image in seiner Engine-Schicht einmalig Brotli-Kopien mit Qualität 11 der großen Skripte und WebAssembly-Module an (engine/scripts/precompress.ts), und der Server schickt die Kopie neben einer Datei, wo es eine gibt: x2t.wasm in 6,8 MB statt 8,1,word/sdk-all.jsin 2,4 statt 2,9. Der lokale Server der Desktop-App schickt Dateien unverändert; sie verlassen den Rechner nie. - Gleichzeitig. Die Datei wird konvertiert, während der Frame lädt:
convertForEnginestartet x2t, sobald der Editor eingehängt wird, sodass x2t in seinem Worker herunterlädt, kompiliert und konvertiert, während der Frame sdkjs parst, und die Öffnen-Funktion des Editors nimmt das Ergebnis alsconvertedentgegen. Die API der Engine wird erzeugt, sobald der Frame da ist, nicht erst, wenn die Datei konvertiert ist: Das Erzeugen lädt den Rest der Engine (sdk-all.js,common/apiBase.js_init→loadSdk), und die Dokumentinfo folgt auf die Konvertierung, so wie web-apps sie erst setzt, wenn die API existiert und ihre Events gebunden sind (documenteditor/mobileMain.jsx;src/document.tsopenDocument). - Bevor danach gefragt wird. Während die Dateiliste angezeigt wird, holt die App die Dateien, auf die
ein Textdokument wartet, in den Cache des Browsers, eine nach der anderen und mit niedriger Priorität,
x2t zuerst (
prefetchedEngineFilesinsrc/prefetch.ts,apps/web/src/editor/prefetch-engine.ts). Verlässt du die Liste, wird die Datei, die gerade unterwegs ist, noch fertig geladen, aber keine weitere geholt. Nicht in der Entwicklung (dort wird die Engine jedes Mal neu geschickt), nicht für Dateien auf diesem Rechner (die Desktop-App, ein lokaler Ordner) und nicht, wenn der Browser bittet, Daten zu sparen (navigator.connection.saveData). - Kompiliert, während sie herunterlädt. Der Worker übergibt x2t.wasm an emscripten über
instantiateWasmmitWebAssembly.instantiateStreaming(engine/frame/x2t/worker.js, der Hook in x2t.jscreateWasm), nicht als Bytes (wasmBinary): Es wird kompiliert, während es ankommt, und Chromium hält den kompilierten Code neben der Datei im Cache, sodass das nächste Öffnen nicht noch einmal 35 MB kompiliert.
Gemessen mit dem Viewport eines Handys, 20 Mbit/s und 4-facher CPU-Drosselung (ein kurzes Textdokument, der Produktions-Build): Das erste Öffnen nach ein paar Sekunden in der Dateiliste dauert 2,7 s statt 8,1 bis 8,7 s. Das zweite Öffnen in einer neuen Seite dauert 3,4 s und jedes weitere etwa 1,1 s, wenn Chromium auch den kompilierten Code der Engine hat.
Code in Dokumenten läuft nicht¶
Weil der Frame denselben Ursprung hat, handelt er mit der Sitzung des angemeldeten Benutzers. sdkjs kann
Code ausführen, den ein Dokument mitbringt, in Closures, die window und document verbergen, aber nicht
parent, top, fetch oder location (common/macros.js _safe_eval_closure,
pdf/src/forms/formActions.js EvalScript). Schreibzeug hat keinen Makro-Editor und keine Plugins,
deshalb schaltet src/document-scripts.ts all das ab:
- JS-Makros (Texte, Tabellen, Präsentationen):
createDocInfosetztput_IsEnabledMacroses(false), wasasc_runMacros(ein Klick auf eine Form oder Schaltfläche, die mit einem Makro verbunden ist) undasc_runAutostartMacrosesprüfen (common/apiBase.js). - Eigene Funktionen einer Tabelle: Die Engine wertet die aus, die eine Datei beim Öffnen mitbringt
(
cell/api.js_openDocumentEndCallback→registerCustomFunctionsLibrary,cell/api_plugins.js), ohne den Makro-Schalter zu fragen, und die Änderung eines Mitbearbeiters kann neue setzen (SetCustomFunctions).withoutCustomFunctionsersetzt diese Methode auf dem API-Objekt. - JavaScript-Aktionen eines PDFs (die Format-, Tastendruck- und Berechnungsskripte eines Feldes,
Link-Aktionen):
CActionRunScriptführt sie ganz ohne Schalter aus.silencePdfScriptslässt jede Aktion als leeres Skript laufen, unmittelbar bevor die Engine das PDF liest (beforeOpeningumhülltopenDocument: Der PDF-Code steckt insdk-all.js, dassdk-all-min.jserst lädt, wenn die API existiert,common/editorscommon.jsloadSdk). Die Warteschlange der Aktionen läuft weiter wie bisher, und das Skript bleibt in der Datei; ein Feld, das ein Skript formatiert (AFNumber_Format), zeigt den reinen Wert.
sdk-all.js lässt sich dafür nicht aus engine/dist weglassen: Jeder Editor lädt es. Stattdessen zählt
engine/scripts/prepare.ts (checkScriptHooks) in den gebauten Bundles die Stellen, auf die sich diese
Schalter verlassen, und bricht ab, wenn ein Engine-Update eine davon verschiebt.
Warum ein Konverter¶
Die Engine öffnet und speichert ihr eigenes Binärformat („DOCY“, „XLSY“, „PPTY“). OOXML direkt zu lesen
und zu schreiben ist ein optionales Addon (Asc.Addons.ooxml, CDocument.fromZip), das nicht zum Build
von Euro-Office gehört: Das Flag zu setzen, verschiebt den Fehler nur nach fromZip is not a function.
Deshalb wandelt jedes Öffnen die .docx mit x2t ins Binärformat um, und jedes Speichern wandelt zurück, so
wie es CryptPad tut. x2t läuft in einem Worker (createConverter), damit sein großer Heap aus der Seite
herausbleibt.
Wie ein Dokument ohne Server geöffnet wird¶
Das Öffnen ist für jeden Editor gleich (src/document.ts openDocument); jeder Editor steuert seinen Teil
als EditorBinding bei: das Format, wie seine API erzeugt wird, seinen Zustand und seine Events, seine
Befehle, was er einmal setzt, sobald das Dokument angezeigt wird. openWordDocument (src/word.ts),
openSheetDocument (src/cell.ts) und openPresentation (src/slide.ts) sind die Bindings. Der Ablauf
konvertiert die Datei (docx → bin, xlsx → bin, pptx → bin) und
folgt dann den mobilen Editoren von web-apps (apps/*editor/mobile/src/controller/Main.jsx):
- Die API des Editors im Frame:
new Asc.asc_docs_api({"id-view": "editor_sdk"})odernew Asc.spreadsheet_api({"id-view": "editor_sdk", "id-input": "ce-cell-content"}). - Die Callbacks registrieren (Zustands-Events,
asc_onGetEditorPermissions,asc_onDocumentContentReady,asc_onError). asc_setDocInfo(info)mit der URLAscCommon.offlineMode. Das schaltet die Verbindung zum Server ab:_coAuthoringInitlässt die Co-Authoring-URL leer,CDocsCoApi.initantwortet dann mit einem lokalen „first connect“ und einer leeren Lizenz, statt einen Socket zu öffnen (common/apiBase.js,common/docscoapi.js). In einer gemeinsamen Sitzung ist die URL stattdessen eine Blob-URL des konvertierten Dokuments, undwindow.ioim Frame ist ein Ersatz für socket.io, der mit dem Relay von Schreibzeug spricht; siehe Zusammenarbeit.asc_getEditorPermissions(); der Callback für die Berechtigungen ruftasc_LoadDocument()auf.- Im Offline-Modus fragt sdkjs über
_openChartOrLocalDocumentnach der Datei, was ein leeres Dokument öffnen würde. Schreibzeug ersetzt das auf der API-Instanz durchasc_openDocumentFromBytes(binary). asc_onDocumentContentReady→ der Editor ist bereit.
Wie sie speichert¶
asc_nativeGetFile() (word/api.js) gibt das Dokument im Binärformat als
DOCY;v5;<size>;<base64> zurück; x2t wandelt es in eine .docx um (bin → docx). Die Web-App legt das
Ergebnis auf dem Server als neue Version ab (PUT /api/files/:id/content, siehe Dateien) und
ruft dann markSaved(saved) auf, also SetUnchangedDocument(): „geändert“ wird bis zur nächsten Änderung
falsch. In einer gemeinsamen Sitzung teilt sie dem Relay außerdem mit, wie viel vom Änderungsprotokoll die
gespeicherte Kopie enthält; siehe Zusammenarbeit.
Serienbrief¶
„Serienbrief“ im Texteditor: Ein Brief mit Seriendruckfeldern und eine Tabelle mit Empfängern werden zu
einem neuen Dokument mit einem Brief pro Empfänger, jeder nach einem Seitenumbruch, abgelegt neben dem
Brief als „apps/web/src/editor/use-mail-merge.tsx).
- Empfänger: „Empfänger wählen …“ nimmt eine Tabelle aus den eigenen Dateien oder vom Rechner:
.xlsx (ihr erstes Blatt, gelesen von
packages/ooxmlxlsxRows, Datumsangaben und Zahlen als deutscher Text), .ods und .xls (vorher von x2t in eine .xlsx umgewandelt) oder .csv (decodeCsvinsrc/csv.ts; UTF-8 oder Windows-1252, wie das deutsche Excel sie schreibt). Die erste Zeile benennt die Felder; eine Spalte ohne Namen oder eine Tabelle ohne Empfänger wird mit Begründung abgelehnt. Die Engine bekommt sie als Liste (word/api.jsasc_StartMailMergeByList); sie leben in der Sitzung, nicht im Dokument. - Felder: Die Leiste über dem Brief setzt ein Feld an den Cursor (
asc_AddMailMergeField, ein MERGEFIELD, das «Name» zeigt und das auch Word liest) und nennt die Felder des Briefs, die der Tabelle fehlen. Word schreibt Seriendruckfelder als komplexe Felder (w:fldChar…MERGEFIELD Name…w:fldChar); die Engine liest sie, führt aber nur einfache zusammen (word/Editor/Document.jsRegister_Field→m_oMailMergeFields), deshalb werden in einer .docx die komplexen Seriendruckfelder vor dem Öffnen zu einfachen gemacht (w:fldSimple, gleiche Anweisung und gleiches Ergebnis) (packages/ooxmlsimplifyMergeFields). - Vorschau: zeigt den Brief für einen Empfänger (
asc_PreviewMailMergeResult); die Engine lässt den Brief währenddessen nicht bearbeiten. - Die Briefe:
CDocument.Get_MailMergedDocumentkopiert den Brief einmal pro Empfänger und ersetzt dabei die Felder. Der eigene Download der Engine schickt das an den Document Server; hier wird es im Binärformat geschrieben (AscCommonWord.BinaryFileWriter, wieasc_nativeGetFile) und von x2t mit den Bildern des Briefs in eine .docx umgewandelt (src/word-mail-merge.ts).
e2e/mail-merge.spec.ts führt test-files/einladung.docx (Seriendruckfelder von Word) mit
test-files/empfaenger.xlsx zusammen, fügt ein Feld hinzu, blättert durch die Vorschau und liest die
gespeicherten Briefe; ein zweiter Test nimmt eine CSV in Windows-1252 vom Rechner und prüft die Warnung für
Felder, die der Tabelle fehlen.
Andere Formate¶
x2t liest mehr als die Office-Formate, und die Dateiliste öffnet auch diese Dateien:
- OpenDocument (.odt, .ods, .odp, wie LibreOffice sie schreibt) öffnet sich im Editor seiner Art und
wird als das gespeichert, was es ist: x2t liest es ins Binärformat (
odt → bin) und schreibt es zurück (bin → odt), wie bei einer .docx (OpenOptions.openDocument,OPEN_DOCUMENT_FORMATinsrc/converter.ts). „Herunterladen“ liefert die .odt; eine Tabelle lässt sich auch als CSV herunterladen. - Ältere Formate (Word, Excel und PowerPoint 97–2003, RTF) liest x2t, schreibt sie aber nicht; eine
.doc ins Binärformat zu lesen, bricht mit Fehler 88 ab, während
doc → docxfunktioniert. Deshalb macht Schreibzeug, was Word mit „Konvertieren“ macht: Die Seite für eine solche Datei (apps/web/src/editor/convert-page.tsx) legt daneben eine Kopie im Office-Format an (OFFICE_FORMAT_OF_LEGACY: .doc und .rtf zu .docx, .xls zu .xlsx, .ppt zu .pptx), unter einem freien Namen („Angebot.docx“, „Angebot (2).docx“), und öffnet diese; die Datei selbst bleibt, wie sie ist. Wem die Datei nur geteilt ist, der bekommt die Kopie in seine eigenen Dateien.
e2e/other-formats.spec.ts bearbeitet und speichert eine .odt, eine .ods und eine .odp und prüft die
gespeicherten Dateien (ihren mimetype-Teil und ihren Text), und es öffnet eine .doc, eine .rtf, eine .xls
und eine .ppt über ihre Kopie. LibreOffice liest die gespeicherte .odt mit ihrem Text wieder ein. Die
Testdateien sind Schreibzeugs eigene, mit LibreOffice konvertiert (test-files/README.md).
Befehle und Zustand¶
Die Oberfläche ruft die Engine nie auf. editor-core übersetzt Events der Engine in EditorState
(src/events.ts, src/state.ts) und bietet Befehle an (src/commands.ts):
| Befehl | Aufruf in der Engine | Event zurück |
|---|---|---|
| fett, kursiv, unterstrichen | put_TextPrBold/Italic/Underline(value) |
asc_onBold/Italic/Underline |
| Schriftgröße | put_TextPrFontSize(size) |
asc_onFontSize |
| Ausrichtung | put_PrAlign(AscCommon.align_*) |
asc_onPrAlign |
| rückgängig, wiederholen | Undo(), Redo() |
asc_onCanUndo, asc_onCanRedo |
| durchgestrichen | put_TextPrStrikeout(value) |
asc_onStrikeout |
| Schriftart | put_TextPrFontName(name) |
asc_onFontFamily; die Liste: asc_onInitEditorFonts |
| Textfarbe | put_TextColor(asc_CColor), automatisch: Auto = true |
asc_onTextColor |
| Absatzformatvorlage | put_Style(name) |
asc_onParaStyleName; die Liste: asc_onInitEditorStyles |
| Aufzählung, nummerierte Liste | put_ListTypeCustom(preset), beenden: { Type: "remove" } |
asc_onFocusObject, dann asc_GetCurrentNumberingId / asc_GetNumberingPr |
| Tabelle einfügen | put_Table(columns, rows) |
asc_onFocusObject mit einem Table-Objekt |
| Zeilen, Spalten | addRowAbove/Below(), addColumnLeft/Right(), remRow(), remColumn(), remTable() |
– |
| alles auswählen | asc_EditSelectAll() |
– |
| hochgestellt, tiefgestellt | put_TextPrBaseline(AscCommon.vertalign_*) |
asc_onVerticalAlign |
| Formatierung löschen | ClearFormating() |
– |
| Seitenumbruch | put_AddPageBreak() |
– |
| ausschneiden, kopieren, einfügen | Cut(), Copy(), Paste(); false: der Browser hat abgelehnt |
– |
| Zoom | zoomIn(), zoomOut(), zoom(percent), zoomFitToWidth(), zoomFitToPage() |
asc_onZoomChange(percent): document.zoom |
| als gespeichert markieren | SetUnchangedDocument() |
asc_onDocumentModifiedChanged |
| – | – | asc_onCountPages |
| – | – | asc_onStartAction / asc_onEndAction mit c_oAscAsyncAction.Disconnect: document.connected |
Builder-Skripte¶
OpenedDocument.runBuilder führt ein Skript gegen die Builder-API der Engine aus (word/apiBuilder.js,
cell/apiBuilder.js, slide/apiBuilder.js), über callCommand (common/apiBase.js), so wie es Plugins
tun: eine Aktion im Verlauf, am Ende einmal neu berechnet, mit der Sperrprüfung fürs gemeinsame Bearbeiten.
Die Aufträge des MCP-Servers für ein offenes Dokument nutzen das (src/agent.ts, siehe den MCP-Server).
Das Skript wird so ausgewertet, wie es ist; deshalb wird es in eine Funktion verpackt, um einen Wert
zurückzugeben, und zurück kommen nur einfache Daten (Asc.checkReturnCommand).
Kommentare¶
src/comments.ts liest und schreibt asc_CCommentDataWord (word/api.js) so, wie es web-apps tut
(common/mobile/lib/controller/collaboration/Comments.jsx). Ein Kommentar trägt zwei Zeiten: Time,
die Ortszeit, geschrieben, als wäre sie UTC, und OOTime, echte Millisekunden; Schreibzeug führt eine Zeit
in Millisekunden und schreibt beide.
| Befehl | Aufruf in der Engine | Event zurück |
|---|---|---|
| hinzufügen (zur Auswahl) | asc_addComment(data) |
asc_onAddComment(id, data) |
| antworten, erledigen | asc_changeComment(id, data) mit dem ganzen Kommentar und allen Antworten |
asc_onChangeCommentData |
| löschen | asc_removeComment(id) |
asc_onRemoveComment |
| hingehen | asc_selectComment(id) |
– |
| – | asc_showComments(false) bei Content-Ready markiert kommentierten Text |
asc_onShowComment(ids), asc_onHideComment |
Beim Öffnen meldet die Engine jeden Kommentar der Datei mit asc_onAddComment; ein Kommentar trägt
den Namen des Kontos, das ihn geschrieben hat.
Die Präsentations-Engine spricht dieselben Aufrufe und Events (slide/api.js, asc_CCommentDataSlide,
exportiert als Asc.asc_CCommentData); ein neuer Kommentar gehört zur aktuellen Folie, und
asc_showComments() bei Content-Ready zeigt die Kommentarmarken auf den Folien.
Die Tabellen-Engine hat dieselben Kommentarfelder (cell/model/CellComment.js
asc_CCommentData), setzt einen neuen Kommentar aber auf die ganze Arbeitsmappe, solange sein
Dokument-Flag nicht falsch ist; deshalb setzt der Editor es auf falsch, und der Kommentar kommt an die
aktive Zelle, deren Bezug der Kommentar als sein Zitat meldet. asc_addComment gibt dort nichts zurück;
die ID kommt mit asc_onAddComment. Neben den einzelnen Events meldet sie Listen: die Kommentare eines
Blatts beim Öffnen und wenn es angezeigt wird (asc_onAddComments), verschobene (asc_onChangeComments)
und entfernte (asc_onRemoveComments). Die ID eines Kommentars beginnt mit sheet<id>_ für sein Blatt
(asc_getWorksheetId), und die Seitenleiste zeigt die Kommentare des angezeigten Blatts, so wie web-apps
sie filtert. asc_showComments(false) markiert kommentierte Zellen.
Alle drei Editoren teilen sich die Befehle (src/comments.ts), den Zustand (src/comment-state.ts) und
die Seitenleiste (apps/web/src/editor/use-comments-panel.tsx).
asc_onDocumentModifiedChanged trägt keinen Wert (word/api.js SetDocumentModified schickt es
ohne); wie web-apps (documenteditor/mobile Main.jsx) liest editor-core beim Eintreffen
isDocumentModified().
Die Namen der Formatvorlagen sind die englischen der Engine (Normal, Heading 1), wie sie in der .docx
stehen; die Werkzeugleiste zeigt die eingebauten auf Deutsch (apps/web/src/toolbar/style-labels.ts). Die
Listenvorlagen sind die ersten Aufzählungs- und Nummerierungsvorlagen von web-apps (documenteditor/mobile
store/textSettings.js), in src/lists.ts; die Farbpalette sind die zehn Standardfarben von Word.
Die Engine nimmt Zielwerte, keine Umschalter; deshalb liest ein Umschaltbefehl zuerst den aktuellen Zustand.
Menüs und das Kontextmenü¶
Die Titelzeile des Editors trägt eine Menüleiste wie in einer Office-Suite auf dem Desktop (apps/web/src/ui/menu-bar.tsx).
„Datei“ und „Hilfe“ sind in jedem Editor gleich (src/editor/file-menu.ts); der Editor fügt seine
eigenen Menüs dazwischen ein (src/editor/word-menus.ts), gebaut aus dem Zustand und den Befehlen oben.
Die Einträge folgen den Desktop-Editoren von web-apps (documenteditor/main Toolbar.js,
DocumentHolder.js); die angezeigten Tastenkürzel sind die der Engine selbst (word/Editor/Shortcuts.js).
Auf dem Handy bekommt das Dokument den Platz: Die Kopfzeile ist eine Reihe (zurück, Name, der
Speicherstand als Symbol, die eigenen Schaltflächen des Editors, „Werkzeuge“ und „Speichern“), und die
Menüs, die Schaltflächen der Datei und die Werkzeugleiste erscheinen erst nach einem Tipp auf „Werkzeuge“
(src/editor/editor-header.tsx, e2e/phone.spec.ts). In Kontext lässt Kontext unter einer offenen Datei
seine Tab-Leiste weg.
Ein Textdokument öffnet sich auf dem Handy in der mobilen Ansicht der Engine, so wie es der mobile Editor von
web-apps öffnet (documenteditor/mobile Main.jsx, „mobile-view“): ChangeReaderMode setzt den Text in
der Breite des Bildschirms in einer lesbaren Größe, weiter bearbeitbar, ohne Lineale
(packages/editor-core/src/word-mobile-view.ts, apps/web/src/editor/use-mobile-view.ts). Es ist nur ein
Layout (word/Editor/Layout/ReadView.js, ohne Verlauf gesetzt), deshalb bleibt die gespeicherte .docx,
wie sie ist. PDF und Drucken brauchen die Seiten: Dafür kehrt die Engine zu den Seiten zurück, setzt sie
auf einmal (RecalculateAllAtOnce, wie asc_Print es tut) und wechselt wieder in die mobile Ansicht.
„Ansicht → Mobilansicht“ schaltet sie auf jedem Bildschirm ein. Eine Präsentation hat auf dem Handy ihre
Folienliste unter der Folie (thumbnails-position: bottom) und ihre Notizen ausgeblendet bis
„Ansicht → Notizen“, so wie es der mobile Präsentationseditor von web-apps hat
(presentationeditor/mobile Main.jsx).
Ein Rechtsklick ins Dokument lässt die Engine asc_onContextMenu mit einem CContextMenuData schicken
(word/api.js sync_ContextMenuCallback): den Punkt relativ zu ihrem Ansichtselement und ob er in einer
Kopf- oder Fußzeile lag. editor-core fügt die Lage des Ansichtselements im Frame hinzu
(src/view.ts toContextMenuRequest) und reicht die Anfrage an die onContextMenu-Listener weiter; die
Web-App fügt die Lage des Frames im Fenster hinzu und zeigt dort ihr eigenes Menü, so wie es web-apps tut
(DocumentHolder.js showPopupMenu). Wer nur ansehen darf, bekommt kein Kontextmenü.
„Hilfe“ enthält die Tastenkürzel des Editors, den Schalter für die Bildschirmleser-Unterstützung der
Engine (Barrierefreiheit) und „Über Schreibzeug“ mit der Lizenz und dem Link zum
laufenden Quellcode, den die AGPL verlangt (src/editor/help-dialogs.tsx).
Ausschneiden, Kopieren und Einfügen aus einem Menü laufen über die Engine (common/clipboard_base.js
Button_Copy, Button_Cut, Button_Paste), die die asynchrone Clipboard-API benutzt; der Frame erlaubt
das (allow="clipboard-read; clipboard-write"). Lehnt der Browser ab, antwortet der Eintrag mit false,
und die App sagt, welche Tasten du nehmen kannst, wie web-apps.
Seitenlayout und Abstände¶
Das Menü „Layout“ setzt die Ausrichtung, das Papierformat und die Ränder des Abschnitts am Cursor;
„Format“ und die Werkzeugleiste setzen den Zeilenabstand und den Einzug der Absätze
(src/layout.ts). Die Auswahl ist die von web-apps (documenteditor main view/Toolbar.js: A4, A5,
Letter, Legal; Ränder normal, schmal, mittel, breit; Abstand 1 bis 3 Zeilen), und die Aufrufe sind es auch
(controller/Toolbar.js): change_PageOrient(isPortrait), change_DocSize(width, height) mit dem
Hochformat (die Engine dreht es für eine Seite im Querformat), asc_SetSectionProps mit einem
Asc.CDocumentSectionProps, in dem nur die Ränder gesetzt sind (CDocument.Set_SectionProps lässt in
Ruhe, was undefiniert ist), put_PrLineSpacing(Asc.linerule_Auto, multiple) sowie
IncreaseIndent / DecreaseIndent. Was Abschnitt und Absatz am Cursor haben, kommt von
asc_onSectionProps (CDocument.UpdateInterface) und asc_onParaSpacingLine; eine Vorlage gilt als
gewählt, wenn jeder Wert auf ein Zehntel Millimeter stimmt, so wie web-apps es prüft.
Kopfzeilen, Fußzeilen und Seitenzahlen¶
„Einfügen“ öffnet die Kopf- oder Fußzeile der aktuellen Seite (GoToHeader(page),
GoToFooter(page) mit getCurrentPage(), wie HeaderFooterTab.js von web-apps) und schließt sie, wenn
man darin ist (asc_CancelHdrFtrEditing), oder entfernt sie (asc_RemoveHeader, asc_RemoveFooter).
Seitenzahlen kommen mit put_PageNum(part, align) hinein, mit den Zahlen von c_pageNumPosition aus
web-apps (DocumentHolder.js: oben 1, unten 2; rechts 0, links 1, Mitte 2), oder mit put_PageNum(-1) am
Cursor; asc_AddPageCount fügt die Seitenzahl gesamt hinzu (src/header-footer.ts). Das Menü liegt
außerhalb des Frames, deshalb gibt das Hineingehen in die Kopfzeile oder das Herausgehen die Tasten wieder
an die Engine. Ob der Cursor in einer Kopf- oder Fußzeile steht, kommt von asc_onFocusObject (ein
Header-Element).
Inhaltsverzeichnis, Fußnoten, Umbrüche und Textfelder¶
„Einfügen“ fügt ein, was der Tab „Verweise“ und die Werkzeugleiste von web-apps anbieten (src/word-insert.ts,
nach documenteditor/mobile controller/add/AddTableContents.jsx, controller/add/AddOther.jsx,
controller/add/AddShape.jsx):
- Inhaltsverzeichnis:
asc_GetTableOfContentsPr()für das, das das Dokument hat, oder ein neuesAsc.CTableOfContentsPr, eingestellt auf die Überschriften 1 bis 9 (put_OutlineRange(1, 9)), verlinkte Einträge, Seitenzahlen rechtsbündig hinter Punkten (c_oAscTabLeader.Dot), dannasc_AddTableOfContents(null, props); gibt es schon eines, wird dieses geändert, statt ein zweites hinzuzufügen. „Inhaltsverzeichnis aktualisieren“ istasc_UpdateTableOfContents(false)(Einträge und Seitenzahlen); ohne Inhaltsverzeichnis sagt der Editor das, statt die EngineComplexFieldNoTOCmelden zu lassen. - Fußnoten und Endnoten:
asc_AddFootnote()undasc_AddEndnote()setzen das Zeichen an den Cursor und den Cursor in die Notiz. Strg+Alt+F ist das eigene Tastenkürzel der Engine (InsertFootnoteNow). - Umbrüche:
put_AddPageBreak()(Strg+Enter),put_AddColumnBreak()undadd_SectionBreak(c_oAscSectionBreakType.NextPage | Continuous), das einen Abschnitt mit eigener Seiteneinrichtung beginnt. - Textfeld:
AddShapeOnCurrentPage("textRect")zeichnet ein Rechteck, das Text aufnimmt, in die Mitte der angezeigten Seite (GraphicObjects.addShapeOnPage), ausgewählt, sodass die nächsten Tasten hineingehen. Es wird alswps:txbxgespeichert.
Das Menü liegt außerhalb des Frames, deshalb gehen die Tasten nach jedem dieser Schritte wieder an die Engine, wie bei Kopf- und Fußzeile: Was du als Nächstes tippst, landet in der Notiz, im Textfeld oder auf der Seite.
Links¶
„Link …“ (Strg+K, die Werkzeugleiste, das Kontextmenü) funktioniert wie der Link-Dialog von web-apps
(controller/Links.js, view/HyperlinkSettingsDialog.js): Wenn can_AddHyperlink() den ausgewählten Text
zurückgibt, kommt ein neuer Link mit add_Hyperlink hinein; sonst steht der Cursor in einem Link, dessen
Asc.CHyperlinkProperty aus getSelectedElements() mit change_Hyperlink und remove_Hyperlink
geändert oder entfernt wird (src/links.ts). Eine Adresse ohne Schema bekommt http:// (eine
E-Mail-Adresse mailto:), und ein unveränderter Text wird als null übergeben, damit der verlinkte Text
seine Formatierung behält. Strg+K erreicht die App als asc_onDialogAddHyperlink; die Kürzeltabelle der
Engine ist leer, bis sie auf die Standardwerte zurückgesetzt wird (asc_resetAllShortcutTypes, wie es
Shortcuts.js von web-apps tut), was der Texteditor einmal tut, sobald das Dokument angezeigt wird.
Strg+Klick auf einen Link schickt asc_onHyperlinkClick; die App öffnet http-, https- und mailto-Adressen
in einem neuen Tab.
Hervorheben und Format übertragen¶
„Hervorheben“ hebt die Auswahl in einer der ersten Farben der Palette von web-apps hervor oder nimmt die
Hervorhebung weg: SetMarkerFormat(true, isColor, r, g, b) (CDocument.SetParagraphHighlight),
dann SetMarkerFormat(false), damit die Maus nicht wie in web-apps ein Textmarker bleibt, wo sie es bis
Escape tut. Die Farbe am Cursor wird aus get_TextProps().get_TextPr().get_HighLight() gelesen, wenn
asc_onTextHighLight kommt, wie es onApiHighlightColor von web-apps tut, weil das Event selbst „keine“
(-1) als Schwarz meldet. „Format übertragen“ ist SetPaintFormat(1); die Engine überträgt die kopierte
Formatierung auf die nächste Auswahl, die mit der Maus gemacht wird, und meldet den Pinsel als aus
(asc_onPaintFormatChanged), aber nicht als an; deshalb hält die Schaltfläche diesen Zustand selbst
(src/marking.ts).
Änderungen nachverfolgen¶
src/review.ts, nach dem Review von web-apps (common/main controller/ReviewChanges.js,
common/mobile controller/collaboration/Review.jsx). Das Menü „Überprüfen“ schaltet das Nachverfolgen
ein und aus, geht durch die Änderungen, nimmt sie an oder lehnt sie ab und wählt, wie sie angezeigt werden;
eine Sprechblase neben der Änderung am Cursor nennt, wer sie wann gemacht hat, mit Annehmen und Ablehnen.
| Befehl | Aufruf in der Engine (word/api.js) |
|---|---|
| Änderungen nachverfolgen | asc_SetLocalTrackRevisions(null), asc_SetGlobalTrackRevisions(on): für das Dokument, gespeichert als w:trackRevisions in settings.xml, wie „für alle“ in web-apps; Zustand von asc_onOnTrackRevisionsChange(local, global) (local null: die Einstellung des Dokuments gilt) |
| annehmen, ablehnen am Cursor | asc_AcceptChangesBySelection(true), asc_RejectChangesBySelection(true): die Änderung am Cursor oder in der Auswahl, dann weiter zur nächsten |
| vorherige, nächste | asc_GetPrevRevisionsChange(), asc_GetNextRevisionsChange() |
| alle | asc_AcceptAllChanges(), asc_RejectAllChanges() |
| Anzeige | asc_SetDisplayModeInReview(c_oAscDisplayModeInReview.Edit \| Final \| Original); es gibt kein Event, deshalb merkt sich der Editor die Wahl |
Die Änderungen am Cursor kommen mit asc_onShowRevisionsChange(changes, isShow), jede ein
CRevisionsChange (word/Editor/RevisionsChange.js): get_UserName, get_DateTime, get_Type
(c_oAscRevisionsChangeType: Text oder Absatz hinzugefügt oder entfernt, Formatierung), get_Value (der
Text oder eine Liste aus Text und Zeichnungen) und get_X/get_Y relativ zum Ansichtselement
(#editor_sdk). Wie in web-apps erscheint die Sprechblase nur für den Cursor (isShow), nicht für eine
Auswahl, und nur, solange Änderungen markiert werden. Der Autor ist der Name, den das Relay der Sitzung
gibt (siehe Zusammenarbeit).
Rechtschreibprüfung¶
src/spelling.ts. Ohne Adresse eines Rechtschreibdienstes prüft die Engine in einem eigenen Worker
(common/apiBase.js _coSpellCheckInit → CSpellchecker, common/spell/spell.js: Hunspell als
WebAssembly) und lädt <lang>/<lang>.aff und .dic aus engine/dist/dictionaries, das
engine/scripts/prepare.ts aus dem Release-Paket mit den Sprachen aus engine.json
(de_DE, de_AT, de_CH, en_US, en_GB) und ihren Lizenzen füllt.
- Nur mitgelieferte Sprachen. Die Engine prüft jede Sprache, die sie aufführt
(
AscCommon.spellcheckGetLanguages); eine Sprache ohne ihr Wörterbuch markiert jedes Wort, und deshalb war die Prüfung vorher abgeschaltet. Die Liste wird vor dem Start des Editors auf die Wörterbücher gekürzt, die wir mitliefern (limitSpellLanguages); Text in anderen Sprachen bleibt unmarkiert. - Ein eigener Worker des Frames. Aus dem Frame des Editors hat der gemeinsame Worker (
SharedWorker, namensonlyoffice-spellchecker) in Chromium nie geantwortet, ein dedizierter Worker dagegen schon; spell.js kommt für WKWebView von WebKit ohnehin ohne den gemeinsamen aus, deshalb versteckt der FrameSharedWorker, bevor der Editor startet (useDedicatedSpellWorker). - Gestartet, egal wie schnell er lädt. Der Worker (
common/spell/spell/spell.js) setztModule.onRuntimeInitializederst, wenn die „init“-Nachricht der Seite kommt. Hat der Browser das WebAssembly im Cache, ist es schon vorher bereit, der Callback kommt nie, und die Assertions des Builds brechen das Modul ab („Attempt to setModule.onRuntimeInitializedafter it has already been processed“): keine Rechtschreibprüfung in diesem Dokument.engine/scripts/prepare.ts(patchSpellWorker) lässt den Worker sofortself.onEngineInit()aufrufen, wennModule.calledRungesetzt ist; es bricht mit einem Fehler ab, falls ein Engine-Update diese Zeile ändert. - An oder aus mit
asc_setSpellCheck(on), sobald das Dokument bereit ist, und über „Überprüfen → Rechtschreibprüfung“; die Wahl bleibt in diesem Browser gespeichert (apps/websettings/spell-check.ts, so wie web-apps „settings-spellcheck“ speichert). Wer nur ansehen darf, bekommt keine Unterstreichungen. - Vorschläge. Steht der Cursor in einem falsch geschriebenen Wort, führt
asc_onFocusObjecteinc_oAscTypeSelectElement.SpellCheck-Element auf (asc_CSpellCheckProperty:get_Word,get_Checkedfalsch,get_Variants). Das Kontextmenü bietet die ersten fünf Varianten an (asc_replaceMisspelledWord(variant, element)), „Ignorieren“ und „Alle ignorieren“ (asc_ignoreMisspelledWord(element, all)), wie das von web-apps (documenteditor/mainDocumentHolderExt.jsspellProps). Dieselben Aufrufe funktionieren im Präsentationseditor.
Die Bilder zur Formattreue und die Screenshots entstehen mit abgeschalteter Rechtschreibprüfung, damit ein Update der Wörterbücher sie nicht verändert.
Suchen und Ersetzen¶
src/search.ts füllt im Frame der Engine ein CSearchSettings (common/api/searchSettings.js: Text,
Groß-/Kleinschreibung beachten, ganze Wörter) und ruft asc_findText(settings, isNext),
asc_replaceText(settings, replacement, isReplaceAll) und asc_endFindText() auf, so wie es web-apps tut
(documenteditor/main controller/Search.js). Die Engine antwortet mit
asc_onSetSearchCurrent(current, total) und, nach „alle ersetzen“, mit asc_onReplaceAll(total,
replaced); beides landet in state.search. Passt nichts, schickt sie nichts, deshalb meldet der Befehl
das selbst.
Strg+F und Strg+H behandelt die Engine nicht (web-apps öffnet dafür ein eigenes Panel); ein
keydown-Listener im Frame (document.ts onKey mit shortcutOf, nach außen gegeben als onShortcut) und einer im Fenster der App öffnen
stattdessen die Suchleiste statt der Suche des Browsers. Wer nur ansehen darf, kann suchen, aber nicht
ersetzen.
PDF und Drucken¶
Dieser Build von x2t macht aus einem Dokument nicht von selbst ein PDF; er schreibt ein PDF aus den
Zeichenbefehlen der Engine, so wie es der Document Server zum Drucken tut. exportPdf (src/document.ts)
gibt dem Konverter drei Dinge, so wie es CryptPad tut (www/common/outer/x2t.js
x2tConvertDataInternal):
- das Dokument im Binärformat der Engine (
asc_nativeGetFile()) alsinput.bin; - jede Seite als Zeichenbefehle, als
pdf.bindaneben:WordControl.m_oDrawingDocument .ToRendererPart(true, true), das, wasword/api.js_downloadAsfür ein PDF zum Drucken schickt; x2t liest diese Datei unter diesem Namen (X2tConverter/src/lib/pdf_image.hdoct_bin2pdf, der Patch von CryptPad); - die Schriften, mit denen das Dokument gezeichnet wurde, in
m_sFontDir: die Schriftdateien, die die Engine geladen hat (AscCommon.g_font_loader, Status 0 oder 1), noch einmal aus ihrem Schriftordner geholt (der Browser hat sie im Cache) und mit rückgängig gemachter Verschleierung ihrer ersten 32 Bytes, so wie es die Engine beim Laden tut (common/Drawings/Externals.js,guidOdttf);src/print.ts.
„Als PDF/A herunterladen“ bittet x2t um dasselbe PDF als PDF/A-2 (m_bIsPDFA im Auftrag;
X2tConverter/src/cextracttools.h → PdfFile.cpp CreatePdf(isPDFA)): XMP-Metadaten mit
pdfaid:part 2, ein sRGB-Output-Intent, jede Schrift eingebettet. Für ein PDF selbst siehe PDFs.
„Drucken“ druckt dieses PDF über den Dialog des Browsers (apps/web/src/editor/pdf.ts), auf einem von
zwei Wegen (apps/web/src/editor/print-pages.ts):
- Wo der Browser einen eigenen PDF-Viewer hat (
navigator.pdfViewerEnabled) und nicht WebKit ist (Chrome, Edge, Firefox auf einem Rechner), kommt das PDF in einen versteckten Frame, der druckt, sobald es geladen ist: scharf und mit seinem Text. - Überall sonst zeichnet pdf.js (nur dann geladen) jede Seite mit 300 dpi, die Bilder kommen in die Seite, auf dem Bildschirm versteckt, und die Seite selbst druckt, sobald alle dekodiert sind; ein Druck-Stylesheet zeigt nur sie, eines pro Blatt in der Größe der ersten Seite. Chrome auf Android und die darauf gebauten Browser haben keinen PDF-Viewer und geben ein PDF in einem Frame an das System weiter, sodass kein Druckdialog käme. Safari meldet den Frame als geladen, bevor sein Viewer die Seiten gezeichnet hat; direkt nach einem Neuladen zu drucken, ergibt dann leere Seiten, und nichts verrät, wann sie gezeichnet sind. Alle Browser auf iOS sind WebKit. „Als PDF sichern“ im Druckdialog ergibt dort ein PDF aus Bildern; „Als PDF herunterladen“ liefert das echte.
Strg+P ist eine weitere Taste, die die Engine ihrer Oberfläche überlässt; sie geht an dieselbe Stelle wie
Strg+F (onShortcut), ebenso Strg+S, das über die App speichert (das eigene asc_Save der Engine würde
mit dem Document Server sprechen). Die Bilder des Dokuments gehen als media/ mit, wie unten beschrieben.
Bilder¶
Der Konverter hält die Bilder eines Dokuments von seiner Binärform getrennt: Beim Öffnen einer .docx
schreibt x2t sie nach media/ neben die Ausgabe, und beim Speichern oder Drucken liest es sie von dort
(engine/frame/x2t/worker.js; CryptPad macht dasselbe in www/common/outer/x2t.js). Die Engine selbst
sieht nie Dateien; sie sucht jedes Bild unter seinem Namen in AscCommon.g_oDocumentUrls
(common/editorscommon.js DocumentUrls), das der Document Server mit Download-Links füllt.
src/media.ts füllt es mit Blob-URLs, die im Frame erzeugt werden (provideMedia), nachdem der Konverter
geantwortet hat, und holt beim Speichern oder Drucken jeden media/-Eintrag wieder in Bytes zurück
(collectMedia), auch Bilder, die beim Bearbeiten hinzugekommen sind.
„Einfügen → Bild …“ fügt ein Bild vom Rechner am Cursor ein (insertImage): Die App legt es auf dem Server
ab, der mit seinem Namen antwortet, und das Bild kommt unter diesem Namen mit seiner Server-URL in
DocumentUrls; dann findet AddImageUrl([url]) (common/apiBase.js) die URL dort und reicht sie an
_addImageUrl des Editors weiter (word/api.js, cell/api.js, slide/api.js), wie nach einem Upload zum
Document Server (UploadImageFiles). Das Speichern bildet die URL wieder auf den Namen ab
(Shapes/SerializeWriter.js getImageLocal), sodass das Bild in media/ der Datei landet. Wie die anderen
in einer Sitzung es bekommen, steht unter Zusammenarbeit.
Tastaturfokus¶
Die Engine nimmt Tasten über ein verstecktes Textfeld in ihrem Frame entgegen (common/text_input2.js, ID
area_id) und bricht mousedown auf ihrem Canvas ab. Ein Klick in die Seite nimmt der App deshalb nicht
den Fokus: Hatte eine Schaltfläche der Werkzeugleiste den Fokus, ging das Tippen ins Leere. editor-core
horcht im Frame auf pointerdown und fokussiert, wenn nichts im Frame die Tasten hält, die Eingabe der
Engine (api.getFocusElement(), common/apiBase.js); der eigene focus-Handler der Engine schaltet dann
ihre Tasten-Events wieder ein (keepFocusOnClick in src/frame.ts). Es prüft noch einmal, wenn die
Haupttaste losgelassen wird: Ein Klick in die Notizen der Präsentation lässt den Fokus danach auf dem Body
der Seite. Ein Rechtsklick bleibt dort unberührt, weil dann das Kontextmenü der App den Fokus hat.
Der Weg wieder hinaus ist F6: Im Dokument gehört Tab der Engine (ein Tabulator, die nächste Zelle, das
nächste Formularfeld), und Escape und Umschalt+Tab bleiben ebenfalls dort. shortcutOf (src/view.ts)
nimmt F6 und Umschalt+F6 im Frame vor der Engine ab, so wie Strg+F; die Web-App wechselt zur Menüleiste,
zur Werkzeugleiste oder zurück ins Dokument (focus(), wieder die Eingabe der Engine;
src/editor/regions.ts).
Bildschirmleser¶
Die Bildschirmleser-Unterstützung der Engine (common/workerspeech.js) schreibt, worüber der Cursor ging
und was ausgewählt wurde, in div#area_id_screen_reader (role="region", aria-live="assertive") neben
ihrer Eingabe. src/screen-reader.ts schaltet sie mit setSpeechEnabled (common/apiBase.js), von Anfang
an, wenn OpenOptions.screenReader es sagt; ausgeschaltet hat EditorActionSpeaker.stop ihre Callbacks
entfernt. Strg+Alt+Z schaltet sie in der Engine selbst (word/Editor/Shortcuts.js SpeechWorker,
cell/view/EventsController.js, slide/Editor/Format/Presentation.js); ein keyup-Listener liest danach
EditorActionSpeaker.isLanched, sodass screenReader im Store und das Menü folgen. Ihre Wörter kommen aus
der translate-Map der API (OpenOptions.texts, die die App aus ihren Texten in
apps/web/src/editor/engine-texts.ts füllt; nachgeschlagen von translateManager.getValue). Gleich nachdem der Inhalt bereit ist, erzeugt die Engine ihre Eingabe
(word/api.js OpenDocument → InitControl); ein Microtask benennt sie dann nach der Datei und ersetzt ihr
autocomplete="extremely_off" (common/text_input2.js), das kein gültiger Wert ist.
Tabellen¶
src/cell.ts bindet die Tabellen-Engine (cell/api.js) an, nach dem Vorbild von
spreadsheeteditor/mobile aus web-apps:
- Bearbeitungsleiste. Die Engine tippt in ein Eingabefeld, das sie per ID in ihrem eigenen Dokument
findet (
config["id-input"],document.getElementById), deshalb gehört die Bearbeitungsleiste zur Frame-Seite (engine/frame/editor/cell/main/index.html), mit dem Namensfeld daneben. Das Namensfeld zeigtasc_onSelectionNameChangedund springt mit Enter perasc_findCell. - Deutsches Regionalformat.
asc_setLocale(0x0407)vor dem Laden: Dezimalkomma,;zwischen Funktionsargumenten. Funktionsnamen bleiben englisch (SUM), weil die Engine ohne Übersetzungsdatei keine deutschen Namen hat. - Zustand.
asc_onSelectionChangedbringt die aktive Zelle (asc_CCellInfo→CellXfs: Schrift, Farben, Ausrichtung, Umbruch, Zahlenformat; Verbundzustand),asc_onSheetsChangedundasc_onActiveSheetChangeddie Blattregister, gelesen mitasc_getWorksheetsCount,asc_getWorksheetName,asc_isWorksheetHidden,asc_getActiveWorksheetIndex. - Die Handler-Liste. Die Engine hält eine einzelne Funktion pro Event, wie sie ist, und erst mehrere
als Liste. Beim Öffnen meldet sie einen eigenen Callback für
asc_onSelectionChangedab, was das ganze Event löscht, wenn nur eine Funktion da ist (cell/view/HandlerList.jsremove). Ein leerer erster Callback erhält unseren. Außerdem ruft sie nur auf, was ihrasc_typeOf„function“ nennt, deshalb sind Callbacks nieasync-Funktionen.
| Befehl | Aufruf in der Engine (cell/api.js) |
|---|---|
| fett, kursiv, unterstrichen, durchgestrichen | asc_setCellBold/Italic/Underline/Strikeout(value) |
| Schriftart, Größe | asc_setCellFontName(name), asc_setCellFontSize(size) (höchstens 409) |
| Textfarbe, Füllung | asc_setCellTextColor(asc_CColor), asc_setCellBackgroundColor(asc_CColor \| null) |
| Ausrichtung, Umbruch | asc_setCellAlign(AscCommon.align_*), asc_setCellTextWrap(value) |
| Zahlenformat | asc_setCellFormat(code): General, #,##0.00, #,##0.00\ [$€-407], 0.00%, dd.mm.yyyy, @ |
| verbinden | asc_mergeCells(c_oAscMergeOptions.Merge \| None) |
| Zeilen, Spalten | asc_insertCells(c_oAscInsertOptions.InsertRows \| InsertColumns), asc_deleteCells(…) |
| rückgängig, wiederholen | asc_Undo(), asc_Redo(); Zustand von asc_onCanUndoChanged, asc_onCanRedoChanged |
| Blätter | asc_showWorksheet(i), asc_addWorksheet(name), asc_renameWorksheet(name), asc_deleteWorksheet() |
| ausschneiden, kopieren, einfügen | asc_Cut(), asc_Copy(), asc_Paste() |
| Zoom | asc_setZoom(factor), asc_getZoom(); asc_onZoomChanged(factor) |
| suchen, ersetzen | asc_findText(asc_CFindOptions) (die Anzahl), asc_replaceText(options); asc_onSetSearchCurrent, asc_onRenameCellTextEnd(found, replaced) |
wb.calcPagesPrint(), wb.printSheets(pages, null).DocumentRenderer.Memory.GetData(), wie cell/api.js _downloadAs |
Die Menüs und das Kontextmenü funktionieren wie im Texteditor (apps/web/src/editor/sheet-menus.ts).
Der Rechtsklick der Tabelle reicht das Maus-Event selbst weiter (WorkbookView.js onContextMenu),
dessen Punkt schon in den Koordinaten des Frames liegt. Die Suche folgt web-apps
(spreadsheeteditor/main controller/Search.js): Werte im aktiven Blatt, „ganze Wörter“ als „ganze
Zelle“; Treffer werden mit asc_selectSearchingResults markiert, weil asc_endFindText der Tabelle in
diesem Build fehlschlägt (es ruft ein _cleanFindResults auf, das WorkbookView.js fehlt).
Die Tabelle hat kein SetUnchangedDocument; ihr „geändert“-Flag fällt, sobald das Relay die Änderungen hat
(asc_isDocumentModified, History.Have_Changes).
Sortieren, Filter und fixierte Bereiche¶
src/cell-data.ts, nach dem Desktop-Editor von web-apps (spreadsheeteditor/main controller/Toolbar.js
onSortType, onAutoFilter, onClearFilter; controller/ViewTab.js onFreeze) und seinem mobilen
Spaltenfilter (spreadsheeteditor/mobile controller/FilterOptions.jsx):
| Befehl | Aufruf in der Engine (cell/api.js) |
|---|---|
| sortieren | asc_sortCellsRangeExpand(), dann asc_sortColFilter(c_oAscSortOptions.Ascending \| Descending, "", undefined, undefined, expand) |
| Filter an, aus | asc_addAutoFilter(); asc_changeAutoFilter(tableName, c_oAscChangeFilterOptions.filter, value), wo Schaltflächen sind oder eine formatierte Tabelle ist |
| Filter löschen | asc_clearFilter() |
| fixieren | asc_freezePane() (an der aktiven Zelle, oder Fixierung aufheben), asc_freezePane(c_oAscFrozenPaneAddType.firstRow \| firstCol) |
| Filter einer Spalte | asc_onSetAFDialog(asc_CAutoFilterObject): Werte mit asc_getText/asc_getVisible; asc_setVisible auf jedem, asc_getFilterObj().asc_setType(c_oAscAutoFilterTypes.Filters), asc_applyAutoFilter(object); danach sortieren mit asc_sortColFilter(order, asc_getCellId(), asc_getDisplayName()) |
- Eine einzelne Spalte sortieren stellt in web-apps die Frage von Excel, wenn daneben weitere Daten
stehen (
c_oAscSelectionSortExpand.showExpandMessage). Schreibzeug nimmt die Vorgabe dieser Frage und sortiert die Zeilen mit, den ganzen Bereich um die Auswahl; hat jemand anderes diese Zeilen (showLockMessage), sortiert es nur die Auswahl, was dort „Ja“ bewirkt. - Der Filterzustand kommt mit der Auswahl:
asc_getAutoFilterInfo()isttruemit Schaltflächen,false, wo sie hinzugefügt werden können, undnull, wo nicht;asc_getIsApplyAutoFilter()sagt, ob ein Filter Zeilen ausblendet. Der Name einer formatierten Tabelle istasc_getFormatTableInfo().asc_getTableName(). - Fixierte Bereiche haben kein Event: Das Fixieren wartet auf die Sperre des Bereichs
(
WorksheetView.js_isLockedFrozenPane), in einer gemeinsamen Sitzung die Antwort des Relays.asc_getSheetViewSettings().asc_getIsFreezePane()wird kurz danach und bei jeder Bewegung der Auswahl erneut gelesen; das Menü zeigt „Fixierung aufheben“, solange etwas fixiert ist, wie das von web-apps. - Der Filter einer Spalte öffnet sich unter ihrer Schaltfläche. Die Lage der Schaltfläche ist relativ
zum Canvas des Rasters, in
#ws-canvas-outer; wir addieren die Lage dieses Elements im Frame und die des Frames im Fenster. „OK“ wendet die markierten Werte an; mindestens einer bleibt sichtbar.
Diagramme¶
src/cell-chart.ts, nach dem mobilen Tabelleneditor von web-apps (controller/add/AddChart.jsx
onInsertChart, controller/edit/EditChart.jsx onType). „Einfügen“ und die Werkzeugleiste bieten
Säulen, Balken, Linien, ein Kreisdiagramm und Flächen an (c_oAscChartTypeSettings barNormal,
hBarNormal, lineNormal, pie, areaNormal):
- Ein neues Diagramm:
asc_getChartSettings(true)liefert die Einstellungen für die Auswahl (true, ohne den Frame des Diagrammeditors zu öffnen),putType(type), dannasc_checkDataRange( c_oAscSelectionDialogType.Chart, getRange(), true, !getInColumns(), getType()); mitc_oAscError.ID.Nokommt das Diagramm mitasc_addChartDrawingObject(settings)hinein, zu viele Datenreihen (MaxDataSeriesError) oder kein Bereich werden in einer Meldung gesagt. - Das ausgewählte Diagramm: Mit
asc_getSelectionType()RangeChart(oderRangeChartText) ist das Diagramm unterasc_getGraphicObjectProps(), seine Einstellungen sindget_ObjectValue().get_ChartProperties();changeType(type)ändert es sofort. Das Menü hakt dann die Art des ausgewählten Diagramms an.
Dropdown-Listen und bedingte Formate¶
src/cell-rules.ts, nach dem Desktop-Tabelleneditor von web-apps (controller/DataTab.js
onDataValidation mit view/DataValidationDialog.js; controller/Toolbar.js für die Auswahl der
bedingten Formate):
- Eine Dropdown-Liste („Daten → Dropdown-Liste …“) ist eine Datenüberprüfung vom Typ Liste.
asc_getDataValidationProps()liefert die Regel der Auswahl; wo die Auswahl mehrere Regeln enthält, antwortet es mitc_oAscError.ID.MoreOneTypeDataValidateund wird erneut mitnullgefragt (neu anfangen), sonst mittrue(die Regel erweitern). Die Werte kommen alsCDataFormulahinein, die Einträge mit „;“ verbunden (dem deutschen Argumenttrenner), mitasc_setType(List),asc_setAllowBlank(true),asc_setShowErrorMessage(true), dannasc_setDataValidation(props); TypNonenimmt die Liste weg. Die .xlsx bekommt sie in der Form derx14-Erweiterung. - Bedingte Formate („Format“): ein Datenbalken und eine Farbskala Grün–Gelb–Rot, die jeweils erste
Vorlage aus der Auswahl von web-apps:
asc_setCF([], [], [c_oAscCFRuleTypeSettings.dataBar | colorScale, 0]).asc_clearCF(c_oAscSelectionForCFType.selection)nimmt sie von den ausgewählten Zellen.
Pivot-Tabellen¶
src/cell-pivot.ts, nach dem Desktop-Tabelleneditor von web-apps (controller/PivotTable.js,
view/PivotSettings.js, view/ValueFieldSettingsDialog.js); die Engine hält und berechnet die Tabelle
(cell/model/PivotTables.js CT_pivotTableDefinition), und x2t schreibt sie mit ihrem Cache in die .xlsx
(xl/pivotTables/, xl/pivotCache/).
- Eine neue („Einfügen → Pivot-Tabelle …“): Der Dialog beginnt mit der Tabelle um die aktive Zelle
(
asc_getAddPivotTableOptions().asc_getRange()), geprüft mitasc_checkDataRange( c_oAscSelectionDialogType.PivotTableData, …);asc_insertPivotNewWorksheet(source, "Pivot<n>")legt sie auf ein neues Blatt mit dem ersten freien Namen (createSheetName). Wo der Bereich keine Überschriften hat, antwortet es nichts; der Dialog sagt das. - Die Tabelle an der aktiven Zelle kommt mit der Auswahl:
asc_getCellInfo().asc_getPivotTableInfo(). Ihre Felder sindasc_getPivotFields()(oder die Namen ausasc_getCacheFields()der Quelle), und die vier Bereicheasc_getPageFields(),asc_getColumnFields(),asc_getRowFields()(Feldindizes;-2ist der Eintrag „Werte“, sobald es zwei Werte gibt) undasc_getDataFields()(CT_DataFieldmit der Quellspalte, dem Namen undc_oAscDataConsolidateFunction). Die Feldliste neben dem Raster zeigt sie, solange die aktive Zelle in einer Pivot-Tabelle liegt. - Anordnen: Ein angehaktes Feld kommt mit
asc_addFieldhinein (Zahlen zu den Werten, andere zu den Zeilen,CT_CacheField.isSumSubtotal), ein abgehaktes mitasc_removeFieldheraus;asc_moveToRowField,asc_moveToColField,asc_moveToPageField,asc_moveToDataFieldverschieben eines (einen Wert mit seinem Platz unter den Werten). Statt Ziehen bietet jeder Eintrag an, wohin er darf. - Wie ein Wert zusammengefasst wird: ein
CT_DataFieldmitasc_setSubtotalundasc_setName, angewandt mitvalue.asc_set(api, pivot, index, change). Werte heißen so, wie das deutsche Excel sie nennt („Summe von Betrag“, „Anzahl von …“): Die Engine füllt ihr Namensmuster (%1 of %2) mit dem englischen Funktionsnamen, deshalb benennt die App jeden neuen Wert sofort um. - Aktualisieren, nachdem sich die Quelle geändert hat:
asc_refresh(api)auf der Tabelle, über „Daten“, das Kontextmenü oder die Feldliste. - Beschriftungen in der Sprache der Oberfläche: „Gesamtergebnis“, „Zeilenbeschriftungen“,
„Spaltenbeschriftungen“, „Werte“, „(Alle)“, „(Leer)“ auf Deutsch, über die
translate-Map, mit der die API erzeugt wird (OpenOptions.texts, gefüllt vonapps/web/src/editor/engine-texts.ts; die Schlüssel sind die Beschriftungen ausPivotTables.js, so wieMain.jsvon web-apps sie übergibt). - Die Engine ändert die Tabelle ohne Änderung der Auswahl, deshalb liest jeder Befehl den Zustand neu.
CSV-Dateien¶
Eine .csv öffnet sich im Tabelleneditor und wird wieder als CSV gespeichert, mit dem Trennzeichen, mit dem
sie kam (src/csv.ts detectDelimiter: das, das die meisten der ersten Zeilen außerhalb von
Anführungszeichen benutzen, ein Feld in Anführungszeichen, das über einen Zeilenumbruch weiterläuft,
eingeschlossen, ein Anführungszeichen mitten in einem Feld wie 27" setzt nichts in Anführungszeichen, bei
Gleichstand „;“). Der Editor sagt einmal, dass nur Werte erhalten bleiben.
- Lesen: x2t liest eine CSV in eine .xlsx, nicht ins Binärformat (das bricht mit Fehler 89 ab), und nur
mit beiden Formaten im Auftrag (
m_nFormatFrom260,m_nFormatTo257) sowiem_nCsvTxtEncoding46 (UTF-8) undm_nCsvDelimiter(c_oAscCsvDelimiter: Tab 1, „;“ 2, „,“ 4);m_nLcid1031 lässt es „-4,20“ und „01.10.2026“ als Zahl und Datum lesen (CoreX2tConverter/src/cextracttools.h,OOXML/Binary/Sheets/Reader/CSVReader.cpp). Die .xlsx öffnet sich dann wie gewohnt. - Schreiben geschieht in der Seite, nicht in x2t: Der CSV-Writer von x2t kodiert Text über ICU, das im
WebAssembly-Build keine Konverterdaten hat, sodass jedes Zeichen jenseits von ASCII als ein einzelnes Byte
herauskam (
Writer/CSVWriter.cppWriteFile,UnicodeConverter.cppfromUnicode). Die Werte sind die des aktiven Blatts, so wie seine Zellen sie zeigen, über die Document-Builder-API (api.getJsApi().GetActiveSheet().GetUsedRange().GetText(),cell/apiBuilder.js), undencodeCsvschreibt sie als UTF-8 mit Byte Order Mark und CR LF und setzt in Anführungszeichen, was das Trennzeichen, ein Anführungszeichen oder einen Zeilenumbruch enthält. „Als CSV herunterladen“ auf einer .xlsx macht dasselbe mit „;“.
Präsentationen¶
src/slide.ts bindet die Präsentations-Engine an (slide/api.js), eingerichtet, wie es
presentationeditor/mobile von web-apps tut: SetDrawingFreeze(true) und SetThemesPath vor dem Laden,
SetDrawingFreeze(false), zoomFitToPage(), sobald das Dokument angezeigt wird. Die Engine zeichnet die
Folienliste und das Notizfeld in ihrem Frame; die Notizen erscheinen, sobald das Dokument angezeigt wird
(asc_ShowNotes(true), wie es der Desktop-Editor von web-apps tut, wenn sie nicht ausgeblendet waren), und
„Ansicht → Notizen“ blendet sie aus und ein. Die Engine meldet nicht, ob sie sichtbar sind, deshalb hält der
Befehl das im Zustand fest. Ihre eigenen Texte (leere Platzhalter, „click to add
notes“) kommen aus der translate-Map, mit der die API erzeugt wird (OpenOptions.texts): Die App übergibt
sie in der Sprache der Oberfläche (apps/web/src/editor/engine-texts.ts); ohne sie zeigt die Engine ihr
eigenes Englisch (common/editorscommon.js CTranslateManager.getValue gibt den Schlüssel zurück).
Die Zeichenformatierung heißt genauso und wird genauso gemeldet wie im Texteditor, deshalb teilen sich beide
createCharacterCommands und textEvents (put_TextPrBold, asc_onBold, …).
| Befehl | Aufruf in der Engine (slide/api.js) | Event zurück |
|---|---|---|
| neue Folie | AddSlide(layoutIndex) |
asc_onCountPages, asc_onCurrentPage |
| Layout | ChangeLayout(layoutIndex); die Layouts mit ihren Bildern: asc_onUpdateLayout (CLayoutThumbnail) |
– |
| duplizieren, löschen | DublicateSlide() (die Schreibweise der Engine), DeleteSlide() |
asc_onCountPages |
| Aufzählung, Nummerierung | put_ListType(0 \| 1, 1), beenden: put_ListType(…, -1) (CommonController.js fFillBullet) |
asc_onListType |
| Zeichenformatierung, Ausrichtung, rückgängig | wie im Texteditor | wie im Texteditor |
| Zwischenablage, Zoom, Suchen und Ersetzen | wie im Texteditor (Copy, zoom, asc_findText, …) |
wie im Texteditor |
WordControl.m_oDrawingDocument.ToRendererPart(true, false): alle Folien, wie slide/api.js _downloadAs |
– |
Formen, Designs und Übergänge¶
src/slide-design.ts, nach web-apps (presentationeditor/mobile controller/add/AddShape.jsx,
controller/edit/EditSlide.jsx, lib/editor.jsx; main controller/Transitions.js):
- Formen („Einfügen“):
AddShapeOnCurrentPage(preset)setzt eine Form in die Mitte der Folie, ausgewählt: ein Textfeld (textRect, gespeichert mittxBox="1"), ein Rechteck (rect), ein abgerundetes (roundRect), eine Ellipse, einen Pfeil (rightArrow) und eine Linie. Die Tasten gehen danach wieder an die Engine, sodass Tippen das Textfeld füllt. - Designs („Design“): Die Engine lädt die Liste ihrer Designs aus
themes.jsim Design-Pfad (SetThemesPath,g_defaultThemes) und schickt sie mitasc_onInitEditorStyles([editor's, document's],CAscThemeInfomitget_Index,get_Name); das Menü benennt sie auf Deutsch.ChangeTheme(index)lädttheme<index + 1>/theme.binund wendet es auf jede Folie an. Das verwendete Design wird nur über seinen Master gemeldet (asc_onUpdateThemeIndexmit-master - 1), deshalb ist keines angehakt. - Übergänge („Übergänge“):
SetSlideProps(props)mit einemCAscSlideTransitionausc_oAscSlideTransitionTypesund jeweils der ersten Option, so wiefillEffectTypesvon web-apps sie wählt (c_oAscSlideTransitionParams), auf den ausgewählten Folien;SlideTransitionApplyToAll()gibt den Übergang der aktuellen Folie allen Folien. Der Übergang der ausgewählten Folie kommt mitasc_onFocusObject(das Objekt vom TypSlide,get_transition().get_TransitionType()) und wird angehakt.
Die Bildschirmpräsentation steht in „Ansicht“ (von Anfang an oder ab der aktuellen Folie), neben der Schaltfläche „Präsentieren“.
Ein Rechtsklick schickt CContextMenuData wie im Texteditor; sein Typ unterscheidet die Folie
(c_oAscContextMenuTypes.Main) von der Folienliste (Thumbnails), und das Kontextmenü bietet in der Liste
zuerst die Folien an (apps/web/src/editor/slide-menus.ts).
Neue Präsentationen kommen aus packages/ooxml (pptx.ts): ein Master mit den Layouts
„Titelfolie“, „Titel und Inhalt“, „Nur Titel“ und „Leer“, ein Design mit den Standardfarben von Office
und Calibri, 16:9.
Bildschirmpräsentation¶
„Präsentieren“ (und „Ansicht → Bildschirmpräsentation …“, von Anfang an oder ab der aktuellen Folie) zeigt
die Folien im Vollbild, so wie es die Vorschau von web-apps tut (controller/Viewport.js
onPreviewStart, mobil controller/Preview.jsx). Die Engine zeichnet die Präsentation in ein Element
ihrer eigenen Seite, #presentation-preview (CDemonstrationManager.Start in
slide/Drawing/Transitions.js), und behandelt die Pfeiltasten, Leertaste, Klicks und Escape dort selbst,
aber nur, solange nichts in ihrer Seite die Tasten hält (wrapKeyboard); deshalb gibt src/slide-show.ts
dem Fenster des Frames den Fokus und nimmt ihn vorher der Eingabe der Engine. Die App schaltet den Frame ins
Vollbild und startet die Präsentation, sobald sie die Größe des Bildschirms hat
(StartDemonstrationFromBeginning, StartDemonstrationFromCurrentSlide). Das Vollbild zu verlassen,
beendet die Präsentation (EndDemonstration), und das Ende der Präsentation (asc_onEndDemonstration)
verlässt das Vollbild. Wer nur ansehen darf, kann ebenfalls präsentieren.
PDFs¶
Der PDF-Editor der Engine (pdf/api.js PDFEditorApi) ist in das Bundle für Textdokumente eingebaut,
word/sdk-all-min.js; sdkjs/pdf/src/engine/ fügt seinen Renderer hinzu, drawingfile.wasm, der das PDF
selbst liest und zeichnet. Deshalb führt engine.json pdf unter den Editoren, und seine Host-Seite
(frame/editor/pdf/main/index.html) lädt das Word-Bundle und wird auf PDFEditorApi geprüft.
Anders als bei den Office-Editoren braucht ein PDF zum Öffnen keine Konvertierung und behält beim Speichern sein Format:
- Öffnen.
asc_openDocumentFromBytes(pdf)mit den eigenen Bytes des PDFs; der Editor gibt sie andrawingfile.wasmweiter (PDFEditorApi.openDocument→DocumentRenderer.open). Die Dokumentinfo nenntpdfals Format; der Rest der Ladekette ist der aus Wie ein Dokument geöffnet wird. - Seitenminiaturen. Hat die Host-Seite ein Element
thumbnails-list, füllt der Editor es bei Content-Ready mit den Seitenminiaturen (onDocumentContentReady,pdf/src/thumbnails.js). Drehen, Entfernen und Verschieben von Seiten wirken auf die dort ausgewählten Seiten, deshalb hat die Seite eins. - Speichern.
DocumentRenderer.Save()des Editors (pdf/src/viewer.js) gibt eine Änderungsdatei zurück, kein PDF: „%PDF“ und die Seiten, Anmerkungen, Formularwerte und Seitenoperationen, die sich geändert haben. x2t schreibt sie ins Original: Der Worker legt das Original neben die Änderungsdatei (changes/changes0.bin) und setztm_bFromChangesmit dem PDF-Format (513) in beide Richtungen, und x2t wendet sie an (X2tConverter/src/lib/pdf_image.hfromCrossPlatform→applyChangesPdf→applyCompiledChangesPdf). Das istsavefromorigindes Document Server (word/api.js_downloadAs), erledigt im Browser.createConverter().applyPdfChanges(original, changes, media)fordert es an.
e2e/pdf-engine.spec.ts prüft diesen Vertrag unterhalb der App: Es öffnet test-files/formular.pdf in
der Host-Seite, dreht eine Seite, entfernt eine, füllt ein Feld aus, speichert über den Worker, öffnet das
Ergebnis erneut und liest die Datei mit pdf-lib zurück.
Die PDF-Ansicht und ihre Werkzeuge bauen darauf auf; siehe PDFs.
Tests¶
packages/editor-core/test prüft das Binding gegen einen Ersatz für die Engine
(test/fake-engine.ts): was jeder Befehl aufruft und wie Events der Engine zu Zustand werden. Die
E2E-Specs lassen die echte Engine in Chromium laufen:
| Spec | Was sie abdeckt |
|---|---|
e2e/word-roundtrip.spec.ts |
eine .docx, geöffnet und wieder gespeichert, mit Inhalt, Bildern, Kommentaren und Formatierung |
e2e/word-formatting.spec.ts, e2e/word-menus.spec.ts |
die Werkzeugleiste und die Menüs des Texteditors: Formatierung, Listen, Layout, Kopfzeilen, Fußnoten, Umbrüche |
e2e/comments.spec.ts, e2e/review.spec.ts |
Kommentare mit Antworten, Erledigen und Löschen; nachverfolgte Änderungen |
e2e/spelling.spec.ts |
die Markierungen und Vorschläge der Rechtschreibprüfung, nach Sprache |
e2e/spreadsheet.spec.ts, e2e/pivot.spec.ts |
der Tabelleneditor und Pivot-Tabellen |
e2e/presentation.spec.ts |
der Präsentationseditor und die Bildschirmpräsentation |
e2e/formats.fidelity.ts |
die Bilder zur Formattreue (Architektur) |