extapps 0.1.0__py3-none-any.whl

extapps/map_packer/map_packer_ui.py

@@ -0,0 +1,260 @@
+# -*- coding: utf-8 -*-
+
+################################################################################
+## Form generated from reading UI file 'map_packer.ui'
+##
+## Created by: Qt User Interface Compiler version 6.10.1
+##
+## WARNING! All changes made in this file will be lost when recompiling UI file!
+################################################################################
+
+from PySide6.QtCore import (QCoreApplication, QDate, QDateTime, QLocale,
+    QMetaObject, QObject, QPoint, QRect,
+    QSize, QTime, QUrl, Qt)
+from PySide6.QtGui import (QBrush, QColor, QConicalGradient, QCursor,
+    QFont, QFontDatabase, QGradient, QIcon,
+    QImage, QKeySequence, QLinearGradient, QPainter,
+    QPalette, QPixmap, QRadialGradient, QTransform)
+from PySide6.QtWidgets import (QApplication, QComboBox, QGridLayout, QGroupBox,
+    QLabel, QLayout, QMainWindow, QPushButton,
+    QSizePolicy, QSpacerItem, QTabWidget, QVBoxLayout,
+    QWidget)
+
+from uitk.widgets.comboBox.ComboBox import ComboBox
+from uitk.widgets.footer import Footer
+from uitk.widgets.header import Header
+from uitk.widgets.lineEdit import LineEdit
+
+class Ui_QtUi(object):
+    def setupUi(self, QtUi):
+        if not QtUi.objectName():
+            QtUi.setObjectName(u"QtUi")
+        QtUi.setEnabled(True)
+        QtUi.resize(200, 299)
+        QtUi.setTabShape(QTabWidget.Triangular)
+        QtUi.setDockNestingEnabled(True)
+        QtUi.setDockOptions(QMainWindow.AllowNestedDocks|QMainWindow.AllowTabbedDocks|QMainWindow.AnimatedDocks|QMainWindow.ForceTabbedDocks)
+        self.central_widget = QWidget(QtUi)
+        self.central_widget.setObjectName(u"central_widget")
+        self.central_widget.setMinimumSize(QSize(200, 0))
+        self.verticalLayout = QVBoxLayout(self.central_widget)
+        self.verticalLayout.setSpacing(2)
+        self.verticalLayout.setObjectName(u"verticalLayout")
+        self.verticalLayout.setContentsMargins(2, 2, 2, 2)
+        self.main_layout = QVBoxLayout()
+        self.main_layout.setSpacing(6)
+        self.main_layout.setObjectName(u"main_layout")
+        self.main_layout.setSizeConstraint(QLayout.SetFixedSize)
+        self.header = Header(self.central_widget)
+        self.header.setObjectName(u"header")
+        sizePolicy = QSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.header.sizePolicy().hasHeightForWidth())
+        self.header.setSizePolicy(sizePolicy)
+        self.header.setMinimumSize(QSize(0, 19))
+        self.header.setMaximumSize(QSize(999, 19))
+        font = QFont()
+        font.setBold(True)
+        self.header.setFont(font)
+
+        self.main_layout.addWidget(self.header)
+
+        self.Formatting = QGroupBox(self.central_widget)
+        self.Formatting.setObjectName(u"Formatting")
+        self.gridLayout = QGridLayout(self.Formatting)
+        self.gridLayout.setObjectName(u"gridLayout")
+        self.gridLayout.setContentsMargins(0, 0, 0, 0)
+        self.cmbB = ComboBox(self.Formatting)
+        self.cmbB.setObjectName(u"cmbB")
+        sizePolicy.setHeightForWidth(self.cmbB.sizePolicy().hasHeightForWidth())
+        self.cmbB.setSizePolicy(sizePolicy)
+        self.cmbB.setMinimumSize(QSize(0, 19))
+        self.cmbB.setMaximumSize(QSize(16777215, 19))
+        self.cmbB.setMaxVisibleItems(30)
+        self.cmbB.setSizeAdjustPolicy(QComboBox.AdjustToContentsOnFirstShow)
+        self.cmbB.setFrame(False)
+
+        self.gridLayout.addWidget(self.cmbB, 2, 1, 1, 1)
+
+        self.cmbR = ComboBox(self.Formatting)
+        self.cmbR.setObjectName(u"cmbR")
+        sizePolicy.setHeightForWidth(self.cmbR.sizePolicy().hasHeightForWidth())
+        self.cmbR.setSizePolicy(sizePolicy)
+        self.cmbR.setMinimumSize(QSize(0, 19))
+        self.cmbR.setMaximumSize(QSize(16777215, 19))
+        self.cmbR.setMaxVisibleItems(30)
+        self.cmbR.setSizeAdjustPolicy(QComboBox.AdjustToContentsOnFirstShow)
+        self.cmbR.setFrame(False)
+
+        self.gridLayout.addWidget(self.cmbR, 0, 1, 1, 1)
+
+        self.cmbA = ComboBox(self.Formatting)
+        self.cmbA.setObjectName(u"cmbA")
+        sizePolicy.setHeightForWidth(self.cmbA.sizePolicy().hasHeightForWidth())
+        self.cmbA.setSizePolicy(sizePolicy)
+        self.cmbA.setMinimumSize(QSize(0, 19))
+        self.cmbA.setMaximumSize(QSize(16777215, 19))
+        self.cmbA.setMaxVisibleItems(30)
+        self.cmbA.setSizeAdjustPolicy(QComboBox.AdjustToContentsOnFirstShow)
+        self.cmbA.setFrame(False)
+
+        self.gridLayout.addWidget(self.cmbA, 3, 1, 1, 1)
+
+        self.cmbG = ComboBox(self.Formatting)
+        self.cmbG.setObjectName(u"cmbG")
+        sizePolicy.setHeightForWidth(self.cmbG.sizePolicy().hasHeightForWidth())
+        self.cmbG.setSizePolicy(sizePolicy)
+        self.cmbG.setMinimumSize(QSize(0, 19))
+        self.cmbG.setMaximumSize(QSize(16777215, 19))
+        self.cmbG.setMaxVisibleItems(30)
+        self.cmbG.setSizeAdjustPolicy(QComboBox.AdjustToContentsOnFirstShow)
+        self.cmbG.setFrame(False)
+
+        self.gridLayout.addWidget(self.cmbG, 1, 1, 1, 1)
+
+        self.lblR = QLabel(self.Formatting)
+        self.lblR.setObjectName(u"lblR")
+        self.lblR.setMaximumSize(QSize(18, 16777215))
+        self.lblR.setFont(font)
+
+        self.gridLayout.addWidget(self.lblR, 0, 0, 1, 1)
+
+        self.lblG = QLabel(self.Formatting)
+        self.lblG.setObjectName(u"lblG")
+        self.lblG.setMaximumSize(QSize(18, 16777215))
+        self.lblG.setFont(font)
+
+        self.gridLayout.addWidget(self.lblG, 1, 0, 1, 1)
+
+        self.lblB = QLabel(self.Formatting)
+        self.lblB.setObjectName(u"lblB")
+        self.lblB.setMaximumSize(QSize(18, 16777215))
+        self.lblB.setFont(font)
+
+        self.gridLayout.addWidget(self.lblB, 2, 0, 1, 1)
+
+        self.lblA = QLabel(self.Formatting)
+        self.lblA.setObjectName(u"lblA")
+        self.lblA.setMaximumSize(QSize(18, 16777215))
+        self.lblA.setFont(font)
+
+        self.gridLayout.addWidget(self.lblA, 3, 0, 1, 1)
+
+
+        self.main_layout.addWidget(self.Formatting)
+
+        self.groupBox = QGroupBox(self.central_widget)
+        self.groupBox.setObjectName(u"groupBox")
+        self.verticalLayout_2 = QVBoxLayout(self.groupBox)
+        self.verticalLayout_2.setSpacing(1)
+        self.verticalLayout_2.setObjectName(u"verticalLayout_2")
+        self.verticalLayout_2.setContentsMargins(0, 0, 0, 0)
+        self.cmbFormat = ComboBox(self.groupBox)
+        self.cmbFormat.setObjectName(u"cmbFormat")
+        sizePolicy.setHeightForWidth(self.cmbFormat.sizePolicy().hasHeightForWidth())
+        self.cmbFormat.setSizePolicy(sizePolicy)
+        self.cmbFormat.setMinimumSize(QSize(0, 19))
+        self.cmbFormat.setMaximumSize(QSize(16777215, 19))
+        self.cmbFormat.setMaxVisibleItems(30)
+        self.cmbFormat.setSizeAdjustPolicy(QComboBox.AdjustToContentsOnFirstShow)
+        self.cmbFormat.setFrame(False)
+
+        self.verticalLayout_2.addWidget(self.cmbFormat)
+
+        self.txtSuffix = LineEdit(self.groupBox)
+        self.txtSuffix.setObjectName(u"txtSuffix")
+        sizePolicy.setHeightForWidth(self.txtSuffix.sizePolicy().hasHeightForWidth())
+        self.txtSuffix.setSizePolicy(sizePolicy)
+        self.txtSuffix.setMinimumSize(QSize(0, 19))
+        self.txtSuffix.setMaximumSize(QSize(16777215, 19))
+        self.txtSuffix.setFrame(False)
+
+        self.verticalLayout_2.addWidget(self.txtSuffix)
+
+
+        self.main_layout.addWidget(self.groupBox)
+
+        self.verticalLayout_3 = QVBoxLayout()
+        self.verticalLayout_3.setSpacing(0)
+        self.verticalLayout_3.setObjectName(u"verticalLayout_3")
+        self.b001 = QPushButton(self.central_widget)
+        self.b001.setObjectName(u"b001")
+        self.b001.setEnabled(False)
+        sizePolicy.setHeightForWidth(self.b001.sizePolicy().hasHeightForWidth())
+        self.b001.setSizePolicy(sizePolicy)
+        self.b001.setMinimumSize(QSize(0, 19))
+        self.b001.setMaximumSize(QSize(16777215, 19))
+
+        self.verticalLayout_3.addWidget(self.b001)
+
+        self.b000 = QPushButton(self.central_widget)
+        self.b000.setObjectName(u"b000")
+        self.b000.setEnabled(True)
+        self.b000.setMinimumSize(QSize(0, 30))
+        self.b000.setMaximumSize(QSize(16777215, 19))
+
+        self.verticalLayout_3.addWidget(self.b000)
+
+
+        self.main_layout.addLayout(self.verticalLayout_3)
+
+        self.verticalSpacer = QSpacerItem(0, 10, QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Expanding)
+
+        self.main_layout.addItem(self.verticalSpacer)
+
+        self.footer = Footer(self.central_widget)
+        self.footer.setObjectName(u"footer")
+        self.footer.setMinimumSize(QSize(0, 19))
+        self.footer.setMaximumSize(QSize(16777215, 19))
+
+        self.main_layout.addWidget(self.footer)
+
+
+        self.verticalLayout.addLayout(self.main_layout)
+
+        QtUi.setCentralWidget(self.central_widget)
+
+        self.retranslateUi(QtUi)
+
+        QMetaObject.connectSlotsByName(QtUi)
+    # setupUi
+
+    def retranslateUi(self, QtUi):
+        self.header.setText(QCoreApplication.translate("QtUi", u"MAP PACKER", None))
+        self.Formatting.setTitle(QCoreApplication.translate("QtUi", u"Channels", None))
+#if QT_CONFIG(tooltip)
+        self.cmbB.setToolTip(QCoreApplication.translate("QtUi", u"<html><head/><body><p>Specify the map to pack to the <span style=\" font-weight:600;\">Blue Channel</span>.</p></body></html>", None))
+#endif // QT_CONFIG(tooltip)
+#if QT_CONFIG(tooltip)
+        self.cmbR.setToolTip(QCoreApplication.translate("QtUi", u"<html><head/><body><p>Specify the map to pack to the <span style=\" font-weight:600;\">Red Channel</span>.</p></body></html>", None))
+#endif // QT_CONFIG(tooltip)
+#if QT_CONFIG(tooltip)
+        self.cmbA.setToolTip(QCoreApplication.translate("QtUi", u"<html><head/><body><p>Specify the map to pack to the <span style=\" font-weight:600;\">Alpha Channel</span>.</p></body></html>", None))
+#endif // QT_CONFIG(tooltip)
+#if QT_CONFIG(tooltip)
+        self.cmbG.setToolTip(QCoreApplication.translate("QtUi", u"<html><head/><body><p>Specify the map to pack to the <span style=\" font-weight:600;\">Green Channel</span>.</p></body></html>", None))
+#endif // QT_CONFIG(tooltip)
+        self.lblR.setText(QCoreApplication.translate("QtUi", u"R", None))
+        self.lblG.setText(QCoreApplication.translate("QtUi", u"G", None))
+        self.lblB.setText(QCoreApplication.translate("QtUi", u"B", None))
+        self.lblA.setText(QCoreApplication.translate("QtUi", u"A", None))
+        self.groupBox.setTitle(QCoreApplication.translate("QtUi", u"Format", None))
+#if QT_CONFIG(tooltip)
+        self.cmbFormat.setToolTip(QCoreApplication.translate("QtUi", u"<html><head/><body><p>Specify the map <span style=\" font-weight:600;\">output file format</span>.</p></body></html>", None))
+#endif // QT_CONFIG(tooltip)
+#if QT_CONFIG(tooltip)
+        self.txtSuffix.setToolTip(QCoreApplication.translate("QtUi", u"<html><head/><body><p>Specify a suffix for the packed texture's file name.</p></body></html>", None))
+#endif // QT_CONFIG(tooltip)
+        self.txtSuffix.setPlaceholderText(QCoreApplication.translate("QtUi", u"Suffix:", None))
+#if QT_CONFIG(tooltip)
+        self.b001.setToolTip(QCoreApplication.translate("QtUi", u"Choose the maps to pack and perform the operation.", None))
+#endif // QT_CONFIG(tooltip)
+        self.b001.setText(QCoreApplication.translate("QtUi", u"Open Output Dir", None))
+#if QT_CONFIG(tooltip)
+        self.b000.setToolTip(QCoreApplication.translate("QtUi", u"Choose the maps to pack and perform the operation.", None))
+#endif // QT_CONFIG(tooltip)
+        self.b000.setText(QCoreApplication.translate("QtUi", u"Pack", None))
+        pass
+    # retranslateUi
+

extapps/map_packer/slots.py

@@ -0,0 +1,250 @@
+# !/usr/bin/python
+# coding=utf-8
+from typing import List, Dict, Optional, Any
+from pythontk.img_utils._img_utils import ImgUtils
+from pythontk.img_utils.map_factory import MapFactory
+from pythontk.file_utils._file_utils import FileUtils
+
+
+class MapPackerSlots(ImgUtils):
+    channels = ["R", "G", "B", "A"]
+    grayscale_types = [
+        "None",
+        "Metallic",
+        "Roughness",
+        "Ambient_Occlusion",
+        "Smoothness",
+        "Opacity",
+        "Height",
+        "Thickness",
+        "Glossiness",
+        "Displacement",
+    ]
+    output_formats = ["PNG", "TGA", "JPG", "BMP", "TIFF", "EXR"]
+
+    PRESET_DIR = "~/.pythontk/presets/map_packer"
+
+    # Built-in presets defined using human-readable names.
+    # Resolved to combo indices at seed time via grayscale_types/output_formats.
+    BUILTIN_PRESETS = {
+        "ORM (Unreal, glTF)": {
+            "R": "Ambient_Occlusion",
+            "G": "Roughness",
+            "B": "Metallic",
+            "A": "None",
+            "format": "PNG",
+            "suffix": "_ORM",
+        },
+        "MSAO (HDRP Mask Map)": {
+            "R": "Metallic",
+            "G": "Ambient_Occlusion",
+            "B": "None",
+            "A": "Smoothness",
+            "format": "PNG",
+            "suffix": "_MSAO",
+        },
+        "Metallic Smoothness (URP)": {
+            "R": "Metallic",
+            "G": "None",
+            "B": "None",
+            "A": "Smoothness",
+            "format": "PNG",
+            "suffix": "_MetallicSmoothness",
+        },
+    }
+
+    def __init__(self, switchboard, **kwargs):
+        super().__init__()
+
+        self.sb = switchboard
+        self.ui = self.sb.loaded_ui.map_packer
+
+        self._source_dir = kwargs.get("source_dir", "")
+
+        self._init_ui_comboboxes()
+        self._set_channel_label_colors()
+        self.ui.b001.setEnabled(False)  # Disable the open output dir button
+
+    def _set_channel_label_colors(self):
+        """Set background color for each channel label."""
+        channel_colors = {
+            "R": "#ef9a9a",  # Pastel Red
+            "G": "#a5d6a7",  # Pastel Green
+            "B": "#90caf9",  # Pastel Blue
+            "A": "#bdbdbd",  # Pastel Gray
+        }
+        for c in self.channels:
+            lbl = getattr(self.ui, f"lbl{c}", None)
+            if lbl:
+                lbl.setStyleSheet(
+                    f"background-color: {channel_colors[c]}; color: white; border-radius: 3px;"
+                )
+
+    def _init_ui_comboboxes(self):
+        """Initialize channel and format comboboxes and connect format change signal."""
+        for c in self.channels:
+            cmb = getattr(self.ui, f"cmb{c}")
+            cmb.clear()
+            cmb.addItems(self.grayscale_types)
+            cmb.restore_state = True  # <-- Enable state restore
+
+        self.ui.cmbFormat.clear()
+        self.ui.cmbFormat.addItems(self.output_formats)
+        self.ui.cmbFormat.restore_state = True  # <-- Enable state restore
+        self.ui.cmbFormat.currentTextChanged.connect(self._on_format_changed)
+        self._on_format_changed(self.ui.cmbFormat.currentText())
+
+    def _on_format_changed(self, fmt: str):
+        """Disable alpha combobox for formats without alpha support."""
+        supports_alpha = fmt.upper() in {"PNG", "TGA", "TIFF", "EXR", "BMP"}
+        self.ui.cmbA.setEnabled(supports_alpha)
+        if not supports_alpha:
+            self.ui.cmbA.setCurrentIndex(self.ui.cmbA.findText("None"))
+
+    def header_init(self, widget):
+        """Configure the header menu with presets for common packed map types."""
+        presets = widget.menu.presets
+        presets.preset_dir = self.PRESET_DIR
+        # Seed built-in presets BEFORE setup so the combo is populated on first launch.
+        self._seed_builtin_presets(presets)
+        presets.setup(
+            preset_dir=self.PRESET_DIR,
+            widgets=[
+                self.ui.cmbR,
+                self.ui.cmbG,
+                self.ui.cmbB,
+                self.ui.cmbA,
+                self.ui.cmbFormat,
+                self.ui.txtSuffix,
+            ],
+        )
+
+    def _seed_builtin_presets(self, preset_mgr):
+        """Write built-in preset JSON files if they don't already exist.
+
+        Converts human-readable BUILTIN_PRESETS (map-type/format names)
+        into the index-based JSON format that PresetManager expects.
+        """
+        import json
+
+        preset_dir = preset_mgr.preset_dir
+        for name, preset in self.BUILTIN_PRESETS.items():
+            filepath = preset_mgr._preset_path(name)
+            if not filepath.exists():
+                data = {
+                    "_meta": {"version": 1},
+                    "cmbR": self.grayscale_types.index(preset["R"]),
+                    "cmbG": self.grayscale_types.index(preset["G"]),
+                    "cmbB": self.grayscale_types.index(preset["B"]),
+                    "cmbA": self.grayscale_types.index(preset["A"]),
+                    "cmbFormat": self.output_formats.index(preset["format"]),
+                    "txtSuffix": preset["suffix"],
+                }
+                with open(filepath, "w", encoding="utf-8") as f:
+                    json.dump(data, f, indent=4)
+
+    @property
+    def source_dir(self):
+        return self._source_dir
+
+    @source_dir.setter
+    def source_dir(self, value):
+        self._source_dir = value
+
+    def b000(self):
+        """Batch pack up to 4 channels into RGBA maps across texture sets."""
+        file_paths = self.sb.file_dialog(
+            file_types=[f"*.{ext}" for ext in self.texture_file_types],
+            title="Select textures for batch packing (multiple sets allowed):",
+            start_dir=self.source_dir,
+            allow_multiple=True,
+        )
+        if not file_paths:
+            print("No files selected.")
+            self.ui.b001.setEnabled(False)
+            return
+
+        texture_sets = MapFactory.group_textures_by_set(file_paths)
+        combos = [
+            self.ui.cmbR.currentText(),
+            self.ui.cmbG.currentText(),
+            self.ui.cmbB.currentText(),
+            self.ui.cmbA.currentText(),
+        ]
+        suffix = self.ui.txtSuffix.text().strip() or "_Packed"
+        if not suffix.startswith("_"):
+            suffix = f"_{suffix}"
+        ext = self.ui.cmbFormat.currentText().lower()
+        fmt = self.ui.cmbFormat.currentText().upper()
+
+        success = False
+        for base_name, files in texture_sets.items():
+            sorted_maps = MapFactory.sort_images_by_type(files)
+            assigned = {c: None for c in self.channels}
+            available_map_types = {MapFactory.resolve_map_type(f): f for f in files}
+            used_files = set()
+
+            for idx, channel in enumerate(self.channels):
+                map_type = combos[idx]
+                if map_type == "None":
+                    continue
+                file = next(
+                    (
+                        f
+                        for f in files
+                        if MapFactory.resolve_map_type(f) == map_type
+                        and f not in used_files
+                    ),
+                    None,
+                )
+                if file:
+                    assigned[channel] = file
+                    used_files.add(file)
+                    continue
+                # Try conversion if not found
+                converted = self.get_converted_map(map_type, available_map_types)
+                if converted is not None:
+                    assigned[channel] = converted
+                    continue
+                print(
+                    f"// Required map '{map_type}' for channel {channel} in '{base_name}' not found and cannot be converted. Skipping."
+                )
+                break  # skip this set if not all required maps are present
+
+            if any(assigned[c] for c in self.channels):
+                out_mode = "RGBA" if assigned["A"] else "RGB"
+                output_dir = FileUtils.format_path(files[0], "path")
+                output_path = f"{output_dir}/{base_name}{suffix}.{ext}"
+                self.pack_channels(
+                    channel_files=assigned,
+                    output_path=output_path,
+                    out_mode=out_mode,
+                    output_format=fmt,
+                )
+                print(f"// Packed map saved: {output_path}")
+                success = True
+
+        if success:
+            self._last_output_dir = FileUtils.format_path(file_paths[0], "path")
+            self.source_dir = self._last_output_dir
+            self.ui.b001.setEnabled(True)
+        else:
+            self.ui.b001.setEnabled(False)
+
+    def b001(self):
+        """Open the last output directory in the system file explorer."""
+        import os
+        import sys
+
+        output_dir = getattr(self, "_last_output_dir", None)
+        if not output_dir or not os.path.isdir(output_dir):
+            print("// No output directory available.")
+            return
+        if sys.platform.startswith("darwin"):
+            os.system(f'open "{output_dir}"')
+        elif sys.platform.startswith("win"):
+            os.startfile(output_dir)
+        elif sys.platform.startswith("linux"):
+            os.system(f'xdg-open "{output_dir}"')
+        else:
+            print("// Unsupported OS for opening directories.")

extapps/mesh_convert/__init__.py

@@ -0,0 +1,22 @@
+# !/usr/bin/python
+# coding=utf-8
+"""Mesh Convert — FBX → glTF / GLB conversion.
+
+Engine logic lives in :mod:`pythontk.file_utils.mesh_convert`; this
+package holds only the Switchboard panel and launcher.
+"""
+from pythontk.core_utils.module_resolver import bootstrap_package
+
+__package__ = "extapps.mesh_convert"
+
+
+DEFAULT_INCLUDE = {
+    "launcher": ["MeshConvertUI"],
+    "slots": ["MeshConvertSlots"],
+}
+
+
+bootstrap_package(globals(), include=DEFAULT_INCLUDE)
+
+
+__all__ = ["MeshConvertUI", "MeshConvertSlots"]

extapps/mesh_convert/launcher.py

@@ -0,0 +1,29 @@
+# !/usr/bin/python
+# coding=utf-8
+"""Application shell for the Mesh Convert UI.
+
+Engine logic lives in :mod:`pythontk.file_utils.mesh_convert` and slot
+bindings in :mod:`extapps.mesh_convert.slots`; this module only assembles
+the Switchboard-driven UI and provides the script entry point.
+"""
+
+
+class MeshConvertUI:
+    def __new__(cls):
+        from uitk import Switchboard
+        from extapps.mesh_convert.slots import MeshConvertSlots
+
+        sb = Switchboard(ui_source="mesh_convert.ui", slot_source=MeshConvertSlots)
+        ui = sb.loaded_ui.mesh_convert
+
+        ui.set_attributes(WA_TranslucentBackground=True)
+        ui.set_flags(FramelessWindowHint=True)
+        ui.style.set(theme="dark", style_class="translucentBgWithBorder")
+        ui.header.config_buttons("menu", "minimize", "hide")
+        return ui
+
+
+# -----------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    MeshConvertUI().show(pos="screen", app_exec=True)