Concorde-IDE/gui_handler.py

from PySide6 import QtWidgets, QtCore, QtGui
import util

app = QtWidgets.QApplication([])

#TODO: Implement separate editor, terminal and main_window classes using Window as a parent

class Window(QtWidgets.QMainWindow):
    def __init__(self, size=(640, 480), title="Concorde"):
        super().__init__()
        self.setWindowTitle(title)
        self.resize(size[0], size[1])

    def __del__(self):
        #TODO: whatever needs to be done here
        pass

    def set_title(self, title):
        self.setWindowTitle(title)

    def get_size(self):
        #TODO: implement
        util.warn("Not implemented!")
        return None

    def set_size(self, size_x, size_y):
        self.resize(size_x, size_y)

    def update_menus(self, menu_dict, menu=None):
        # if not a sub menu
        if menu == None:
            menu = self.menuBar()
            menu.clear()

        #Looping through entire menu_dict
        for entry in menu_dict:
            # inactive or separator
            if menu_dict[entry] == None:
                # determine if entry is a separator or an inactive menu item
                if type(entry) == int:
                    menu.addSeparator()
                else:
                    menu_item = menu.addAction(entry)
                    menu_item.setEnabled(False)
            # sub menus
            if type(menu_dict[entry]) == dict:
                submenu = menu.addMenu(entry)
                # recurse because sub menus may have sub menus
                self.update_menus(menu_dict[entry], menu=submenu)
            # ordinary menu entries
            if callable(menu_dict[entry]):
                menu_item = menu.addAction(entry)
                menu_item.triggered.connect(menu_dict[entry])

class Editor(Window):
    def __init__(self, size=(640, 480)):
        super().__init__(size, "Editor")

        #TODO: Figure out a way to do the fucking line numbers

        #Text Editor
        self.text_edit = QtWidgets.QPlainTextEdit(self)
        self.text_edit.setFrameStyle(QtWidgets.QFrame.NoFrame)

        self.set_size(size[0], size[1])

        #layout
        layout = QtWidgets.QHBoxLayout()
        layout.addChildWidget(self.text_edit)

        self.setLayout(layout)
        
    def resizeEvent(self, event):
        self.set_size(event.size().width(), event.size().height())

    def set_size(self, size_x, size_y):
        self.text_edit.resize(size_x, size_y)
        self.resize(size_x, size_y)


class Message(QtWidgets.QMessageBox):
    def __init__(self, title, text):
        super().__init__()

        self.setWindowTitle(title)
        self.setText(text)
        self.setStandardButtons(QtWidgets.QMessageBox.Ok)
        self.exec()


#TODO: This needs to run in a thread but Qt really doesn't want it to. There are two ways around this:
#   - create the QtWidgets.QApplication inside a thread and run all QT stuff inside that thread
#   - make a generic wrapper for window mainloop that will always run in the main thread while the actual main control flow of the program gets moved to another thread
# There are some issues with these workarounds though; mainly that QT isn't thread safe.
# I really want to keep QT running in its own thread because I want to retain the ability to arbitrarily spawn and manipulate windows while other windows are running.
# Another issue that is probably easily worked around / fixed is that app.exec() will return once all running windows are closed.
# Idea for a workaround for both:
#   Maybe Qt has scheduled events in which case a scheduled polling event could run a function inside the Qt thread that fetches commands and executes them.
#   This could work by passing (lambda) functions through a Communication object.
#UPDATE: Tried implementing both approaches, neither worked. :(
def fixme_window_mainloop_workaround_to_just_get_a_window_started_really_should_not_be_implemented_this_way_for_reasons_stated_in_the_comment_above_the_definition_of_this_function():
    app.exec()