pypipboyapp.py

# -*- coding: utf-8 -*-


import os, platform
import sys
import json
import time
import importlib
import traceback
import faulthandler
import logging.config
import threading
import urllib.request
from PyQt5 import QtGui, QtWidgets, QtCore
from dialogs.ui_helpwidget import Ui_HelpWidget
from dialogs.ui_mainwindow import Ui_MainWindow
from pypipboy.network import NetworkChannel
from pypipboy.datamanager import PipboyDataManager
from dialogs.selecthostdialog import SelectHostDialog
from dialogs.connecthostdialog import ConnectHostDialog
from widgets.widgets import ModuleHandle 


class ApplicationStyle(QtCore.QObject):
    def __init__(self, app, name, styledir):
        self.app = app
        self.name = name
        self.styledir = styledir


# Application Main-Window
class PipboyMainWindow(QtWidgets.QMainWindow):
    # Signal that is emitted when the application should be closed.
    signalWantsToQuit = QtCore.pyqtSignal()
    
    # Constructor
    def __init__(self, parent = None):
        super().__init__(parent)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.connectionStatusLabel = QtWidgets.QLabel("No Connection")
        self.ui.statusbar.addPermanentWidget(self.connectionStatusLabel)
        self.setCentralWidget(None) # damn thing cannot be removed in Qt-Designer
        self.setDockNestingEnabled(True)
        self.setTabPosition(QtCore.Qt.AllDockWidgetAreas, QtWidgets.QTabWidget.North)
        
    # Init function that is called after everything has been set up
    def init(self, app, networkchannel, datamanager):
        if self.isFullScreen():
            self.ui.actionFullscreen.setChecked(True)
        else:
            self.ui.actionFullscreen.setChecked(False)
        self.ui.actionFullscreen.toggled.connect(self.setFullscreen)
        
    def closeEvent(self, event):
        event.ignore() # We do our own shutdown handling
        self.signalWantsToQuit.emit()
        
    @QtCore.pyqtSlot(bool)        
    def setFullscreen(self, fullscreen):
        if fullscreen:
            self.showFullScreen()
        else:
            self.showMaximized()



# Main application class
class PyPipboyApp(QtWidgets.QApplication):
    
    PROGRAM_NAME = 'PyPipboyApp'
    PROGRAM_VERSION_MAJOR = 0
    PROGRAM_VERSION_MINOR = 0
    PROGRAM_VERSION_REV = 0
    PROGRAM_VERSION_SUFFIX = 'unknown'
    #PROGRAM_ABOUT_TEXT = 'ToDo: About Text'
    PROGRAM_ABOUT_LICENSE = 'GPL 3.0<br><br>Contains Graphical Assets owned by Bethesda and subject to their terms of service.'
    PROGRAM_ABOUT_AUTHORS = '<li>matzman666</li><li>akamal</li><li>killean</li><li>gwhittey</li>'
    PROGRAM_WIDGETS_DIR = 'widgets'
    PROGRAM_STYLES_DIR = 'styles'
    
    # public signals
    signalConnectToHost = QtCore.pyqtSignal(str, int, bool)
    signalShowWarningMessage = QtCore.pyqtSignal(str, str)
    signalRequestQuit = QtCore.pyqtSignal()
    
    # internal signals
    _signalConnectToHostFinished = QtCore.pyqtSignal(bool, str)
    _signalAutodiscoveryFinished = QtCore.pyqtSignal()
    _signalFinishedCheckVersion = QtCore.pyqtSignal(dict, bool, bool, str, bool)
    
    #constructor
    def __init__(self, args, inifile):
        super().__init__(args)
        self._logger = logging.getLogger('pypipboyapp.main')

        self.startedFromWin32Launcher = False;
        
        for i in range(0, len(args)):
            if args[i].lower() == '--startedfromwin32launcher':
                self.startedFromWin32Launcher = True

        # Prepare QSettings for application-wide use
        QtCore.QCoreApplication.setOrganizationName("PyPipboyApp")
        QtCore.QCoreApplication.setApplicationName("PyPipboyApp")
        if inifile:
            self._logger.info('Using ini-file "' + str(inifile) + '".')
            self.settings = QtCore.QSettings(inifile, QtCore.QSettings.IniFormat)
        elif platform.system() == 'Windows':
            self.settings = QtCore.QSettings(QtCore.QSettings.IniFormat, QtCore.QSettings.UserScope, "PyPipboyApp", "PyPipboyApp")
            # If there are no settings, copy existing settings from registry
            if len(self.settings.allKeys()) <= 0:
                registrySettings = QtCore.QSettings(QtCore.QSettings.NativeFormat, QtCore.QSettings.UserScope, "PyPipboyApp", "PyPipboyApp")
                for k in registrySettings.allKeys():
                    self.settings.setValue(k, registrySettings.value(k))
                    #registrySettings.remove(k)
                #registrySettings.sync()
        else: 
            # Non-Windows OS already use the ini-format, they just use another file-extension. That's why we stick with nativeFormat.
            self.settings = QtCore.QSettings(QtCore.QSettings.NativeFormat, QtCore.QSettings.UserScope, "PyPipboyApp", "PyPipboyApp")
        
        # Init PyPipboy communication layer
        self.dataManager = PipboyDataManager()
        self.networkChannel = self.dataManager.networkchannel
        self.networkChannel.registerConnectionListener(self._onConnectionStateChange)
        # Connect internal signals
        self._signalAutodiscoveryFinished.connect(self._slotAutodiscoveryFinished)
        self.signalConnectToHost.connect(self.connectToHost)
        self._signalConnectToHostFinished.connect(self._slotConnectToHostFinished)
        self.signalShowWarningMessage.connect(self.showWarningMessage)
        self.signalRequestQuit.connect(self.requestQuit)
        self._signalFinishedCheckVersion.connect(self._slotFinishedCheckVersion)
        self._connectHostMessageBox = None
        self._connectHostThread = None
        self._iwcEndpoints = dict()
        self.widgetMenu = QtWidgets.QMenu()
        
        pipboyAppIcon = QtGui.QIcon()
        pipboyAppIcon.addFile(os.path.join('ui', 'res', 'PyPipBoyApp-Launcher.ico'))
        self.setWindowIcon(pipboyAppIcon)
        
        try:
            versionFile = open('VERSION', 'r')
            versionJSON = json.loads(versionFile.read())
            versionFile.close()
            self.PROGRAM_VERSION_MAJOR = versionJSON['major']
            self.PROGRAM_VERSION_MINOR = versionJSON['minor']
            self.PROGRAM_VERSION_REV = versionJSON['rev']
            self.PROGRAM_VERSION_SUFFIX = versionJSON['suffix']
        except Exception as e:
            self._logger.warn('Could not determine program version: ' + str(e))

    
    
    # run the application
    def run(self):
        self.mainWindow = PipboyMainWindow()
          
        # Load Styles
        self._loadStyles()
        # Load widgets
        self.helpWidget = QtWidgets.QDockWidget()
        self.helpWidget.ui = Ui_HelpWidget()
        self.helpWidget.ui.setupUi(self.helpWidget)
        self.helpWidget.ui.textBrowser.setSource(QtCore.QUrl.fromLocalFile(os.path.join('ui', 'res', 'helpwidget.html')))
        self.mainWindow.addDockWidget(QtCore.Qt.TopDockWidgetArea, self.helpWidget)
        self._loadWidgets()
        # Restore saved window state
        savedFullScreen = bool(int(self.settings.value('mainwindow/fullscreen', 0)))
        if savedFullScreen:
            self.mainWindow.showFullScreen()
        savedGeometry = self.settings.value('mainwindow/geometry')
        if savedGeometry:
            self.mainWindow.restoreGeometry(savedGeometry)
        savedState = self.settings.value('mainwindow/windowstate')
        if savedState:
            self.mainWindow.restoreState(savedState)
        # Create widgets menu entry
        self.widgetMenu.setTitle('Widgets')
        menuActions = self.mainWindow.menuBar().actions()
        self.mainWindow.menuBar().insertMenu(menuActions[len(menuActions)-1], self.widgetMenu)
        # connect with main window
        self.mainWindow.ui.actionConnect.triggered.connect(self.startAutoDiscovery)
        self.mainWindow.ui.actionConnectTo.triggered.connect(self.showConnectToDialog)
        self.mainWindow.ui.actionDisconnect.triggered.connect(self.disconnect)
        self.mainWindow.ui.actionQuit.triggered.connect(self.requestQuit)
        self.mainWindow.signalWantsToQuit.connect(self.requestQuit)
        self.mainWindow.ui.actionShowAbout.triggered.connect(self.showAboutDialog)
        self.mainWindow.ui.actionShowAboutQt.triggered.connect(self.aboutQt)
        self.mainWindow.ui.actionAuto_Connect_on_Start_up.triggered.connect(self.autoConnectToggled)
        self.mainWindow.ui.actionExportData.triggered.connect(self.exportData)
        self.mainWindow.ui.actionImportData.triggered.connect(self.importData)
        self.mainWindow.ui.actionVersionCheck.triggered.connect(self.startVersionCheckVerbose)
        stayOnTop = bool(int(self.settings.value('mainwindow/stayOnTop', 0)))
        self.mainWindow.ui.actionStayOnTop.toggled.connect(self.setWindowStayOnTop)
        self.mainWindow.ui.actionStayOnTop.setChecked(stayOnTop)
        promptBeforeQuit = bool(int(self.settings.value('mainwindow/promptBeforeQuit', 1)))
        self.mainWindow.ui.actionPromptBeforeQuit.toggled.connect(self.setPromptBeforeQuit)
        self.mainWindow.ui.actionPromptBeforeQuit.setChecked(promptBeforeQuit)
        # Main window is ready, so show it
        self.mainWindow.init(self, self.networkChannel, self.dataManager)
        self._initWidgets()
        self.mainWindow.show()
        # start main event loop
        if int(self.settings.value('mainwindow/autoconnect', 0)):
            self.mainWindow.actionAuto_Connect_on_Start_up.setChecked(True)
            host = 'localhost'
            port = 27000
            if self.settings.value('mainwindow/lasthost'):
                host = self.settings.value('mainwindow/lasthost')
            if self.settings.value('mainwindow/lastport'):
                port = int(self.settings.value('mainwindow/lastport'))
            self.signalConnectToHost.emit(host, port, True)
        self.startVersionCheck()
        sys.exit(self.exec_())

    @QtCore.pyqtSlot(bool)
    def autoConnectToggled(self, value):
        self.settings.setValue('mainwindow/autoconnect', int(value))

        
    # Start auto discovery (non-blocking)
    # Auto discovery is done in its own thread, we don't want to block the gui
    # returns true when the thread was successfully started
    @QtCore.pyqtSlot()
    def startAutoDiscovery(self, busyDialog = True):
        if not self.networkChannel.isConnected:
            if busyDialog:
                self._autodiscoverMessageBox = QtWidgets.QMessageBox(self.mainWindow)
                self._autodiscoverMessageBox.setWindowTitle('Autodiscovery')
                self._autodiscoverMessageBox.setText('Searching for host, please wait.')
                self._autodiscoverMessageBox.setStandardButtons(QtWidgets.QMessageBox.NoButton)
                self._autodiscoverMessageBox.show()
            else:
                self._autodiscoverMessageBox = None
            parentself = self # Capture self for inner class
            class _AutodiscoverThread(QtCore.QThread):
                def run(self):
                    try:
                        parentself._logger.debug('Starting Autodiscovery Thread')
                        parentself._autodiscoverHosts = NetworkChannel.discoverHosts()
                        parentself._signalAutodiscoveryFinished.emit()
                        parentself._logger.debug('Autodiscovery Thread finished')
                    except:
                        traceback.print_exc(file=sys.stdout)
                        time.sleep(1) # Just to make sure that the error is correctly written into the log file
            self._autodiscoverThread = _AutodiscoverThread()
            self._autodiscoverThread.start()
            return True
        else:
            return False
        
    # internal slot connected to the 'auto discovery thread is finished' signal
    @QtCore.pyqtSlot()
    def _slotAutodiscoveryFinished(self):
        # close busy dialog
        if self._autodiscoverMessageBox:
            self._autodiscoverMessageBox.hide()
            self._autodiscoverMessageBox = None
        # Wait for thread before deleting it
        self._autodiscoverThread.wait()
        self._autodiscoverThread = None
        # Let the user select a host
        selectDialog = SelectHostDialog(self.mainWindow)
        if selectDialog.exec(self._autodiscoverHosts):
            host = selectDialog.getSelectedHost()
            if host:
                self.signalConnectToHost.emit(host['addr'], NetworkChannel.PIPBOYAPP_PORT, False)
                
    # Shows a 'connect to host' dialog and then connects 
    @QtCore.pyqtSlot()        
    def showConnectToDialog(self):
        if not self.networkChannel.isConnected:
            connectDialog = ConnectHostDialog(self.mainWindow)
            host = 'localhost'
            port = 27000
            if self.settings.value('mainwindow/lasthost'):
                host = self.settings.value('mainwindow/lasthost')
            if self.settings.value('mainwindow/lastport'):
                port = self.settings.value('mainwindow/lastport')
            connectDialog.ui.hostInput.setText(host)
            connectDialog.ui.portInput.setText(str(port))
            if connectDialog.exec():
                try:
                    host = connectDialog.ui.hostInput.text()
                    port = int(connectDialog.ui.portInput.text())
                    retry = connectDialog.ui.retryCheckbox.isChecked()
                    #self.signalConnectToHost.emit(host, port, retry)
                    self.connectToHost(host, port, retry)
                except ValueError as e:
                    QtWidgets.QMessageBox.warning(self.mainWindow, 'Connection to host failed', 
                            'Caught exception while parsing port: ' + str(e),
                            QtWidgets.QMessageBox.Ok)
            
                    
    # connect to specified host (non blocking)
    # connect happens in its own thread
    # returns true when the thread was successfully started
    @QtCore.pyqtSlot(str, int, bool)        
    def connectToHost(self, host, port, retry = False,  busydialog= True):
        if not self.networkChannel.isConnected:
            self._logger.info('Connecting to host ' + host + ':' + str(port) + ' Retry=' + str(retry))
            # show busy dialog
            if busydialog:
                self._connectHostMessageBox = QtWidgets.QMessageBox(self.mainWindow)
                self._connectHostMessageBox.setWindowTitle('Connecting')
                self._connectHostMessageBox.setText('Connecting to host, please wait.')
                self._connectHostMessageBox.setStandardButtons(QtWidgets.QMessageBox.Cancel)
                self._connectHostMessageBox.buttonClicked.connect(self.cancelConnectToHost)
                self._connectHostMessageBox.show()
            else:
                self._connectHostMessageBox = None
            # start connect thread
            parentself = self # capture self for inner class
            if not self._connectHostThread or not self._connectHostThread.isRunning():
                class _ConnectHostThread(QtCore.QThread):
                    def run(self):
                        parentself._logger.debug('Connect to Host Thread started')
                        self._cancelThread = False
                        while not self._cancelThread:
                            try:
                                if not parentself.networkChannel.connect(host, port = port):
                                    parentself._signalConnectToHostFinished.emit(False, 'Host denied connection.')
                                    break
                                else:
                                    parentself._signalConnectToHostFinished.emit(True, '')
                                    break
                            except Exception as e:
                                if not retry:
                                    parentself._signalConnectToHostFinished.emit(False, 'Caught exception while connecting to host: ' + str(e))
                                    break
                        parentself._logger.debug('Connect to Host Thread finished')
                self._connectHostThread = _ConnectHostThread()
                self._connectHostThread.start()
                return True
            else:
                QtWidgets.QMessageBox.warning(self.mainWindow, 'Connection to host failed', 
                        'There is another connection thread already running', QtWidgets.QMessageBox.Ok)
                return False
        else:
            return False
            
    # Cancels any currently running 'connect to host' operation
    @QtCore.pyqtSlot(QtWidgets.QAbstractButton)        
    def cancelConnectToHost(self, button):
        if self._connectHostThread and self._connectHostThread.isRunning():
            self._logger.info('Connect to Host Thread Cancel Request received')
            self._connectHostThread._cancelThread = True
            self.networkChannel.cancelConnectionAttempt()
            try:
                self._connectHostThread.wait()
            except:
                pass
            self._connectHostThread = None
                    
    
    # internal slot connected to the 'connect thread is finished' signal
    @QtCore.pyqtSlot(bool, str)        
    def _slotConnectToHostFinished(self, status, msg):
        # hide busy dialog
        if self._connectHostMessageBox:
            self._connectHostMessageBox.hide()
            self._connectHostMessageBox = None
        # delete thread
        if self._connectHostThread:
            self._connectHostThread.wait()
            self._connectHostThread = None
        # Handle errors
        if status:
            pass
        else:
            QtWidgets.QMessageBox.warning(self.mainWindow, 'Connection to host failed', msg)
                
    # Shows a warning message dialog
    @QtCore.pyqtSlot(str, str)        
    def showWarningMessage(self, title, text):
            QtWidgets.QMessageBox.warning(self.mainWindow, title, text)
    
    # Shows a info message dialog
    @QtCore.pyqtSlot(str, str)        
    def showInfoMessage(self, title, text):
            QtWidgets.QMessageBox.information(self.mainWindow, title, text)
    
    # disconnects the current network session
    @QtCore.pyqtSlot()        
    def disconnect(self):
        if self.networkChannel.isConnected:
            self.networkChannel.disconnect()

    # Request the user to quit, saves state and quits
    @QtCore.pyqtSlot()        
    def requestQuit(self):
        # do you really wanna
        if not int(self.settings.value('mainwindow/promptBeforeQuit', 1)) or  QtWidgets.QMessageBox.question(self.mainWindow, 'Close', 'Are you sure you want to quit?',
                            QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,
                            QtWidgets.QMessageBox.No) == QtWidgets.QMessageBox.Yes:
            # disconnect any network sessions
            if self.networkChannel.isConnected:
                self.networkChannel.disconnect()
            # save state
            self.settings.setValue('mainwindow/geometry', self.mainWindow.saveGeometry())
            self.settings.setValue('mainwindow/fullscreen', int(self.mainWindow.isFullScreen()))
            self.settings.setValue('mainwindow/windowstate', self.mainWindow.saveState())
            self.settings.sync()
            # quit
            self.quit()
    
    def getVersionString(self, versionData = None):
        if versionData:
            major = versionData['major']
            minor = versionData['minor']
            rev = versionData['rev']
            suffix = versionData['suffix']
        else:
            major = self.PROGRAM_VERSION_MAJOR
            minor = self.PROGRAM_VERSION_MINOR
            rev = self.PROGRAM_VERSION_REV
            suffix = self.PROGRAM_VERSION_SUFFIX
        version = 'v' + str(major) + '.' + str(minor)
        if rev > 0:
            version += '.' + str(rev)
        if suffix:
            version += '-' + suffix
        return version
    
    # Shows the about dialog
    def showAboutDialog(self):
        QtWidgets.QMessageBox.about(self.mainWindow, 'About ' + self.PROGRAM_NAME,
            '<b>' + self.PROGRAM_NAME + '</b><br>' + self.getVersionString() + '<br><br>' +
            #self.PROGRAM_ABOUT_TEXT + '<br><br>' + 
            '<b>License:</b><br>' + self.PROGRAM_ABOUT_LICENSE + '<br><br>' +
            '<b>Authors:</b><ul>' + self.PROGRAM_ABOUT_AUTHORS + '<ul>')
        
    @QtCore.pyqtSlot()        
    def exportData(self):
        fileName = QtWidgets.QFileDialog.getSaveFileName(self.mainWindow, '', '', 'Pipboy Data (*.pip)')
        if fileName[0]:
            #try:
                file = open(fileName[0], 'w')
                data = {}
                data['PipDatabase'] = self.dataManager.exportData()
                data['PipDatabase'].reverse()
                file.write(json.dumps(data))
                file.close()
            #except Exception as e:
            #    self.showWarningMessage('Export Data', 'Could not export data: '  + str(e))
        
    @QtCore.pyqtSlot()        
    def importData(self):
        fileName = QtWidgets.QFileDialog.getOpenFileName(self.mainWindow, '', '', 'Pipboy Data (*.pip)')
        if fileName[0]:
            #try:
                file = open(fileName[0], 'r')
                self.dataManager.importData(json.loads(file.read())['PipDatabase'])
                file.close()
            #except Exception as e:
            #    self.showWarningMessage('Import Data', 'Could not import data: '  + str(e))
        
        
    # event listener for pypipboy network state events
    def _onConnectionStateChange(self, state, errstatus = 0, errmsg = ''):
        self._logger.info('Connection State Changed: ' + str(state) + ' - ' + str(errstatus) + ' - ' + str(errmsg))
        if state: # connect
            # menu management stuff
            self.mainWindow.ui.actionConnect.setEnabled(False)
            self.mainWindow.ui.actionConnectTo.setEnabled(False)
            self.mainWindow.ui.actionDisconnect.setEnabled(True)
            self.mainWindow.ui.actionExportData.setEnabled(True)
            self.mainWindow.ui.actionImportData.setEnabled(False)
            # status bar update
            tmp = str(self.networkChannel.hostAddr) + ':' + str(self.networkChannel.hostPort) + ' ('
            tmp += 'Version: ' + str(self.networkChannel.hostVersion) + ", "
            tmp += 'Lang: ' +str(self.networkChannel.hostLang) + ")"
            self.mainWindow.connectionStatusLabel.setText('Connected to ' + tmp)
            self.settings.setValue('mainwindow/lasthost', str(self.networkChannel.hostAddr))
            self.settings.setValue('mainwindow/lastport', self.networkChannel.hostPort)

            
        else: # disconnect
            # menu management stuff
            self.mainWindow.ui.actionConnect.setEnabled(True)
            self.mainWindow.ui.actionConnectTo.setEnabled(True)
            self.mainWindow.ui.actionDisconnect.setEnabled(False)
            self.mainWindow.ui.actionExportData.setEnabled(False)
            self.mainWindow.ui.actionImportData.setEnabled(True)
            # status bar update
            self.mainWindow.connectionStatusLabel.setText('No Connection')
            # error handling
            if errstatus != 0:
                self.signalShowWarningMessage.emit('Connection Error', 'Connection Error: ' + str(errmsg))
                
    @QtCore.pyqtSlot()
    def startVersionCheckVerbose(self):
        self.startVersionCheck(True)
    
    @QtCore.pyqtSlot()
    def startVersionCheck(self, verbose = False):
        def _checkVersion():
            try:
                rawData = urllib.request.urlopen('https://raw.githubusercontent.com/matzman666/PyPipboyApp/versionCheck/VERSION').read().decode()
                versionData = json.loads(rawData)
                major = versionData['major']
                minor = versionData['minor']
                rev = versionData['rev']
                suffix = versionData['suffix']
                newVersionAvailable = False
                if (self.PROGRAM_VERSION_MAJOR < major 
                        or (self.PROGRAM_VERSION_MAJOR == major and self.PROGRAM_VERSION_MINOR < minor) 
                        or (self.PROGRAM_VERSION_MAJOR == major and self.PROGRAM_VERSION_MINOR == minor and self.PROGRAM_VERSION_REV < rev)):
                    newVersionAvailable = True
                self._signalFinishedCheckVersion.emit(versionData, newVersionAvailable, False, '', verbose)
            except Exception as e:
                self._logger.warn('Could not check for new version: ' + str(e))
                self._signalFinishedCheckVersion.emit({}, False, True, str(e), verbose)
        self._checkVersionThread = threading.Thread(target = _checkVersion)
        self._checkVersionThread.start()
    
    
    @QtCore.pyqtSlot(dict, bool, bool, str, bool)
    def _slotFinishedCheckVersion(self, versionData, newVersionAvailable, errorState, errorString, verbose):
        self._checkVersionThread.join()
        self._checkVersionThread = None
        if errorState:
            if verbose:
                self.showWarningMessage('Version Check', 'Could not check for new version: ' + errorString)
        elif newVersionAvailable:
            self.showInfoMessage('Version Check', '<b>New version is available!<br><br>' 
                                                + self.getVersionString(versionData) + '</b> (current: ' 
                                                + self.getVersionString() + ').<br><br>'
                                                + 'Download from:<ul>'
                                                + '<li><a href="http://www.nexusmods.com/fallout4/mods/4664">nexusmods.com</a><li>'
                                                + '<li><a href="http://github.com/matzman666/PyPipboyApp">github.com</a></li></ul>')
        elif verbose:
            self.showInfoMessage('Version Check', 'Current version is up-to-date.')
    
    @QtCore.pyqtSlot(bool)
    def setWindowStayOnTop(self, value):
        self.settings.setValue('mainwindow/stayOnTop', int(value))
        if value:
            self.mainWindow.setWindowFlags(self.mainWindow.windowFlags() | QtCore.Qt.WindowStaysOnTopHint)
        else:
            self.mainWindow.setWindowFlags(self.mainWindow.windowFlags() & ~QtCore.Qt.WindowStaysOnTopHint)
        self.mainWindow.show()

    @QtCore.pyqtSlot(bool)
    def setPromptBeforeQuit(self, value):
        self.settings.setValue('mainwindow/promptBeforeQuit', int(value))
    
    
    # load widgets
    def _loadWidgets(self):
        self.widgets = list()
        self.modulehandles = dict()
        menuCategoryMap = dict()
        self.widgetMenuEntries = list()
        lastWidget = self.helpWidget
        for dir in os.listdir(self.PROGRAM_WIDGETS_DIR):
            dirpath = os.path.join(self.PROGRAM_WIDGETS_DIR, dir)
            if dir != 'shared' and not dir.startswith('__') and os.path.isdir(dirpath):
                self._logger.debug('Trying to load widget "' + dir + '"')
                module = None
                try:
                    module = importlib.import_module(self.PROGRAM_WIDGETS_DIR + '.' + dir + '.info')
                    info = getattr(module, 'ModuleInfo')
                    if info:
                        if info.isEnabled():
                            self._logger.debug('Found info module')
                            if info.LABEL in self.modulehandles:
                                raise Exception('Module with same name already exists.')
                            handle = ModuleHandle(self, dirpath)
                            self.modulehandles[info.LABEL] = handle
                            widgets = info.createWidgets(handle, self.mainWindow)
                            if widgets:
                                if not type(widgets) == list:
                                    nl = list()
                                    nl.append(widgets)
                                    widgets = nl
                                i = 0
                                for w in widgets:
                                    w.setObjectName(info.LABEL + '_' + str(i))
                                    self.mainWindow.addDockWidget(QtCore.Qt.TopDockWidgetArea, w)
                                    self.widgets.append(w)
                                    if w.getMenuCategory():
                                        try:
                                            m = menuCategoryMap[w.getMenuCategory()]
                                            m.addAction(w.toggleViewAction())
                                        except:
                                            m = QtWidgets.QMenu(w.getMenuCategory())
                                            menuCategoryMap[w.getMenuCategory()] = m
                                            self.widgetMenuEntries.append(m)
                                            m.addAction(w.toggleViewAction())
                                    else:
                                        self.widgetMenuEntries.append(w.toggleViewAction())
                                    w.setVisible(False)
                                    if lastWidget:
                                        self.mainWindow.tabifyDockWidget(lastWidget, w)
                                    lastWidget = w
                                    i += 1
                                self._logger.info('Successfully loaded widget "' + dir + '"')
                            else:
                                self._logger.warning('Could not load widget "' + dir + '": No widgets returned')
                        else:
                            self._logger.info('Widget "' + dir + '" is not enabled')
                    else:
                        self._logger.warning('Could not load widget "' + dir + '": No Info')
                except Exception as e:
                    self._logger.warning('Could not load widget "' + dir + '": ' + str(e))
                    traceback.print_exc(file=sys.stdout)
        for e in self.widgetMenuEntries:
            if type(e) == QtWidgets.QMenu:
                self.widgetMenu.addMenu(e)
            else:
                self.widgetMenu.addAction(e)
    
    def iwcRegisterEndpoint(self, key, endpoint):
        self._iwcEndpoints[key] = endpoint
        
    def iwcUnregisterEndpoint(self, key):
        if key in self._iwcEndpoints:
            del self._iwcEndpoints[key]
            
    def iwcGetEndpoint(self, key):
        try:
            return self._iwcEndpoints[key]
        except:
            return None
    
    # load widgets
    def _initWidgets(self):
        for w in self.widgets:
            w.iwcSetup(self)
        for w in self.widgets:
            w.init(self, self.dataManager)
            
    def _loadStyles(self):
        self.styles = dict()
        for dir in os.listdir(self.PROGRAM_STYLES_DIR):
            dirpath = os.path.join(self.PROGRAM_STYLES_DIR, dir)
            if not dir.startswith('__') and dir != 'default' and os.path.isdir(dirpath):
                self._logger.debug('Trying to add style "' + dir + '"')
                stylefile = os.path.join(dirpath, 'style.qss')
                if os.path.isfile(stylefile):
                    style = ApplicationStyle(self, dir, dirpath)
                    self.styles[dir] = style
                    self._logger.info('Added style "' + dir + '"')
                else:
                    self._logger.warn('Could not add style "' + dir + '": No style.qss found')
        menu = self.mainWindow.ui.menuStyles
        def _genSlotSetStyles(app, name):
            return lambda : app.setStyle(name)
        for s in self.styles:
            action = menu.addAction(self.styles[s].name)
            action.triggered.connect(_genSlotSetStyles(self, self.styles[s].name))
            action.setCheckable(True)
        self.mainWindow.ui.actionStylesDefault.triggered.connect(_genSlotSetStyles(self, 'default'))
        if (self.settings.value('mainwindow/lastStyle')):
            self.setStyle(self.settings.value('mainwindow/lastStyle'))
        else:
            self.setStyle('default')
        
            
    def setStyle(self, name):
        if (name == 'default' or not name in self.styles):
            name = 'default'
            self.setStyleSheet('')
        else:
            style = self.styles[name]
            stylefilepath = os.path.join(style.styledir, 'style.qss')
            self.setStyleSheet('file:///' + stylefilepath)
        actionFound = False
        for a in self.mainWindow.ui.menuStyles.actions():
            if a.text() == name:
                a.setChecked(True)
                actionFound = True
            else:
                a.setChecked(False)
        if not actionFound:
            self.mainWindow.ui.actionStylesDefault.setChecked(True)
        self.settings.setValue('mainwindow/lastStyle', name) 
        
           
            
    def isWidgetReallyVisisble(self, widget):
        return not widget.visibleRegion().isEmpty()
                
    def popWidget(self, widgetName):
        self._logger.debug('popWidget: widgetName: ' + str(widgetName))
        for widget in self.widgets:
            if (widget.windowTitle().lower() == widgetName):
                widget.raise_()
                break
        return
        
    def cycleWidgets(self, widgetNameList):
        self._logger.debug('cycleWidgets: widgetNameList: ' + str(widgetNameList))
        nextWidgetIndex = 0
        currentWidget = None
        for widget in self.widgets:
            #self._logger.debug('cycleWidgets: \t: ' + str(widget.windowTitle()))
            if (widget.windowTitle().lower() in widgetNameList
            and self.isWidgetReallyVisisble(widget)):
                currentWidget = widget
                break

        if (currentWidget):
            for i in range(0, len(widgetNameList)):
                if (currentWidget.windowTitle().lower() == widgetNameList[i]):
                    nextWidgetIndex = i + 1
                    break
                        
        if(nextWidgetIndex >= len(widgetNameList)):
            nextWidgetIndex = 0

        nextWidgetName = widgetNameList[nextWidgetIndex]
        self.popWidget(nextWidgetName)   
        return        

            
# Main entry point
if __name__ == "__main__":
    try:
        stdlogfile = None
        inifile = None
        i = 1
        while i < len(sys.argv):
            if sys.argv[i] == '--stdlog':
                if i == len(sys.argv) -1 :
                    logging.error('Missing argument for --stdlog')
                else:
                    i += 1
                    stdlogfile = sys.argv[i]
            elif sys.argv[i] == '--inifile':
                if i == len(sys.argv) -1 :
                    logging.error('Missing argument for --inifile')
                else:
                    i += 1
                    inifile = sys.argv[i]
            i += 1
        if stdlogfile != None:
            stdlog = open(stdlogfile, 'w')
            sys.stdout = stdlog
            sys.stderr = stdlog
        try:
            logging.config.fileConfig('logging.config')
        except Exception as e:
            logging.basicConfig(level=logging.WARN)
            logging.error('Error while reading logging config: ' + str(e))
    
        try:
            faulthandler.enable()
        except Exception as e:
            logging.error('Error calling Faulthandle.enable(): ' + str(e))
            
        if (faulthandler.is_enabled()):
            logging.warning('Faulthandler is enabled')
            #faulthandler.dump_traceback_later(5)
        else:
            logging.error('Faulthandler is NOT enabled')
    
        if 'nt' in os.name:
            from ctypes import windll
            windll.shell32.SetCurrentProcessExplicitAppUserModelID(u'matzman666.pypipboyapp')
        pipboyApp = PyPipboyApp(sys.argv, inifile)
        pipboyApp.run()
    except:
        traceback.print_exc(file=sys.stdout)
        time.sleep(1) # Just to make sure that the error is correctly written into the log file