Ankündigung

Einklappen

Sammelbestellung ETS6 Vollversionen aktiv!

Sammelbestellung für ETS6 Vollversionen (Prof., Home, Lite) mit 40% Rabatt aktiv! Infos im Forum!
Mehr anzeigen
Weniger anzeigen

KNX ETS 6.3.1 unter Linux mit Wine - ERFOLG! - mit Anleitung

Einklappen
X
 
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

    #91
    Hallo RgSg86,

    gibt es schon ein neues Installationskript?
    Ich scheitere aktuell bei der Installation von ETS6. Der MicrosoftEdgeWebView2 schlägt fehl in der ETS6 Installation.

    Gruß

    Kommentar


      #92
      Zitat von ByteBanger25 Beitrag anzeigen
      Hallo RgSg86,

      gibt es schon ein neues Installationskript?
      Ich scheitere aktuell bei der Installation von ETS6. Der MicrosoftEdgeWebView2 schlägt fehl in der ETS6 Installation.

      Gruß
      Es gibt ein Winetricks Paket für WebView2, das wird von dem Script aktuell auch genutzt. Es fehlt dann nur noch der Segoe Schriftart-Ersatz (Wenn Winetricks Dotnet 4.0 und 4.8 bereits drauf ist) + Einstellungen für udev und Firewall, dann sollte es theoretisch auch ohne das Script laufen, wenn Wine 11.10 installiert ist. Das Script bzw. der Manager automatisiert nurnoch die Installation und die Einstellungen für udev, Firewall, Schriftart und verwaltet parallel installierte Versionen der ETS (wenn Wine 11.10 installiert). ETS 5.7.7 und beliebig viele Installationen der ETS6 in verschiedenen Versionen: kein Problem.

      WineHQ baut gerade einen vollwertigen WebView Ersatz extra für Wine, der Fortschritt ist mir aber nicht bekannt, nur das man daran aktuell aktiv arbeitet.

      ____________

      Seit Wine 11.10 ist Wine selber und die ETS absolut patchfrei. Ich arbeite gerade an einer WPF --> Vulkan Übersetzung, habe mich damit aber ein wenig übernommen, das wird noch was dauern. Ab dann sollte die ETS in der Performance ungefähr einer Windowsinstallation entsprechen. Nebenbei schraube schaue ich gerade bei Wine Mono mal drüber und versuche die Winetricks 4.0 und 4.8 damit loszuwerden, dass ist jedoch eine noch größere Baustelle die ich nicht alleine bearbeiten kann. WineHQ und die Entwickler dort sind dran! Ab dann: Installer runterladen und wie unter Windows bekannt einfach installieren und ausführen.

      Ab da schaue ich mir die Plugins, Addons etc. mal genauer an. Alles wieder direkt bei WineHQ selber als Patch einreichen, damit jede Anwendung, daher nicht nur die ETS, unter Wine davon was hat und man nicht im Programm selber und Wine lokal rumpatchen muss.

      ____________

      Ich bin seit einiger Zeit schon mit der KNX-A im Gespräch, da ergibt sich gerade etwas sehr Spannendes mit meinen Wine-Anpassungen. Für konkrete Aussagen ist es hier aber (noch) zu früh. Entschuldigt bitte die nebulöse Aussage, etwas Konkretes wird sicherlich im Laufe des Jahres folgen!

      ____________

      Die letzten paar Wochen waren bei mir recht stressig, sollte ich mit heutigem Stand eine PN, Mail etc. nicht beantwortet haben pingt mich gerne noch einmal an. Für neue Anfragen: Eine E-Mail-Adresse brauche ich, innerhalb der PNs kann ich keine 1,8MB verschicken.

      Kommentar


        #93
        Ich habe ETS6 einmal mit Wine 11.11 versucht, jedoch bricht er mit einer fehlerhaften Installation ab. Du beschreibst oben, dass es eigentlich ohne patches laufen sollte?
        Kannst Du mir bitte einmal das Skript schicken? Dann kann ich schauen was es macht. PN ist schon in deinem Postfach.

        Kommentar


          #94
          So, nochmal ein Update:

          Ich war seit März 2026 mit der KNX-A im Gespräch bzgl. meinem Wine-Ansatz. Zu Beginn war man dem Ansatz sehr aufgeschlossen und wollte das sogar offiziell unterstützen. Das waren eigentlich sehr konstruktive Diskussionen über mehrere Monate hinweg.

          Es wurden diverse "Schlachtpläne" geschmiedet, eine Newsmeldung der KNX-A selber war im Gespräch, es wurde über Tools wie ein eigenes GitLab etc. von der KNX-A diskutiert. Das sah eigentlich alles sehr vielversprechend aus.

          Um es abzukürzen: Letzte Woche wurde mir dann final mitgeteilt, das man den Ansatz doch nicht verfolgen wird, da man den Supportaufwand und auch die Sicherheit nicht gewährleisten kann. Ich habe hier vollstes Verständnis für, musste das trotzdem erst einmal sacken lassen nach monatelangen, guten Diskussionen.

          Ich hatte ein Schweigen zu den Details der möglichen Zusammenarbeit mit der KNX-A vereinbart, damit diese das entsprechend selber ankündigen können. Jetzt, da es diese Zusammenarbeit nicht geben wird, kann ich hier ein wenig offener drüber sprechen.

          Ich wurde höflich, aber doch bestimmt, darauf hingewiesen, dass man Manipulationen in den ETS Dateien selber und auch ein Manipulieren der USB/Ethernet Verbindungen nicht akzeptieren kann, auch hierfür habe ich vollstes Verständnis. Genau das war auch der Grund, warum ich mich damit an die KNX-A gewandt hatte, erste Versionen manipulierten tatsächlich die Dateien innerhalb der ETS. In der aktuellsten Version entfällt dies komplett, die ETS 6 ist, wie bereits zuvor hier geschrieben, mit Wine 10.10 zu 100% patchfrei, ebenso Wine selber. Die 5.7.7. läuft aktuell nicht patchfrei (glaube ich), das schaue ich mir noch einmal an und patche bei Wine selber nach.

          USB- und Ethernetverbindungen wurden nie manipuliert, es fehlten nur die entsprechenden Verbindung innerhalb von Wine (sehr vereinfacht ausgedrückt). Ich habe einfach nur dafür gesorgt, dass die Daten da ankommen wo sie hingehören, den Inhalt der Kommunikation selber aber nie angefasst.

          Ich habe das Projekt selber ab Anfang Mai ein wenig hinten anstellen müssen, da ich in einer Abschlussprüfungsphase war. Aber hey, jetzt ist alles bestanden und durch!

          Wie geht es weiter:

          Ich werde vorerst keinen Manager mehr verteilen. Wie geschrieben hatten erste Versionen tatsächlich Manipulationen in den ETS Dateien selber vorgenommen (recht harmlos, wie einzelne Bits von 0 auf 1 oder einen Wert von 00 auf FF gesetzt) und ich kann nicht ausschließen, dass in der letzten Version da noch Codefragmente drin sind. Daher baue ich das alles einmal von Grund auf neu, zusätzlich stark entschlackt. Das veröffentliche ich dann auch zeitnah nachdem es in Tests geprüft wurde.

          Bis diese neue Version fertig ist baue ich mal eine Anleitung mit allen Schritten die nötig sind, um die ETS per Hand zu installieren. So viel ist das gar nicht, so aus dem Kopf wären das aktuell nur noch Winetricks 4.0, Winetricks 4.8, Winetricks Allfonts und eine udev Regel (für USB) unter Linux. Ich hoffe das kommt zeitnah, kann aber nichts versprechen.

          Nebenbei baue ich bei Wine selber weiter. Wie schon mehrfach erwähnt, Endziel ist ein Doppelklick auf den Installer und alles verhält sich so wie unter Windows, der Nutzer merkt keinen Unterschied.


          Entschuldigt bitte einige noch nicht beantwortete PNs, ich musste für mich selber erst einmal überlegen wie es weiter gehen soll.

          Abschließend: Ich habe vollstes Verständnis für die finale Entscheidung der KNX-A, das kann man echt schwer offiziell unterstützen. Ich mache da niemanden einen Vorwurf. Schade ist nur das ganze Vorgeplänkel und die erst Monate später erfolgte Absage, trotz anfänglicher sehr positiver Signale. Vielleicht wird eine zukünftige ETS 7 (deren Entwicklungszustand ich nicht kenne, geschweige denn ob diese bereits in Entwicklung ist) das Multi-OS-freundlicher lösen.

          Kommentar


            #95
            Es gab ja schon eine ETS für Linux... aber so lange man Plugins offiziell unterstützt , wird es das nicht geben.
            Dieser Beitrag enthält keine Spuren von Sarkasmus... ich bin einfach so?!

            Kommentar


              #96
              ETS6 unter Linux per Hand installieren

              Schritt-für-Schritt-Anleitung für ETS 6.4.1 unter Wine.
              Stand: 01.07.2026 - 00:23 Uhr

              Diese Anleitung modifiziert keine ETS/KNX-Binaries. ETS6 wird unverändert installiert, nur die Wine-Umgebung wird vorbereitet. Die ETS-Lizenz bleibt unberührt.

              Jeder Schritt hat am Ende einen PRÜFEN-Block, mit dem sich kontrollieren lässt, ob er geklappt hat.

              Voraussetzungen
              • Wine 11.10 oder neuer. Ab 11.10 läuft ETS6 ohne jeden Wine-Patch (alle nötigen Fixes sind upstream gemerged).
              • Die ETS 6.4.1 setup.exe (Build 8722) aus dem MyKNX-Konto.
              • Ca. 3 GB freier Platz für das Wine-Prefix, plus der Platz für die ETS6 selbst.


              Im Folgenden ist das Prefix als ~/.wine-ets6 angenommen. Diese Variable einmal pro Terminal setzen:

              Code:
              export WINEPREFIX="$HOME/.wine-ets6"


              Schritt 1: Systempakete installieren

              Arch / CachyOS / EndeavourOS / Manjaro:
              Code:
              sudo pacman -S --needed wine winetricks python-fonttools cabextract unzip wget p7zip msitools gcc
              Debian / Ubuntu / Mint / Pop!_OS:
              Code:
              sudo dpkg --add-architecture i386
              sudo apt update
              sudo apt install wine64 wine32 winetricks python3-fonttools cabextract unzip wget p7zip-full msitools
              Fedora / Nobara:
              Code:
              sudo dnf install wine winetricks python3-fonttools cabextract unzip wget p7zip msitools
              openSUSE:
              Code:
              sudo zypper install wine winetricks python3-fonttools cabextract unzip wget glibc-32bit p7zip msitools gcc
              msitools und p7zip entpacken die ETS-setup.exe (WiX-Burn-Bundle). python-fonttools wird in Schritt 7 gebraucht.

              PRÜFEN:
              Code:
              for t in wine winetricks 7z msiextract cabextract; do command -v $t >/dev/null && echo "OK  $t" || echo "FEHLT $t"; done
              Alle müssen OK zeigen (msiextract kommt aus msitools).

              Schritt 2: Wine-Version prüfen und ggf. aktualisieren

              Code:
              wine --version
              Ist die Ausgabe wine-11.10 oder höher, weiter zu Schritt 3. Sonst aktualisieren.

              Wichtig: ETS6 braucht 11.10 oder neuer, das ist Wines Development-Branch. Die WineHQ-stable-Serie ist 10.x und damit zu alt. Beim WineHQ-Repo immer winehq-devel (oder winehq-staging) installieren, NICHT winehq-stable.

              Arch / CachyOS / EndeavourOS / Manjaro (Repo ist immer aktuell):
              Code:
              sudo pacman -Syu wine
              Debian / Ubuntu / Mint / Pop!_OS (Distro-Wine ist meist zu alt, WineHQ-Repo nötig). "noble" durch den eigenen Codenamen ersetzen (lsb_release -cs), für Debian die .../debian/dists/<codename>/-URL nehmen:
              Code:
              sudo dpkg --add-architecture i386
              sudo mkdir -pm755 /etc/apt/keyrings
              sudo wget -O /etc/apt/keyrings/winehq-archive.key https://dl.winehq.org/wine-builds/winehq.key
              sudo wget -NP /etc/apt/sources.list.d/ https://dl.winehq.org/wine-builds/ubuntu/dists/noble/winehq-noble.sources
              sudo apt update
              sudo apt install --install-recommends winehq-devel
              Fedora / Nobara:
              Code:
              sudo dnf config-manager addrepo --from-repofile=https://dl.winehq.org/wine-builds/fedora/$(rpm -E %fedora)/winehq.repo
              sudo dnf install winehq-devel
              openSUSE (Beispiel Tumbleweed):
              Code:
              sudo zypper addrepo https://dl.winehq.org/wine-builds/opensuse/Tumbleweed/winehq.repo
              sudo zypper refresh
              sudo zypper install winehq-devel
              PRÜFEN: wine --version zeigt jetzt wine-11.10 oder höher.

              Schritt 3: Wine-Prefix anlegen (64-bit)

              Code:
              export WINEARCH=win64
              wineboot --init
              wineserver -w
              PRÜFEN:
              Code:
              ls "$WINEPREFIX/drive_c/windows/system32/" >/dev/null 2>&1 && echo "OK Prefix angelegt" || echo "FEHLT Prefix"


              Schritt 4: .NET Framework 4.0 + 4.8 installieren

              Der langwierige Schritt (mehrere Minuten je Runtime). winetricks lädt die echten Microsoft-Installer und führt sie im Prefix aus.

              Code:
              winetricks -q remove_mono
              winetricks -q dotnet40
              winetricks -q dotnet48
              Danach .NET-Overrides setzen, damit ETS das echte .NET statt Wine-Mono nutzt:
              Code:
              wine reg add 'HKCU\Software\Wine\DllOverrides' /v '*mscoree' /t REG_SZ /d 'native,builtin' /f
              wine reg add 'HKCU\Software\Wine\DllOverrides' /v 'mscoree'  /t REG_SZ /d 'native,builtin' /f
              remove_mono kann eine Warnung ausgeben (unkritisch). Falls beim dotnet48-Lauf ein "Mono installieren?"-Popup kommt, abbrechen.

              PRÜFEN:
              Code:
              ls "$WINEPREFIX/drive_c/windows/Microsoft.NET/Framework64/v4.0.30319/clr.dll" 2>/dev/null
              
              && echo "OK .NET 4.x vorhanden" || echo "FEHLT .NET (dotnet48 nicht durchgelaufen)"


              Schritt 5: Visual C++ Runtime + GDI+ + Windows-Version

              Code:
              winetricks -q vcrun2022
              winetricks -q gdiplus
              winetricks -q win10
              Die 11 VC-Runtime-DLLs auf native,builtin zwingen:
              Code:
              for dll in concrt140 msvcp140 msvcp140_1 msvcp140_2 msvcp140_atomic_wait
              
              msvcp140_codecvt_ids vcamp140 vccorlib140 vcomp140 vcruntime140 vcruntime140_1; do
              wine reg add 'HKCU\Software\Wine\DllOverrides' /v "*$dll" /t REG_SZ /d 'native,builtin' /f
              done
              PRÜFEN:
              Code:
              ls "$WINEPREFIX/drive_c/windows/system32/vcruntime140.dll" 2>/dev/null
              
              && echo "OK vcrun2022" || echo "FEHLT vcrun2022"


              Schritt 6: ETS 6.4.1 installieren

              Variante A (am einfachsten), den Pfad zur eigenen setup.exe anpassen:
              Code:
              wine /pfad/zu/ETS6-Setup.exe
              Durch den Installer klicken. ETS landet unter $WINEPREFIX/drive_c/Program Files (x86)/ETS6/.

              Variante B (wenn der GUI-Installer hängt): das WiX-Burn-Bundle manuell entpacken, die enthaltene(n) MSI mit msiextract auspacken und den ETS6-Ordner nach $WINEPREFIX/drive_c/Program Files (x86)/ETS6/ kopieren.
              Code:
              7z x ETS6-Setup.exe -oets6-extract
              Nach der Installation die .exe.config-Dateien um zwei .NET-Schalter ergänzen. Das ist eine reine Konfigurations-XML neben der Binary, kein Eingriff in die EXE. In ETS6N.exe.config (und optional ETS6C.exe.config) innerhalb des <runtime>-Blocks einfügen:
              Code:
              <legacyCorruptedStateExceptionsPolicy enabled="true" />
              <AppContextSwitchOverrides value="Switch.System.Windows.Controls.Grid.StarDefinitionsCanExceedAvailableSpace=true" />
              Es genügt ETS6N.exe (64-bit). ETS6C.exe (32-bit) wird nur für ältere ETS3-Plugins gebraucht.

              PRÜFEN:
              Code:
              ls "$WINEPREFIX/drive_c/Program Files (x86)/ETS6/ETS6N.exe" 2>/dev/null
              
              && echo "OK ETS6N.exe installiert" || echo "FEHLT ETS6N.exe"


              Schritt 7: Schriftarten

              ETS erwartet drei Windows-Schriften.

              Segoe UI (Standard-UI-Schrift). WPF braucht eine echte Datei segoeui.ttf PLUS zwei Registry-Einträge:
              Code:
              cp /usr/share/fonts/liberation/LiberationSans-Regular.ttf
              
              "$WINEPREFIX/drive_c/windows/Fonts/segoeui.ttf" 2>/dev/null
              
              || cp /usr/share/fonts/TTF/DejaVuSans.ttf "$WINEPREFIX/drive_c/windows/Fonts/segoeui.ttf"
              
              wine reg add 'HKLM\Software\Microsoft\Windows NT\CurrentVersion\FontSubstitutes' /v 'Segoe UI' /t REG_SZ /d 'Segoe UI' /f
              wine reg add 'HKCU\Software\Wine\Fonts\Replacements' /v 'Segoe UI' /t REG_SZ /d 'Liberation Sans' /f
              Consolas (Log-Panels) auf eine Monospace-Familie:
              Code:
              wine reg add 'HKCU\Software\Wine\Fonts\Replacements' /v 'Consolas' /t REG_SZ /d 'Liberation Mono' /f
              Segoe MDL2 Assets (Icon-Font für die Titelleisten-Buttons close/minimize/maximize/restore). Microsoft-proprietär, nicht frei verteilbar. Eine funktionale Ersatzschrift lässt sich mit python-fonttools erzeugen. Das Skript make-mdl2.py steht am Ende dieses Beitrags (Abschnitt "Anhang"). Den Code dort in eine Datei make-mdl2.py speichern, dann:
              Code:
              python3 make-mdl2.py "$WINEPREFIX/drive_c/windows/Fonts/segmdl2.ttf"
              wine reg add 'HKLM\Software\Microsoft\Windows NT\CurrentVersion\Fonts' /v 'Segoe MDL2 Assets (TrueType)' /t REG_SZ /d 'segmdl2.ttf' /f
              Das ist eine vereinfachte Ersatzschrift: nur die Fenster-Buttons werden sauber dargestellt, exotischere MDL2-Symbole bleiben leer. Für ETS reicht das. Wer die echte Schrift hat, kann stattdessen segmdl2.ttf von einem Windows-System kopieren.

              PRÜFEN:
              Code:
              for f in segoeui.ttf segmdl2.ttf; do ls "$WINEPREFIX/drive_c/windows/Fonts/$f" >/dev/null 2>&1 && echo "OK $f" || echo "FEHLT $f"; done


              Schritt 8: Firewall für KNXnet/IP

              ETS kommuniziert mit IP-Gateways über UDP-Port 3671.
              Code:
              ufw (Debian/Ubuntu):
              sudo ufw allow 3671/udp
              
              firewalld (Fedora/openSUSE):
              sudo firewall-cmd --permanent --add-port=3671/udp && sudo firewall-cmd --reload
              Ohne aktive Firewall (Standard auf vielen Arch-Systemen) nichts zu tun.

              Schritt 9: WPF-Software-Modus + Desktop-Integration --- WICHTIG

              Ohne diesen Schritt bleibt das Hauptfenster schwarz. ETS6 nutzt WPF-Hardware-Rendering, das unter Wine auf einen langsamen Software-Blit zurückfällt. Lösung: WPF in den Software-Modus zwingen.
              Code:
              wine reg add 'HKCU\SOFTWARE\Microsoft\Avalon.Graphics' /v DisableHWAcceleration /t REG_DWORD /d 1 /f
              WebView2-Stubs (ETS prüft diese Keys beim Start, die Werte müssen nur vorhanden sein):
              Code:
              GUID='{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}'
              VER='109.0.1518.140'
              wine reg add "HKCU\Software\Microsoft\EdgeUpdate\ClientState\$GUID" /v pv /t REG_SZ /d "$VER" /f
              wine reg add "HKCU\Software\Microsoft\EdgeUpdate\Clients\$GUID"     /v pv /t REG_SZ /d "$VER" /f
              wine reg add 'HKCU\Software\Wine\AppDefaults\msedgewebview2.exe' /v Version /t REG_SZ /d 'win7' /f
              DPI bei hochauflösenden Monitoren (96=100%, 120=125%, 144=150%):
              Code:
              wine reg add 'HKCU\Control Panel\Desktop' /v LogPixels /t REG_DWORD /d 120 /f
              Hinweis Skalierung: Unter X11/XWayland (Standard) ist die Skalierung kein Problem. Unter nativem winewayland.drv wurde die fraktionale Skalierung erst mit Wine 11.12 eingebaut, mit älterem Wine rendert ETS dort zu klein. Der LogPixels-Wert oben ist die manuelle Korrektur.

              PRÜFEN:
              Code:
              wine reg query 'HKCU\SOFTWARE\Microsoft\Avalon.Graphics' /v DisableHWAcceleration 2>/dev/null | grep -q 0x1 && echo "OK SW-Modus aktiv" || echo "FEHLT DisableHWAcceleration"


              Schritt 10: USB-Lizenz-Dongle (udev-Regel)

              KNX-Dongle: Vendor 2a07, Product 0102.
              Code:
              sudo tee /etc/udev/rules.d/90-knx-usb.rules > /dev/null <<'EOF'
              SUBSYSTEM=="usb", ATTRS{idVendor}=="2a07", ATTRS{idProduct}=="0102", MODE="0660", GROUP="plugdev", TAG+="uaccess"
              EOF
              sudo udevadm control --reload-rules
              sudo udevadm trigger
              Danach Dongle aus- und wieder einstecken. Hat deine Distro keine plugdev-Gruppe, GROUP="users" verwenden. TAG+="uaccess" gibt dem eingeloggten Desktop-Nutzer automatisch Zugriff.

              PRÜFEN (mit gestecktem Dongle):
              Code:
              lsusb | grep -i 2a07 && echo "Dongle erkannt" || echo "Dongle nicht gefunden (Vendor 2a07)"


              Schritt 11: ETS starten

              Code:
              WINEPREFIX="$HOME/.wine-ets6" wine "C:\Program Files (x86)\ETS6\ETS6N.exe"
              Endprüfung:

              - Splash-Screen (grün, KNX-Logo) erscheint.
              - Hauptfenster öffnet sich und zeigt Inhalt (nicht schwarz). Bleibt es schwarz, wurde Schritt 9 (DisableHWAcceleration) nicht angewendet.
              - Mit Dongle: Lizenz wird erkannt. Ohne Dongle: Demo-Modus.
              - Cloud-Lizenzen sollten keine Probleme machen und problemlos erkannt werden nach dem einloggen

              Fehlerbehebung: .NET-Reparatur

              Falls ETS nach Schritt 11 mit .NET-Ladefehlern startet, war der dotnet48-Lauf (Schritt 4) vermutlich unvollständig. Dann Schritt 4 in einem frischen Prefix wiederholen, oder gezielt die fehlenden Komponenten über winetricks nachinstallieren. Bei einem sauberen Schritt 4 ist das nicht nötig.

              Anhang: make-mdl2.py (für Schritt 7, Segoe MDL2 Assets)

              Den folgenden Code in eine Datei make-mdl2.py speichern. Wichtig: Die Einrückung muss erhalten bleiben (Python ist einrückungs-sensitiv). Beim Kopieren aus dem Code-Block bleibt sie erhalten.

              Code:
              #!/usr/bin/env python3
              """Minimaler Segoe-MDL2-Assets-Ersatz fuer ETS6 unter Wine.
              
              Erzeugt eine segmdl2.ttf mit den Fenster-Chrome-Symbolen die ETS6 in der
              Titelleiste nutzt (close/minimize/maximize/restore). Vereinfachte Glyphen,
              fuer ETS ausreichend. Benoetigt python-fonttools.
              
              Aufruf:
              python3 make-mdl2.py /pfad/zu/segmdl2.ttf
              """
              import sys
              from fontTools.fontBuilder import FontBuilder
              from fontTools.pens.ttGlyphPen import TTGlyphPen
              
              EM = 2048
              
              Codepoints die ETS6 fuer die Titelleisten-Buttons nutzt
              CP = {0xE106: "close", 0xE73C: "indeterminate", 0xE921: "minimize",
              0xE922: "maximize", 0xE923: "restore", 0xEB90: "projectclose"}
              ORDER = [".notdef"] + list(dict.fromkeys(CP.values()))
              
              def box(pen, x0, y0, x1, y1, t=90):
              # gefuellter Rechteck-Rahmen (aussen CW, innen CCW = hohl)
              pen.moveTo((x0, y0)); pen.lineTo((x1, y0)); pen.lineTo((x1, y1)); pen.lineTo((x0, y1)); pen.closePath()
              pen.moveTo((x0+t, y0+t)); pen.lineTo((x0+t, y1-t)); pen.lineTo((x1-t, y1-t)); pen.lineTo((x1-t, y0+t)); pen.closePath()
              
              def stroke_h(pen, x0, x1, y, t=90):
              pen.moveTo((x0, y-t)); pen.lineTo((x1, y-t)); pen.lineTo((x1, y+t)); pen.lineTo((x0, y+t)); pen.closePath()
              
              def draw(name, pen):
              if name == "minimize":
              stroke_h(pen, 400, 1400, 300)
              elif name == "maximize":
              box(pen, 400, 300, 1400, 1300)
              elif name == "restore":
              box(pen, 300, 200, 1250, 1150)
              box(pen, 550, 450, 1500, 1400)
              elif name in ("close", "projectclose"):
              pen.moveTo((400, 350)); pen.lineTo((520, 230)); pen.lineTo((1500, 1210)); pen.lineTo((1380, 1330)); pen.closePath()
              pen.moveTo((1380, 230)); pen.lineTo((1500, 350)); pen.lineTo((520, 1330)); pen.lineTo((400, 1210)); pen.closePath()
              elif name == "indeterminate":
              stroke_h(pen, 500, 1300, 800)
              else:  # .notdef
              box(pen, 200, 100, 900, 1400, t=70)
              
              fb = FontBuilder(EM, isTTF=True)
              fb.setupGlyphOrder(ORDER)
              fb.setupCharacterMap(CP)
              glyphs, metrics = {}, {}
              for n in ORDER:
              pen = TTGlyphPen(None)
              draw(n, pen)
              glyphs[n] = pen.glyph()
              metrics[n] = (1800, 0)
              fb.setupGlyf(glyphs)
              fb.setupHorizontalMetrics(metrics)
              fb.setupHorizontalHeader(ascent=1638, descent=-410)
              fb.setupNameTable({"familyName": "Segoe MDL2 Assets", "styleName": "Regular",
              "fullName": "Segoe MDL2 Assets", "psName": "SegoeMDL2Assets-Regular"})
              fb.setupOS2(sTypoAscender=1638, sTypoDescender=-410, usWinAscent=1638, usWinDescent=410)
              fb.setupPost()
              out = sys.argv[1] if len(sys.argv) > 1 else "segmdl2.ttf"
              fb.save(out)
              print("geschrieben:", out)



              Abschließend:

              - Zusammengeschrieben aus meinem bisherigem Script und grob mit KI gegengeprüft, nicht breitbandig getestet!.
              - Ein neues Script ist in Arbeit, dass alle diese Schritte automatisiert abarbeitet.
              - Feedback ist erwünscht, mit konkretem Fehlerbild und Weg dahin
              - Wenn Probleme aufploppen gerne die KI eures Vertrauens befragen, anschließend gerne eine Zusammenfassung an mich

              Bekannte Probleme:


              - nicht jedes Addon läuft
              - die Bildwiederholungsrate kann auf System mit kleiner PCIe 5 nicht optimal sein



              Kommentar


                #97
                Zitat von RgSg86 Beitrag anzeigen
                ETS6 unter Linux per Hand installieren
                Vielleicht macht es Sinn die Anleitung im ersten Post zu verlinken, um ihn später einfach wieder zu finden!?!

                Kommentar


                  #98
                  ... und sie vielleicht auf Github, Codeberg oder Gitlab hosten, damit du issues einfacher tracken kannst (und wir nicht alle die gleichen Baustellen finden & melden)?

                  Kommentar


                    #99
                    Wow!
                    Smart Building Design GmbH (everything) - www.smart-building-design.com
                    Smart Building Services GmbH (Onlineshop) - www.knxshop4u.ch

                    Kommentar


                      ur63

                      grobe Verlinkung direkt auf der 1. Seite auf die 7. ist drin.

                      DiMa

                      ich baue wie angekündigt ein frisches Script + passendes GUI dazu, alles stark entschlackt, ohne Altlasten. Da sollte wie geschrieben nicht noch versteckt Code drinstecken, der die ETS selber anfasst. Wenn fertig geht das dann direkt auf Github etc.

                      Bin bereits dran, hoffe das zieht sich nicht so lange. Soll schlanker als das bisherige und maximal benutzerfreundlich sein, so das auch Linux Einsteiger sich da direkt zurechtfinden.

                      Ich brauche noch einen neuen Namen für das Projekt, Linux ETS Manager oder ETS on Linux möchte ich aus urheberrechtlichen Gründen vielleicht eher nicht nutzen.

                      Ein AppDB Eintrag bei Wine kommt noch.

                      Das mit dem Tracking, Debugging und Fixen für alle Addons, Plugins, DCA, was-auch-immer wird nochmal speziell. + Das Mammutprojekt bei Wine-Mono, damit die Winetricks raus können.

                      Man entwickelt da so oder so nicht für die Tonne falls die ETS7 das dann können sollte, geht ja direkt in das Wine Projekt.



                      Kommentar

                      Lädt...
                      X