fmu-manipulation-toolbox 1.8__py3-none-any.whl → 1.8.2__py3-none-any.whl

fmu_manipulation_toolbox/gui.py

@@ -1,17 +1,22 @@
 import os.path
 import sys
-from .version import __version__ as version
-from PyQt5.QtCore import Qt, QObject, QUrl, pyqtSignal, QDir
-from PyQt5.QtWidgets import (QApplication, QWidget, QGridLayout, QLabel, QLineEdit, QPushButton, QFileDialog,
-                             QTextBrowser, QInputDialog, QMenu, QAction)
-from PyQt5.QtGui import QPixmap, QImage, QFont, QTextCursor, QIcon, QColor, QPainter, QBrush, QDesktopServices
 import textwrap
+
+from PySide6.QtCore import Qt, QObject, QUrl, QDir, Signal, QPoint, QModelIndex
+from PySide6.QtWidgets import (QApplication, QWidget, QGridLayout, QLabel, QLineEdit, QPushButton, QFileDialog,
+                               QTextBrowser, QInputDialog, QMenu, QTreeView, QAbstractItemView, QTabWidget, QTableView,
+                               QCheckBox)
+from PySide6.QtGui import (QPixmap, QTextCursor, QStandardItem, QIcon, QDesktopServices, QAction,
+                           QPainter, QColor, QImage, QStandardItemModel)
 from functools import partial
 from typing import Optional
 
+from .gui_style import *
 from .fmu_operations import *
+from .assembly import Assembly, AssemblyNode
 from .checker import checker_list
 from .help import Help
+from .version import __version__ as version
 
 
 class DropZoneWidget(QLabel):
@@ -19,30 +24,30 @@ class DropZoneWidget(QLabel):
     HEIGHT = 150
     fmu = None
     last_directory = None
-    clicked = pyqtSignal()
+    clicked = Signal()
 
-    def __init__(self):
-        super().__init__()
+    def __init__(self, parent=None):
+        super().__init__(parent)
         self.setAcceptDrops(True)
         self.set_image(None)
         self.setProperty("class", "dropped_fmu")
         self.setFixedSize(self.WIDTH, self.HEIGHT)
 
     def dragEnterEvent(self, event):
-        if event.mimeData().hasImage:
+        if event.mimeData().hasUrls():
             event.accept()
         else:
             event.ignore()
 
     def dragMoveEvent(self, event):
-        if event.mimeData().hasImage:
+        if event.mimeData().hasUrls():
             event.accept()
         else:
             event.ignore()
 
     def dropEvent(self, event):
-        if event.mimeData().hasImage:
-            event.setDropAction(Qt.CopyAction)
+        if event.mimeData().hasUrls():
+            event.setDropAction(Qt.DropAction.CopyAction)
             try:
                 file_path = event.mimeData().urls()[0].toLocalFile()
             except IndexError:
@@ -59,8 +64,8 @@ class DropZoneWidget(QLabel):
         else:
             default_directory = os.path.expanduser('~')
 
-        fmu_filename, _ = QFileDialog.getOpenFileName(self, 'Select FMU to Manipulate',
-                                                      default_directory, "FMU files (*.fmu)")
+        fmu_filename, _ = QFileDialog.getOpenFileName(parent=self, caption='Select FMU to Manipulate',
+                                                      dir=default_directory, filter="FMU files (*.fmu)")
         if fmu_filename:
             self.set_fmu(fmu_filename)
 
@@ -70,25 +75,24 @@ class DropZoneWidget(QLabel):
         elif not os.path.isfile(filename):
             filename = os.path.join(os.path.dirname(__file__), "resources", "fmu.png")
 
-        image = QImage(filename).scaled(self.WIDTH-4, self.HEIGHT-4, Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
-        pixmap = QPixmap.fromImage(image)
-        rounded = self.make_pixmap_rounded(pixmap)
-        self.setPixmap(rounded)
-
-    def make_pixmap_rounded(self, pixmap):
-        rounded = QPixmap(pixmap.size())
-        rounded.fill(QColor("transparent"))
-
-        painter = QPainter(rounded)
-        painter.setRenderHint(QPainter.Antialiasing)
-        painter.setBrush(QBrush(pixmap))
-        painter.setPen(Qt.NoPen)
-        painter.drawRoundedRect(pixmap.rect(), 20, 20)
-        del painter    # Mandatory to avoid a crash
-        self.update()  # Mandatory to avoid a crash
-        return rounded
-
-    def set_fmu(self, filename):
+        base_image = QImage(filename).scaled(self.WIDTH, self.HEIGHT, Qt.AspectRatioMode.IgnoreAspectRatio,
+                                             Qt.TransformationMode.SmoothTransformation)
+        mask_filename = os.path.join(os.path.dirname(__file__), "resources", "mask.png")
+        mask_image = QImage(mask_filename).scaled(self.WIDTH, self.HEIGHT, Qt.AspectRatioMode.IgnoreAspectRatio,
+                                                  Qt.TransformationMode.SmoothTransformation)
+        rounded_image = QImage(self.WIDTH, self.HEIGHT, QImage.Format.Format_ARGB32)
+        rounded_image.fill(QColor(0, 0, 0, 0))
+        painter = QPainter()
+        painter.begin(rounded_image)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        painter.drawImage(QPoint(0, 0), base_image)
+        painter.drawImage(QPoint(0, 0), mask_image)
+        painter.end()
+        pixmap = QPixmap.fromImage(rounded_image)
+
+        self.setPixmap(pixmap)
+
+    def set_fmu(self, filename: str):
         try:
             self.last_directory = os.path.dirname(filename)
             self.fmu = FMU(filename)
@@ -104,7 +108,10 @@ class LogWidget(QTextBrowser):
     class XStream(QObject):
         _stdout = None
         _stderr = None
-        messageWritten = pyqtSignal(str)
+        messageWritten = Signal(str)
+
+        def __init__(self):
+            super().__init__()
 
         def flush(self):
             pass
@@ -133,21 +140,14 @@ class LogWidget(QTextBrowser):
 
     def __init__(self):
         super().__init__()
-        if os.name == 'nt':
-            font = QFont('Consolas')
-            font.setPointSize(10)
-        else:
-            font = QFont('Courier New')
-            font.setPointSize(12)
-        self.setFont(font)
-        self.setMinimumWidth(800)
-        self.setMinimumHeight(480)
-
-        self.insertHtml('<center><img src="fmu_manipulation_toolbox.png"/></center><br>')
+        self.setMinimumWidth(900)
+        self.setMinimumHeight(500)
+        self.setSearchPaths([os.path.join(os.path.dirname(__file__), "resources")])
+        self.insertHtml('<center><img src="fmu_manipulation_toolbox.png"/></center><br/>')
         LogWidget.XStream.stdout().messageWritten.connect(self.insertPlainText)
         LogWidget.XStream.stderr().messageWritten.connect(self.insertPlainText)
 
-    def loadResource(self, type, name):
+    def loadResource(self, _, name):
         image_path = os.path.join(os.path.dirname(__file__), "resources", name.toString())
         return QPixmap(image_path)
 
@@ -162,7 +162,7 @@ class HelpWidget(QLabel):
         filename = os.path.join(os.path.dirname(__file__), "resources", "help.png")
         image = QPixmap(filename)
         self.setPixmap(image)
-        self.setAlignment(Qt.AlignRight)
+        self.setAlignment(Qt.AlignmentFlag.AlignRight)
 
     def mousePressEvent(self, event):
         QDesktopServices.openUrl(QUrl(self.HELP_URL))
@@ -175,14 +175,14 @@ class FilterWidget(QPushButton):
         self.nb_items = len(items)
         self.update_filter_text()
         if items:
-            menu = QMenu()
+            self.menu = QMenu()
             for item in items:
                 action = QAction(item, self)
                 action.setCheckable(True)
                 action.setChecked(True)
                 action.triggered.connect(partial(self.toggle_item, action))
-                menu.addAction(action)
-            self.setMenu(menu)
+                self.menu.addAction(action)
+            self.setMenu(self.menu)
 
     def toggle_item(self, action: QAction):
         if not action.isChecked() and len(self.items_selected) == 1:
@@ -208,27 +208,201 @@ class FilterWidget(QPushButton):
             return sorted(self.items_selected)
 
 
-class FMUManipulationToolboxlMainWindow(QWidget):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
+class AssemblyTreeWidget(QTreeView):
+    class AssemblyTreeModel(QStandardItemModel):
+
+        def __init__(self, assembly: Assembly, parent=None):
+            super().__init__(parent)
+
+            self.lastDroppedItems = []
+            self.pendingRemoveRowsAfterDrop = False
+            self.setHorizontalHeaderLabels(['col1'])
+            self.dnd_target_node: Optional[AssemblyNode] = None
+
+            self.icon_container = QIcon(os.path.join(os.path.dirname(__file__), 'resources', 'container.png'))
+            self.icon_fmu = QIcon(os.path.join(os.path.dirname(__file__), 'resources', 'icon_fmu.png'))
+
+            if assembly:
+                self.add_node(assembly.root, self)
+
+        def add_node(self, node: AssemblyNode, parent_item):
+            # Add Container
+            item = QStandardItem(self.icon_container, node.name)
+            parent_item.appendRow(item)
+            item.setFlags(Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable | Qt.ItemFlag.ItemIsDragEnabled |
+                          Qt.ItemFlag.ItemIsDropEnabled)
+            item.setData(node, role=Qt.ItemDataRole.UserRole + 1)
+            item.setData("container", role=Qt.ItemDataRole.UserRole + 2)
+
+            # Add FMU's
+            children_name = node.children.keys()
+            for fmu_name in node.fmu_names_list:
+                if fmu_name not in children_name:
+                    fmu_node = QStandardItem(self.icon_fmu, fmu_name)
+                    fmu_node.setData(node, role=Qt.ItemDataRole.UserRole + 1)
+                    fmu_node.setData("fmu", role=Qt.ItemDataRole.UserRole + 2)
+                    fmu_node.setFlags(Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable |
+                                      Qt.ItemFlag.ItemIsDragEnabled)
+                    item.appendRow(fmu_node)
+
+            # Add Sub-Containers
+            for child in node.children.values():
+                self.add_node(child, item)
+
+        def insertRows(self, row, count, parent=QModelIndex()):
+            self.dnd_target_node = parent.data(role=Qt.ItemDataRole.UserRole + 1)
+            return super().insertRows(row, count, parent=parent)
+
+        def removeRows(self, row, count, parent=QModelIndex()):
+            if not self.dnd_target_node:
+                print("NO DROP NODE!?")
+
+            source_index = self.itemFromIndex(parent).child(row, 0).data(role=Qt.ItemDataRole.UserRole+1)
+            print(f"{source_index} ==> {self.dnd_target_node.name}")
+
+            self.dnd_target_node = None
+            return super().removeRows(row, count, parent)
+
+        def dropMimeData(self, data, action, row, column, parent: QModelIndex):
+            if parent.column() < 0:  # Avoid to drop item as a sibling of the root.
+                return False
+            return super().dropMimeData(data, action, row, column, parent)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        self.model = self.AssemblyTreeModel(None)
+        self.setModel(self.model)
+
+        self.expandAll()
+        self.setDropIndicatorShown(True)
+        self.setDragDropOverwriteMode(False)
+        self.setAcceptDrops(True)
+        self.setDragDropMode(QAbstractItemView.DragDropMode.InternalMove)
+        self.setRootIsDecorated(True)
+        self.setHeaderHidden(True)
+
+    def load_container(self, filename):
+        assembly = Assembly(filename)
+        self.model = self.AssemblyTreeModel(assembly)
+        self.setModel(self.model)
+
+    def setTopIndex(self):
+        topIndex = self.model.index(0, 0, self.rootIndex())
+        print(topIndex.isValid(), topIndex.model())
+        if topIndex.isValid():
+            self.setCurrentIndex(topIndex)
+            if self.layoutCheck:
+                self.model.layoutChanged.disconnect(self.setTopIndex)
+        else:
+            if not self.layoutCheck:
+                self.model.layoutChanged.connect(self.setTopIndex)
+                self.layoutCheck = True
+
+
+    def dragEnterEvent2(self, event):
+        if event.mimeData().hasImage:
+            event.accept()
+        else:
+            event.ignore()
+
+    def dragMoveEvent2(self, event):
+        if event.mimeData().hasImage:
+            event.accept()
+        else:
+            event.ignore()
+
+    def dropEvent2(self, event):
+        if event.mimeData().hasImage:
+            event.setDropAction(Qt.DropAction.CopyAction)
+            try:
+                file_path = event.mimeData().urls()[0].toLocalFile()
+            except IndexError:
+                print("Please select a regular file.")
+                return
+            print(f"DROP: {file_path}")
+            event.accept()
+        else:
+            event.ignore()
 
-        self.setWindowTitle('FMU Manipulation Toolbox')
 
-        # set the grid layout
+class AssemblPropertiesWidget(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
         self.layout = QGridLayout()
+        self.layout.setVerticalSpacing(4)
+        self.layout.setHorizontalSpacing(4)
+        self.layout.setContentsMargins(10, 10, 10, 10)
         self.setLayout(self.layout)
 
+        mt_check = QCheckBox("Multi-Threaded", self)
+        self.layout.addWidget(mt_check, 1, 0)
+
+        profiling_check = QCheckBox("Profiling", self)
+        self.layout.addWidget(profiling_check, 1, 1)
+
+        auto_inputs_check = QCheckBox("Auto Inputs", self)
+        self.layout.addWidget(auto_inputs_check, 0, 0)
+
+        auto_outputs_check = QCheckBox("Auto Outputs", self)
+        self.layout.addWidget(auto_outputs_check, 0, 1)
+
+        auto_links_check = QCheckBox("Auto Links", self)
+        self.layout.addWidget(auto_links_check, 0, 2)
+
+
+class AssemblyTabWidget(QTabWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        table = AssemblPropertiesWidget(parent=self)
+        self.addTab(table, "Properties")
+        table = QTableView()
+        self.addTab(table, "Links")
+        table = QTableView()
+        self.addTab(table, "Inputs")
+        table = QTableView()
+        self.addTab(table, "Outputs")
+        table = QTableView()
+        self.addTab(table, "Start values")
+
+        self.tabBar().setDocumentMode(True)
+        self.tabBar().setExpanding(True)
+
+
+class WindowWithLayout(QWidget):
+    def __init__(self, title: str):
+        super().__init__(None)  # Do not set parent to have a separated window
+        self.setWindowTitle(title)
+
+        self.layout = QGridLayout()
+        self.layout.setVerticalSpacing(4)
+        self.layout.setHorizontalSpacing(4)
+        self.layout.setContentsMargins(10, 10, 10, 10)
+        self.setLayout(self.layout)
+
+
+class MainWindow(WindowWithLayout):
+    def __init__(self):
+        super().__init__('FMU Manipulation Toolbox')
+
         self.dropped_fmu = DropZoneWidget()
         self.dropped_fmu.clicked.connect(self.update_fmu)
+
         self.layout.addWidget(self.dropped_fmu, 0, 0, 4, 1)
 
-        font = QFont('Verdana')
-        font.setPointSize(14)
-        font.setBold(True)
         self.fmu_title = QLabel()
-        self.fmu_title.setFont(font)
+        self.fmu_title.setProperty("class", "title")
         self.layout.addWidget(self.fmu_title, 0, 1, 1, 4)
 
+        self.container_window = None
+        #TODO: Container Window
+        #container_button = QPushButton("Make a container")
+        #container_button.setProperty("class", "quit")
+        #container_button.clicked.connect(self.launch_container)
+        #self.layout.addWidget(container_button, 4, 1, 1, 1)
+
         help_widget = HelpWidget()
         self.layout.addWidget(help_widget, 0, 5, 1, 1)
 
@@ -264,8 +438,8 @@ class FMUManipulationToolboxlMainWindow(QWidget):
                 self.add_operation(operation[0], operation[1], operation[2], operation[3], line, col, **operation[4])
 
         line += 1
-        self.apply_filter_label = QLabel("Apply modification only on: ")
-        self.layout.addWidget(self.apply_filter_label, line, 1, 1, 2, alignment=Qt.AlignRight)
+        self.apply_filter_label = QLabel("Apply only on: ")
+        self.layout.addWidget(self.apply_filter_label, line, 2, 1, 1, alignment=Qt.AlignmentFlag.AlignRight)
         self.set_tooltip(self.apply_filter_label, 'gui-apply-only')
 
         causality = ["parameter", "calculatedParameter", "input", "output", "local", "independent"]
@@ -305,6 +479,19 @@ class FMUManipulationToolboxlMainWindow(QWidget):
         # show the window
         self.show()
 
+    def closeEvent(self, event):
+        if self.container_window:
+            self.container_window.close()
+            self.container_window = None
+        event.accept()
+
+    def launch_container(self):
+        if not self.container_window:
+            self.container_window = ContainerWindow(self)
+
+    def closing_container(self):
+        self.container_window = None
+
     def set_tooltip(self, widget, usage):
         widget.setToolTip("\n".join(textwrap.wrap(self.help.usage(usage))))
 
@@ -382,7 +569,7 @@ class FMUManipulationToolboxlMainWindow(QWidget):
         self.layout.addWidget(button, x, y)
 
     def prompt_string(self, message):
-        text, ok = QInputDialog().getText(self, "Enter value", f"{message}:", QLineEdit.Normal, "")
+        text, ok = QInputDialog().getText(self, "Enter value", f"{message}:", QLineEdit.EchoMode.Normal, "")
 
         if ok and text:
             return text
@@ -414,7 +601,7 @@ class FMUManipulationToolboxlMainWindow(QWidget):
 
     def apply_operation(self, operation):
         if self.dropped_fmu.fmu:
-            self.log_widget.moveCursor(QTextCursor.End)
+            self.log_widget.moveCursor(QTextCursor.MoveOperation.End)
             fmu_filename = os.path.basename(self.dropped_fmu.fmu.fmu_filename)
             print('-' * 100)
             self.log_widget.insertHtml(f"<strong>{fmu_filename}: {operation}</strong><br>")
@@ -433,66 +620,128 @@ class FMUManipulationToolboxlMainWindow(QWidget):
             scroll_bar.setValue(scroll_bar.maximum())
 
 
+class ContainerWindow(WindowWithLayout):
+    def __init__(self, parent: MainWindow):
+        super().__init__('FMU Manipulation Toolbox - Container')
+        self.main_window = parent
+        self.last_directory = None
+
+        # ROW 0
+        load_button = QPushButton("Load Description")
+        load_button.clicked.connect(self.load_container)
+        load_button.setProperty("class", "quit")
+        self.layout.addWidget(load_button, 0, 0)
+
+        self.container_label = QLabel()
+        self.container_label.setProperty("class", "title")
+        self.container_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.layout.addWidget(self.container_label, 0, 1, 1, 2)
+
+        # ROW 1
+        add_fmu_button = QPushButton("Add FMU")
+        add_fmu_button.setProperty("class", "modify")
+        add_fmu_button.setDisabled(True)
+        self.layout.addWidget(add_fmu_button, 1, 1)
+
+        add_sub_button = QPushButton("Add SubContainer")
+        add_sub_button.setProperty("class", "modify")
+        add_sub_button.setDisabled(True)
+        self.layout.addWidget(add_sub_button, 1, 2)
+
+        self.assembly_tree = AssemblyTreeWidget(parent=self)
+        self.assembly_tree.setMinimumHeight(600)
+        self.assembly_tree.setMinimumWidth(200)
+        self.layout.addWidget(self.assembly_tree, 1, 0, 3, 1)
+
+        # ROW 2
+        del_fmu_button = QPushButton("Remove FMU")
+        del_fmu_button.setProperty("class", "removal")
+        del_fmu_button.setDisabled(True)
+        self.layout.addWidget(del_fmu_button, 2, 1)
+
+        del_sub_button = QPushButton("Remove SubContainer")
+        del_sub_button.setProperty("class", "removal")
+        del_sub_button.setDisabled(True)
+        self.layout.addWidget(del_sub_button, 2, 2)
+
+        # ROW 3
+        self.assembly_tab = AssemblyTabWidget(parent=self)
+        self.assembly_tab.setMinimumWidth(600)
+        self.layout.addWidget(self.assembly_tab, 3, 1, 1, 2)
+
+        # ROW 4
+        close_button = QPushButton("Close")
+        close_button.setProperty("class", "quit")
+        close_button.clicked.connect(self.close)
+        self.layout.addWidget(close_button, 4, 0)
+
+        save_button = QPushButton("Save Container")
+        save_button.setProperty("class", "save")
+        self.layout.addWidget(save_button, 4, 2)
+
+        self.assembly_tree.selectionModel().currentChanged.connect(self.item_selected)
+        topIndex = self.assembly_tree.model.index(0, 0, self.assembly_tree.rootIndex())
+        self.assembly_tree.setCurrentIndex(topIndex)
+
+        self.show()
+
+    def closeEvent(self, event):
+        if self.main_window:
+            self.main_window.closing_container()
+        event.accept()
+
+    def item_selected(self, current: QModelIndex, previous: QModelIndex):
+        if current.isValid():
+            node = current.data(role=Qt.ItemDataRole.UserRole + 1)
+            node_type = current.data(role=Qt.ItemDataRole.UserRole + 2)
+            self.container_label.setText(f"{node.name} ({node_type})")
+        else:
+            self.container_label.setText("")
+
+    def load_container(self):
+        if self.last_directory:
+            default_directory = self.last_directory
+        else:
+            default_directory = os.path.expanduser('~')
+
+        filename, _ = QFileDialog.getOpenFileName(parent=self, caption='Select FMU to Manipulate',
+                                                  dir=default_directory,
+                                                  filter="JSON files (*.json);;SSP files (*.ssp)")
+        if filename:
+            try:
+                self.last_directory = os.path.dirname(filename)
+                self.assembly_tree.load_container(filename)
+            except Exception as e:
+                print(e)
+
+
 class Application(QApplication):
     """
 Analyse and modify your FMUs.
 
-Note: modifying the modelDescription.xml can damage your FMU ! Communicating with the FMU-developer and adapting the
-way the FMU is generated, is preferable when possible.
+Note: modifying the modelDescription.xml can damage your FMU !
+Communicating with the FMU-developer and adapting the way the FMU is generated, is preferable when possible.
 
     """
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
+        self.setHighDpiScaleFactorRoundingPolicy(Qt.HighDpiScaleFactorRoundingPolicy.RoundPreferFloor)
 
         QDir.addSearchPath('images', os.path.join(os.path.dirname(__file__), "resources"))
-        font = QFont("Verdana")
-        font.setPointSize(10)
-        self.setFont(font)
-        css_dark = """
-QWidget                  {background: #4b4e51; color: #b5bab9}
-QPushButton           { min-height: 30px; padding: 1px 1px 0.2em 0.2em; border: 1px solid #282830; border-radius: 5px;}
-QComboBox             { min-height: 30px; padding: 1px 1px 0.2em 0.2em; border: 1px solid #282830; border-radius: 5px;}
-QPushButton:pressed      { border: 2px solid #282830; }
-QPushButton.info         {background-color: #4e6749; color: #dddddd;}
-QPushButton.info:hover   {background-color: #5f7850; color: #dddddd;}
-QPushButton.info:hover   {background-color: #5f7850; color: #dddddd;}
-QPushButton.modify       {background-color: #98763f; color: #dddddd;}
-QPushButton.modify:hover {background-color: #a9874f; color: #dddddd;}
-QPushButton.removal      {background-color: #692e2e; color: #dddddd;}
-QPushButton.removal:hover{background-color: #7a3f3f; color: #dddddd;}
-QPushButton.save         {background-color: #564967; color: #dddddd;}
-QPushButton.save:hover   {background-color: #675a78; color: #dddddd;}
-QPushButton.quit         {background-color: #4571a4; color: #dddddd;}
-QPushButton.quit:hover   {background-color: #5682b5; color: #dddddd;}
-QToolTip                 {color: black}
-QLabel.dropped_fmu       {background-color: #b5bab9; border: 2px dashed #282830; border-radius: dashed 20px;}
-QLabel.dropped_fmu:hover {background-color: #c6cbca; border: 2px dashed #282830; border-radius: dashed 20px;}
-QTextBrowser             {background-color: #282830; color: #b5bab9;}
-QMenu                               {font-size: 18px;}
-QMenu::item                         {padding: 2px 250px 2px 20px; border: 1px solid transparent;}
-QMenu::item::indicator              {width: 32px; height: 32px; }
-QMenu::indicator:checked            {image: url(images:checkbox-checked.png);}
-QMenu::indicator:checked:hover      {image: url(images:checkbox-checked-hover.png);}
-QMenu::indicator:checked:disabled   {image: url(images:checkbox-checked-disabled.png);}
-QMenu::indicator:unchecked          {IconWidth: 50px; image: url(images:checkbox-unchecked.png); }
-QMenu::indicator:unchecked:hover    {width: 35px; image: url(images:checkbox-unchecked-hover.png); }
-QMenu::indicator:unchecked:disabled {width: 35px; image: url(images:checkbox-unchecked-disabled.png); }
-"""
-
-        self.setStyleSheet(css_dark)
-
+        self.setStyleSheet(gui_style_dark)
 
         if os.name == 'nt':
+            import ctypes
             self.setWindowIcon(QIcon(os.path.join(os.path.dirname(__file__), 'resources', 'icon-round.png')))
 
             # https://stackoverflow.com/questions/1551605/how-to-set-applications-taskbar-icon-in-windows-7/1552105#1552105
-            import ctypes
+
             application_id = 'FMU_Manipulation_Toolbox'  # arbitrary string
             ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(application_id)
         else:
             self.setWindowIcon(QIcon(os.path.join(os.path.dirname(__file__), 'resources', 'icon.png')))
 
-        self.window = FMUManipulationToolboxlMainWindow()
+        self.window = MainWindow()
 
 
 def main():
@@ -502,3 +751,7 @@ def main():
     print(application.__doc__)
 
     sys.exit(application.exec())
+
+
+if __name__ == "__main__":
+    main()