linkcad.controller

Übergeordneter Controller für den Konvertierungsablauf. Verwenden Sie ihn, wenn Sie die vollständige Zustandsmaschine des Konvertierungsassistenten brauchen (Formate wählen, Optionen setzen, lesen, Tools anwenden, schreiben), statt linkcad.conv direkt zu steuern.

from linkcad.v1.controller import (
    ConversionController, ConversionState,
    ControllerEvent, IControllerListener, ProgressInfo,
)

Klassen

ConversionController

Steuert den mehrstufigen Konvertierungsablauf des LinkCAD-Assistenten.

from linkcad.v1.controller import ConversionController

ctrl = ConversionController()
ConversionController.import_format = "GDSII"
ConversionController.export_format = "DXF"
ctrl.selected_input_files = ["/data/design.gds"]
ConversionController.output_file = "/data/design.dxf"

ctrl.start_read()
dwg = ctrl.current_drawing
if dwg is None:
    raise RuntimeError("Import produced no drawing")

ctrl.start_write()
print(ctrl.current_state)

Formatauswahl und Ausgabepfad sind prozessweiter Zustand der Engine; import_format, export_format und output_file sind daher statische Eigenschaften: weisen Sie sie an der Klasse zu. Das Lesen über eine Instanz funktioniert ebenfalls und liefert denselben Wert.

Eigenschaft / Methode	Beschreibung
`ConversionController()`	Eine neue Controller-Instanz erzeugen
`ConversionController.import_format` / `.export_format`	Formatnamen (z. B. `"GDSII"`); statisch, zuweisbar
`ConversionController.output_file`	Pfad der Ausgabedatei; statisch, zuweisbar
`ctrl.selected_input_files`	Liste der Eingabedateipfade; zuweisbar
`ctrl.set_import_options(options_json)` / `ctrl.set_export_options(options_json)`	Optionen als JSON-Zeichenkette anwenden
`ctrl.tools_enabled`	Ob zwischen Lesen und Schreiben Tools laufen; zuweisbar
`ctrl.configure_tools(tools_config)`	Die Tool-Stufe per JSON konfigurieren
`ctrl.batch_mode`	Stapelverarbeitungsmodus; zuweisbar
`ctrl.start_read()`	Das Lesen der Eingabedatei(en) starten
`ctrl.start_write()`	Das Schreiben der Ausgabedatei starten
`ctrl.start_batch()`	Eine Stapelkonvertierung starten
`ctrl.finish_operation(success)`	Die aktuelle Operation als abgeschlossen markieren
`ctrl.cancel_current_operation()`	Die laufende Operation abbrechen
`ctrl.operation_in_progress`	`True`, solange eine Operation läuft
`ctrl.next()` / `ctrl.back()` / `ctrl.reset()`	Durch die Zustände des Ablaufs navigieren
`ctrl.can_go_next` / `ctrl.can_go_back`	Ob Navigation möglich ist
`ctrl.current_state`	Aktueller `ConversionState`
`ctrl.current_drawing`	Die geladene `Drawing` oder `None`
`ctrl.current_progress`	Aktuelle `ProgressInfo`
`ctrl.import_log`	Importprotokoll, als `IEventLogReader`
`ctrl.export_log`	Exportprotokoll, als `IEventLog`
`ctrl.conversions`	Die zugrunde liegende `Conversions`-Sammlung — siehe linkcad.conv
`ctrl.add_listener(listener)` / `ctrl.remove_listener(listener)`	Einen `IControllerListener` an- oder abmelden

set_import_options() und set_export_options() bleiben Methoden: der Controller reicht das JSON direkt an das Plugin weiter und behält nichts zum Auslesen, und eine Eigenschaft ohne Getter ist keine Eigenschaft.

ConversionState

Enum, das jede Seite des Konvertierungsassistenten benennt.

Wert	Beschreibung
`ConversionState.Begin`	Anfangszustand
`ConversionState.SelectFormat`	Auswahl von Import- und Exportformat
`ConversionState.ImportOptions`	Seite mit Importoptionen
`ConversionState.ExportOptionsPre`	Exportoptionen, vor dem Lesen angezeigt
`ConversionState.ReadFile`	Lesen der Eingabedatei(en)
`ConversionState.ApplyTools`	Anwenden der Geometrie-Tools
`ConversionState.ReadLog`	Durchsicht des Importprotokolls
`ConversionState.OpenPolys`	Behandlung offener Polylinien
`ConversionState.BatchTools`	Tool-Konfiguration für Stapelläufe
`ConversionState.Structure`	Seite zur Zellen-/Ebenenstruktur
`ConversionState.ExportOptionsPost`	Exportoptionen, nach dem Lesen angezeigt
`ConversionState.SelectBatchFiles`	Auswahl der Stapeldateien
`ConversionState.ConvertBatchFiles`	Stapelkonvertierung läuft
`ConversionState.WriteFile`	Schreiben der Ausgabedatei
`ConversionState.WriteLog`	Durchsicht des Exportprotokolls
`ConversionState.Summary`	Zusammenfassungsseite
`ConversionState.End`	Ablauf abgeschlossen

ControllerEvent

Enum der Benachrichtigungen, die ein Controller aussendet.

Wert	Beschreibung
`ControllerEvent.StateChanged`	Der Ablauf hat den Zustand gewechselt
`ControllerEvent.PageActivated`	Eine Assistentenseite wurde aktiv
`ControllerEvent.ProgressUpdated`	Die Fortschrittsinformation hat sich geändert
`ControllerEvent.LogUpdated`	Ein Protokoll hat Einträge erhalten
`ControllerEvent.DrawingChanged`	Die aktuelle Zeichnung wurde ersetzt
`ControllerEvent.OperationFinished`	Eine Operation wurde abgeschlossen
`ControllerEvent.OperationCancelled`	Eine Operation wurde abgebrochen
`ControllerEvent.ErrorOccurred`	Ein Fehler wurde gemeldet

ProgressInfo

Momentaufnahme des Fortschritts, geliefert von ctrl.current_progress.

Eigenschaft	Beschreibung
`percentage`	Fortschritt in Prozent (0-100)
`current_operation`	Beschreibung des aktuellen Schritts
`current_file`	Aktuell verarbeitete Datei
`current_file_index`	Index der aktuellen Datei
`total_files`	Anzahl der Dateien im Auftrag

IControllerListener

Leiten Sie hiervon ab, um Controller-Benachrichtigungen zu empfangen. Jede Methode muss überschrieben werden.

from linkcad.v1.controller import ConversionController, IControllerListener

class Watcher(IControllerListener):
    def on_state_changed(self, new_state): print(f"state: {new_state}")
    def on_page_activated(self, page): pass
    def on_progress_updated(self, progress): print(f"{progress.percentage}%")
    def on_log_updated(self): pass
    def on_drawing_about_to_be_cleared(self, drawing): pass
    def on_drawing_changed(self, drawing): pass
    def on_operation_finished(self, success): print(f"finished: {success}")
    def on_operation_cancelled(self): pass
    def on_error_occurred(self, message): print(f"error: {message}")

ctrl = ConversionController()
watcher = Watcher()
ctrl.add_listener(watcher)

Methode	Aufgerufen, wenn
`on_state_changed(new_state)`	Der Zustand des Ablaufs wechselt
`on_page_activated(page)`	Eine Assistentenseite aktiviert wird
`on_progress_updated(progress)`	Der Fortschritt aktualisiert wird
`on_log_updated()`	Ein Protokoll aktualisiert wird
`on_drawing_about_to_be_cleared(drawing)`	Unmittelbar bevor die aktuelle Zeichnung verworfen wird
`on_drawing_changed(drawing)`	Die Zeichnung wechselt
`on_operation_finished(success)`	Eine Operation abgeschlossen wird
`on_operation_cancelled()`	Eine Operation abgebrochen wird
`on_error_occurred(message)`	Ein Fehler auftritt