コード例 #1
0
class instanceWindow(QDialog):
    widgets = []
    repoWidgets = []
    cacheTabWidgets = []
    installModpack = utils.installModpack()
    getModpackFS = utils.getModpackFS()
    getModpackURL = utils.getModpackURL()
    getModpackRepo = utils.getModpackRepo()

    # Same drill. Does background things.
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowModality(Qt.ApplicationModal)
        self.progressWin = installWindow(self)
        self.getModpackRepo.result.connect(self.updateRepo)
        optionWindow.launcherConfig = utils.loadSettings(self)
        screen_resolution = app.desktop().screenGeometry()
        self.title = config.NAME + " " + config.VER + " Instance Manager"
        self.setWindowIcon(QIcon(config.ICON))
        self.left = screen_resolution.width() / 2 - 290
        self.top = screen_resolution.height() / 2 - 170
        self.initUI()
        self.getModpackRepo.start()

    # Same drill. Does showy things.
    def initUI(self):
        self.setWindowTitle(self.title)
        self.setGeometry(self.left, self.top, 580, 340)
        self.setFixedSize(self.size())
        self.createTabs()
        self.createButtons()
        self.createStatus()
        self.createInput()
        self.show()

    def updateRepo(self, result, modpacks):
        for widget in self.repoWidgets:
            try:
                widget.deleteLater()
            except:
                pass

        self.repoWidgets = []

        if result == True:
            for key, modpack in modpacks["modpacks"].items():
                vbox = QVBoxLayout()
                group = QGroupBox(modpack["name"] + " version " + modpack["modpackver"])
                widget = QPushButton(self, text="Install " + modpack["name"] + " version " + modpack["modpackver"] + ".")
                widget1 = QTextEdit(self)
                widget2 = QPushButton(self, text="View on pymcl.net")
                widget1.setText(modpack["smalldesc"])
                widget1.setReadOnly(True)
                widget.clicked.connect(functools.partial(self.getModpackURLWrapper, modpack["zipurl"]))
                widget2.clicked.connect(functools.partial(utils.openModpackInBrowser, key))
                vbox.addWidget(widget)
                vbox.addWidget(widget1)
                vbox.addWidget(widget2)
                group.setLayout(vbox)
                self.modpackRepoLayout.addWidget(group)
                self.repoWidgets.append(widget)
                self.repoWidgets.append(widget1)
                self.repoWidgets.append(widget2)
                self.repoWidgets.append(group)

    # I sorta figured this out. Still hella bad. Will be sorted sometime in the future.
    def createTabs(self):
        for widget in self.widgets:
            try:
                widget.deleteLater()
            except:
                pass
        self.widgets = []
        self.tab = QTabWidget(self)
        self.tab.move(1, 0)
        self.tab.resize(self.size())
        self.tab.resize(self.tab.width(), self.tab.height()-20)
        self.removeInstanceContainer = QVBoxLayout(self)
        self.cacheTabContainer = QVBoxLayout(self)
        self.modpackRepoContainer = QVBoxLayout(self)
        self.addInstanceTab = QWidget()
        self.removeInstanceTab = QWidget()
        self.cacheTab = QWidget()
        self.modpackRepoTab = QWidget()
        self.tab.addTab(self.addInstanceTab, "Create an Instance")
        self.tab.addTab(self.modpackRepoTab, "Modpack Repo")
        self.tab.addTab(self.removeInstanceTab, "Delete Instances")
        self.tab.addTab(self.cacheTab, "Manage Cached Modpacks")
        self.removeInstanceTab.setLayout(self.removeInstanceContainer)
        self.cacheTab.setLayout(self.cacheTabContainer)
        self.modpackRepoTab.setLayout(self.modpackRepoContainer)

        scroll = QScrollArea(self)
        self.removeInstanceContainer.addWidget(scroll)
        scroll.setWidgetResizable(True)
        scroll.resize(scroll.width(), scroll.height()-20)
        scrollContent = QWidget(scroll)
        self.removeInstanceLayout = QVBoxLayout(scrollContent)
        scrollContent.setLayout(self.removeInstanceLayout)
        scroll.setWidget(scrollContent)

        scroll = QScrollArea(self)
        self.cacheTabContainer.addWidget(scroll)
        scroll.setWidgetResizable(True)
        scrollContent = QWidget(scroll)
        self.cacheTabLayout = QVBoxLayout(scrollContent)
        scrollContent.setLayout(self.cacheTabLayout)
        scroll.setWidget(scrollContent)

        scroll = QScrollArea(self)
        self.modpackRepoContainer.addWidget(scroll)
        scroll.setWidgetResizable(True)
        scrollContent = QWidget(scroll)
        self.modpackRepoLayout = QVBoxLayout(scrollContent)
        scrollContent.setLayout(self.modpackRepoLayout)
        scroll.setWidget(scrollContent)
        self.refreshButton = QPushButton(self.modpackRepoTab)
        self.refreshButton.move(8, 8)
        self.refreshButton.resize(20, 20)
        icon = QIcon(utils.resourcePath("refresh.png"))
        self.refreshButton.setIcon(icon)
        self.refreshButton.clicked.connect(self.getModpackRepo.start)

        self.updateInstanceList()
        self.updateCacheList()

    def updateInstanceList(self):
        utils.areYouThere(config.MC_DIR + "/instances")
        for widget in self.widgets:
            widget.deleteLater()

        self.widgets = []

        instances = [f for f in os.listdir(config.MC_DIR + "/instances") if not os.path.isfile(config.MC_DIR + "/instances/" + f)]
        for instance in instances:
            widget = QPushButton(self, text="Delete " + instance + ".")
            widget.clicked.connect(functools.partial(utils.rmInstance, instance, self))
            self.removeInstanceLayout.addWidget(widget)
            self.widgets.append(widget)

    def updateCacheList(self):
        utils.areYouThere(config.MC_DIR + "/modpackzips")
        modpacks = [f for f in os.listdir(config.MC_DIR + "/modpackzips") if os.path.isfile(config.MC_DIR + "/modpackzips/" + f)]

        for widget in self.cacheTabWidgets:
            try:
                widget.deleteLater()
            except:
                pass

        self.repoWidgets = []

        for modpack in modpacks:
            vbox = QVBoxLayout()
            group = QGroupBox(modpack)
            widget = QPushButton(self, text="Install " + modpack + ".")
            widget1 = QPushButton(self, text="Delete " + modpack + ".")
            widget2 = QTextEdit(self)
            widget2.setText("A generic ZIP modpack.")
            widget2.setReadOnly(True)
            widget.clicked.connect(functools.partial(self.installModpackWrapper, config.MC_DIR + "/modpackzips/" + modpack))
            widget1.clicked.connect(functools.partial(self.removeModpack, config.MC_DIR + "/modpackzips/" + modpack, modpack))
            vbox.addWidget(widget)
            vbox.addWidget(widget1)
            vbox.addWidget(widget2)
            group.setLayout(vbox)
            self.cacheTabLayout.addWidget(group)
            self.cacheTabWidgets.append(widget)
            self.cacheTabWidgets.append(widget1)
            self.cacheTabWidgets.append(widget2)
            self.cacheTabWidgets.append(group)

    def createButtons(self):
        # Local filesystem crap
        self.installModpackButton = QPushButton("Install Local Modpack", self.addInstanceTab)
        self.installModpackButton.resize(150, 22)
        self.installModpackButton.move(5, 5)
        self.installModpackButton.clicked.connect(lambda: self.getModpackFSWrapper(self.modpackZipDir.text()))

        self.getDirButton = QPushButton("...", self.addInstanceTab)
        self.getDirButton.resize(24, 22)
        self.getDirButton.move(545, 5)
        self.getDirButton.clicked.connect(self.getDir)

        self.openDirButton = QPushButton("Open " + config.NAME + " Install Dir", self.addInstanceTab)
        self.openDirButton.resize(150, 22)
        self.openDirButton.move(5, self.height()-70)
        self.openDirButton.clicked.connect(self.openDir)

        # Url crap
        self.installModpackUrlButton = QPushButton("Install Modpack from URL", self.addInstanceTab)
        self.installModpackUrlButton.resize(150, 22)
        self.installModpackUrlButton.move(5, 34)
        self.installModpackUrlButton.clicked.connect(lambda: self.getModpackURLWrapper(self.modpackURL.text()))

        self.instanceVersionButton = QPushButton(self.addInstanceTab, text="Create Blank Instance")
        self.instanceVersionButton.resize(150, 22)
        self.instanceVersionButton.move(5, 63)
        self.instanceVersionButton.clicked.connect(lambda: self.installModpackWrapper(self.instanceName.text(), True, self.instanceVersion.currentText()))

    def createStatus(self):
        self.status = QLabel(self)
        self.status.resize(self.width(), 20)
        self.status.move(0, self.height()-20)
        self.updateStatus()

    def createInput(self):
        self.modpackZipDir = QLineEdit(self.addInstanceTab)
        self.modpackZipDir.setPlaceholderText("Paste the path to your modpack ZIP file here!")
        self.modpackZipDir.resize(390, 22)
        self.modpackZipDir.move(155, 5)

        self.modpackURL = QLineEdit(self.addInstanceTab)
        self.modpackURL.setPlaceholderText("Paste the URL to download your modpack ZIP from here!")
        self.modpackURL.resize(390, 22)
        self.modpackURL.move(155, 34)

        self.instanceName = QLineEdit(self.addInstanceTab)
        self.instanceName.setPlaceholderText("Instance name")
        self.instanceName.resize(194, 22)
        self.instanceName.move(155, 63)

        self.instanceVersion = QComboBox(self.addInstanceTab)
        self.instanceVersion.addItems(utils.getMCVersions().keys())
        self.instanceVersion.resize(194, 22)
        self.instanceVersion.move(351, 63)

    def progressWinWrapper(self):
        if self.progressWin.iWantToDie == True:
            self.progressWin.iWantToDie = False
            self.progressWin.exec_()

    def modpackInstallDone(self):
        self.progressWin.iWantToDie = True
        self.progressWin.close()
        self.updateInstanceList()

    def installModpackWrapper(self, modpackName, isVanilla=False, mcVer=""):
        self.installModpack.stop()
        self.installModpack = utils.installModpack(modpackName, isVanilla, mcVer)
        self.installModpack.done.connect(self.modpackInstallDone)
        self.installModpack.starting.connect(self.progressWinWrapper)
        self.installModpack.updateIStatus.connect(self.updateIStatus)
        self.installModpack.updateStatus.connect(self.updateStatus)
        self.installModpack.start()

    def getModpackURLWrapper(self, modpackURL):
        self.getModpackURL.stop()
        self.getModpackURL = utils.getModpackURL(modpackURL)
        self.getModpackURL.starting.connect(self.progressWinWrapper)
        self.getModpackURL.installModpack.connect(self.installModpackWrapper)
        self.getModpackURL.updateIStatus.connect(self.updateIStatus)
        self.getModpackURL.start()

    def getModpackFSWrapper(self, modpackDir):
        self.getModpackFS.stop()
        self.getModpackFS = utils.getModpackFS(modpackDir)
        self.getModpackFS.starting.connect(self.progressWinWrapper)
        self.getModpackFS.installModpack.connect(self.installModpackWrapper)
        self.getModpackFS.start()

    def removeModpack(self, dir, name="this"):

        result = QMessageBox.question(self, "Are you sure?", "Are you sure you want to delete " + name + "?", QMessageBox.Yes | QMessageBox.No, QMessageBox.No)

        if result == QMessageBox.Yes:
            os.unlink(dir)
            self.updateCacheList()

    @staticmethod
    def openDir():
        if platform.system() == "Windows":
            os.startfile(config.MC_DIR)
        elif platform.system() == "Darwin":
            subprocess.Popen(["open", config.MC_DIR])
        else:
            subprocess.Popen(["xdg-open", config.MC_DIR])

    def getDir(self):
        fileName, _ = QFileDialog.getOpenFileName(self, "Select a Modpack ZIP File", os.path.expanduser("~"), "Modpack ZIP Archive (*.zip)")
        if fileName:
            self.modpackZipDir.setText(fileName)

    # Cause we need an error box thingy without too much copypasta.
    def error(self, err):
        QMessageBox.warning(self, "Warning", err, QMessageBox.Ok, QMessageBox.Ok)

    def updateStatus(self, text="", color="black", bgcolor="lightgrey"):
        self.status.setText(text)
        self.status.setStyleSheet("color: " + color + "; background-color: " + bgcolor + ";")

    def updateIStatus(self, text):
        utils.logger.info(text)
        try:
            if text.startswith("[") and self.progressWin.status.toPlainText().split("\n")[len(self.progressWin.status.toPlainText().split("\n"))-2].startswith("["):
                newtext = self.progressWin.status.toPlainText().split("\n")
                newtext = "\n".join(newtext[:len(newtext)-2])
                newtext = newtext + "\n" + text + "\n"
            else:
                newtext = self.progressWin.status.toPlainText() + text + "\n"
            self.progressWin.status.setText(newtext)
            self.progressWin.status.verticalScrollBar().setValue(self.progressWin.status.verticalScrollBar().maximum())
        except:
            pass


    # Fires when the instance select window closes.
    def closeEvent(self, event, *args, **kwargs):
        global mainWin
        # Wouldnt want to try and launch a non-existant instance now, do we?
        if not os.path.exists(config.MC_DIR + "/instances/" + mainWin.currentInstance):
            try:
                mainWin.currentInstance = os.listdir(config.MC_DIR + "/instances")[1]
            except:
                mainWin.currentInstance = ""

        mainWin.createDropdowns()
        mainWin.setInstance(mainWin.currentInstance)
コード例 #2
0
class PhotoAlbumAndDirectoryViewer(QWidget):
    def __init__(self, parent):
        super(QWidget, self).__init__(parent)
        self.parent = parent
        self.setFixedWidth(400)
        self.layout = QVBoxLayout(self)

        # Инициализация вкладок
        self.tabs = QTabWidget()

        # init first tab
        self.directory_viewer = QTreeView()

        self.cur_item = None

        path = QDir.rootPath()
        self.dirModel = QFileSystemModel()
        self.dirModel.setRootPath(QDir.rootPath())
        self.dirModel.setFilter(QDir.NoDotAndDotDot | QDir.AllDirs)

        self.fileModel = QFileSystemModel()
        self.fileModel.setFilter(QDir.NoDotAndDotDot | QDir.Files)

        self.directory_viewer.setModel(self.dirModel)
        self.directory_viewer.setRootIndex(self.dirModel.index(path))

        self.directory_viewer.clicked.connect(self.parent.on_clicked_directory)

        self.tabs.addTab(self.directory_viewer, 'Directory')

        # init photo album creator and viewer
        self.album_viewer = QListWidget()

        self.dict_albums = {}  # key - name album, value list path photo path

        self.album_viewer.setViewMode(QListWidget.IconMode)
        self.album_viewer.setResizeMode(QListWidget.Adjust)
        self.album_viewer.setMovement(QListView.Static)

        self.tabs.addTab(self.album_viewer, 'Album viewer')

        self.album_viewer.itemClicked.connect(self.on_clicked_album)

        self.layout.addWidget(self.tabs)

        # init btn for manage photo album directory

        self.search_btn = QPushButton(self)
        self.search_btn.resize(QSize(28, 28))
        self.search_btn.setIconSize(QSize(28, 28))
        self.search_btn.setIcon(QIcon('image/search.png'))
        self.search_btn.clicked.connect(self.open_find_widget)

        self.add_album = QPushButton(self)
        self.add_album.resize(QSize(28, 28))
        self.add_album.setIconSize(QSize(28, 28))
        self.add_album.setIcon(QIcon('image/add_album.png'))
        self.add_album.clicked.connect(self.add_album_widget)

        self.edit_album = QPushButton(self)
        self.edit_album.resize(QSize(28, 28))
        self.edit_album.setIconSize(QSize(40, 44))
        self.edit_album.setIcon(QIcon('image/edit_folder.png'))
        self.edit_album.clicked.connect(self.edit_album_f)

        self.del_album = QPushButton(self)
        self.del_album.resize(QSize(28, 28))
        self.del_album.setIconSize(QSize(28, 28))
        self.del_album.setIcon(QIcon('image/delete_folder.png'))
        self.del_album.clicked.connect(self.del_album_f)

        self.cluster_widget = ClusterWidget(list(self.dict_albums.keys()),
                                            parent=self)

        self.btn_cluster = QPushButton(self)
        self.btn_cluster.resize(QSize(28, 28))
        self.btn_cluster.setIconSize(QSize(28, 28))
        self.btn_cluster.setIcon(QIcon('image/cluster.png'))
        self.btn_cluster.clicked.connect(self.show_cluster_widget)

        # init widgets edit and add, del album

        self.add_album_w = AddAlbum(self)
        self.edit_album_w = None

        self.search_widget = SearchWidget(self)
        self.cluster_creator = None

        self.setLayout(self.layout)

    def show_cluster_widget(self):
        self.cluster_widget = ClusterWidget(list(self.dict_albums.keys()),
                                            parent=self)
        self.cluster_widget.show()

    def clusters_files(self, clusters_list_album):
        dict_tags = {}
        for album in clusters_list_album:
            for image_path in self.dict_albums[album]:
                print('Dict_tags: ', dict_tags)
                dict_tags[DirectoryViewer.get_name_from_path(image_path)] = \
                    [image_path, list(get_tags_image(image_path).keys())]

        self.cluster_creator = ClusterSelector(self, dict_tags)
        self.cluster_creator.show()

    def open_find_widget(self):
        self.search_widget.show()

    def add_cluster_albums(self, added_albums):
        del self.cluster_creator
        for i in added_albums:
            self.create_album(i, [added_albums[i][1]])

    def find_files(self, file_name, flags_search: list):
        if 'folder' in flags_search:
            self.search_file_in_folders(file_name)
        if 'album' in flags_search:
            self.search_file_in_album(file_name)

    def search_file_in_folders(self, file_name):
        pass

    def search_file_in_album(self, file_name):
        list_equal = []
        for file_list in self.dict_albums:
            for file_path in self.dict_albums[file_list]:
                print(file_path, ':', file_name)
                if file_name == DirectoryViewer.get_name_from_path(file_path):
                    list_equal.append(file_path)
        if not list_equal:
            QMessageBox.critical(None, 'Error', 'No files found in album')
        else:
            self.parent.change_list(list_equal)

    def del_album_f(self):
        if self.cur_item:
            if self.cur_item in self.dict_albums:
                self.dict_albums.pop(self.cur_item)
                self.update_album_list()

    def edit_album_f(self):
        if self.cur_item:
            if self.cur_item in self.dict_albums:
                self.edit_album_w = EditAlbum(
                    name=self.cur_item,
                    list_images=self.dict_albums[self.cur_item],
                    parent=self)
                self.edit_album_w.show()

    def contain_name_album(self, name):
        if name in self.dict_albums:
            return True
        return False

    def create_album(self, name, photo_list):
        if name in self.dict_albums:
            self.dict_albums[name].extend(photo_list)
        else:
            self.dict_albums[name] = photo_list

        self.album_viewer.clear()
        for i in self.dict_albums:
            item = QListWidgetItem()
            item.setText(i)
            item.setIcon(QIcon('image/photo.png'))
            item.setSizeHint(QSize(128, 128))
            self.album_viewer.addItem(item)
            item.setTextAlignment(Qt.AlignCenter)

    def update_album_list(self):
        self.album_viewer.clear()
        for i in self.dict_albums:
            item = QListWidgetItem()
            item.setText(i)
            item.setIcon(QIcon('image/photo.png'))
            item.setSizeHint(QSize(128, 128))
            self.album_viewer.addItem(item)
            item.setTextAlignment(Qt.AlignCenter)

    def add_album_widget(self):
        self.add_album_w.show()

    def resizeEvent(self, e):
        cor = e.size()
        self.btn_cluster.move(self.tabs.width() - 165, 0)
        self.search_btn.move(self.tabs.width() - 130, 0)
        self.add_album.move(self.tabs.width() - 25, 0)
        self.edit_album.move(self.tabs.width() - 60, 0)
        self.del_album.move(self.tabs.width() - 95, 0)
        self.tabs.resize(abs(cor.width() - self.tabs.width()),
                         abs(cor.height() - self.tabs.height()))

    def on_clicked_album(self, item):
        self.cur_item = item.text()
        text_item = item.text()
        self.parent.on_clicked_album(self.dict_albums[text_item])
コード例 #3
0
class optionWindow(QDialog):
    widgets = []

    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowModality(Qt.ApplicationModal)
        screen_resolution = app.desktop().screenGeometry()
        self.title = config.NAME + " " + config.VER + " Instance Configuration"
        self.setWindowIcon(QIcon(config.ICON))
        self.left = screen_resolution.width() / 2 - 290
        self.top = screen_resolution.height() / 2 - 170
        self.initUI()

    def initUI(self):
        self.setWindowTitle(self.title)
        self.setGeometry(self.left, self.top, 580, 340)
        self.setFixedSize(self.size())
        self.createTabs()
        self.createInstallTab()
        self.createConfigTab()
        self.createModsTab()
        self.createSavesTab()

    def createTabs(self):
        for widget in self.widgets:
            try:
                widget.deleteLater()
            except:
                pass
        self.widgets = []
        self.tab = QTabWidget(self)
        self.tab.move(1, 0)
        self.tab.resize(self.size())
        self.tab.resize(self.tab.width(), self.tab.height()-20)
        self.modsContainer = QVBoxLayout(self)
        self.savesContainer = QVBoxLayout(self)
        self.installTab = QWidget()
        self.savesTab = QWidget()
        self.configTab = QWidget()
        self.modsTab = QWidget()
        self.tab.addTab(self.configTab, "Config")
        self.tab.addTab(self.modsTab, "Mods")
        self.tab.addTab(self.savesTab, "Saves")
        self.tab.addTab(self.installTab, "Install")
        self.modsTab.setLayout(self.modsContainer)
        self.savesTab.setLayout(self.savesContainer)

        scroll = QScrollArea(self)
        self.modsContainer.addWidget(scroll)
        scroll.setWidgetResizable(True)
        scrollContent = QWidget(scroll)
        self.modsLayout = QVBoxLayout(scrollContent)
        scrollContent.setLayout(self.modsLayout)
        scroll.setWidget(scrollContent)

        scroll = QScrollArea(self)
        self.savesContainer.addWidget(scroll)
        scroll.setWidgetResizable(True)
        scrollContent = QWidget(scroll)
        self.savesLayout = QVBoxLayout(scrollContent)
        scrollContent.setLayout(self.savesLayout)
        scroll.setWidget(scrollContent)

    def createInstallTab(self):
        self.installModButton = QPushButton("Add Local Mod to Jar", self.installTab)
        self.installModButton.resize(150, 22)
        self.installModButton.move(5, 5)
        self.installModButton.clicked.connect(lambda: utils.addToJar(mainWin.currentInstance, self.modZipDir.text()))

        self.modZipDir = QLineEdit(self.installTab)
        self.modZipDir.setPlaceholderText("Paste the path to your mod ZIP file here!")
        self.modZipDir.resize(390, 22)
        self.modZipDir.move(155, 5)

        self.getDirButton = QPushButton("...", self.installTab)
        self.getDirButton.resize(24, 22)
        self.getDirButton.move(545, 5)
        self.getDirButton.clicked.connect(self.getDir)

    def createSavesTab(self):
        messageLabel = QLabel("Save management comming soon(tm)!", self.savesTab)
        messageLabel.move(185, 120)
        messageLabel.resize(255, messageLabel.height())

    def createModsTab(self):
        messageLabel = QLabel("Mod management comming soon(tm)!", self.modsTab)
        messageLabel.move(185, 120)
        messageLabel.resize(255, messageLabel.height())

    # Same drill. Creates things.
    def createConfigTab(self):
        global launcherConfig
        # Inputs
        self.javaArgs = QLineEdit(self.configTab, text=mainWin.instanceConfig["javaargs"])
        self.javaArgs.resize(310, 24)
        self.javaArgs.move(150, 20)

        self.maxRamAllocation = QLineEdit(self.configTab, text=mainWin.instanceConfig["maxram"])
        self.maxRamAllocation.resize(100, 24)
        self.maxRamAllocation.move(205, 48)

        self.minRamAllocation = QLineEdit(self.configTab, text=mainWin.instanceConfig["minram"])
        self.minRamAllocation.resize(100, 24)
        self.minRamAllocation.move(360, 48)

        self.enableAutoProxySkin = QCheckBox(self.configTab)
        self.enableAutoProxySkin.setChecked(mainWin.instanceConfig["proxyskin"])
        self.enableAutoProxySkin.move(150, 81)

        self.enableAutoProxySound = QCheckBox(self.configTab)
        self.enableAutoProxySound.setChecked(mainWin.instanceConfig["proxysound"])
        self.enableAutoProxySound.move(150, 109)

        self.enableAutoProxyCape = QCheckBox(self.configTab)
        self.enableAutoProxyCape.setChecked(mainWin.instanceConfig["proxycape"])
        self.enableAutoProxyCape.move(150, 137)

        self.javaLoc = QLineEdit(self.configTab, text=mainWin.instanceConfig["javaargs"])
        self.javaLoc.resize(310, 24)
        self.javaLoc.move(150, 160)

        try:
            mainWin.instanceConfig["javaloc"]
        except:
            mainWin.instanceConfig["javaloc"] = ""
        self.javaLoc = QLineEdit(self.configTab, text=mainWin.instanceConfig["javaloc"])
        self.javaLoc.resize(310, 24)
        self.javaLoc.move(150, 160)

        self.getJavDirButton = QPushButton("...", self.configTab)
        self.getJavDirButton.resize(24, 22)
        self.getJavDirButton.move(465, 160)
        self.getJavDirButton.clicked.connect(self.getJavDir)

        # Labelz
        self.javaArgsLabel = QLabel(self.configTab, text="Java arguments:")
        self.javaArgsLabel.resize(100, 20)
        self.javaArgsLabel.move(20, 22)

        self.ramAllocationLabel = QLabel(self.configTab, text="RAM Allocation:")
        self.ramAllocationLabel.resize(100, 20)
        self.ramAllocationLabel.move(20, 50)

        self.maxRamAllocationLabel = QLabel(self.configTab, text="Maximum:")
        self.maxRamAllocationLabel.move(150, 50)
        self.maxRamAllocationLabel.resize(100, 20)

        self.minRamAllocationLabel = QLabel(self.configTab, text="Minimum:")
        self.minRamAllocationLabel.move(310, 50)
        self.minRamAllocationLabel.resize(100, 20)

        self.enableAutoProxySkinLabel = QLabel(self.configTab, text="Enable skin proxy:")
        self.enableAutoProxySkinLabel.resize(100, 20)
        self.enableAutoProxySkinLabel.move(20, 76)

        self.enableAutoProxySoundLabel = QLabel(self.configTab, text="Enable sound proxy:")
        self.enableAutoProxySoundLabel.resize(100, 20)
        self.enableAutoProxySoundLabel.move(20, 104)

        self.enableAutoProxyCapeLabel = QLabel(self.configTab, text="Enable cape proxy:")
        self.enableAutoProxyCapeLabel.resize(100, 20)
        self.enableAutoProxyCapeLabel.move(20, 132)

        self.enableAutoProxySkinLabel2 = QLabel(self.configTab, text="(Breaks sounds if skinfix is installed!)")
        self.enableAutoProxySkinLabel2.resize(250, 20)
        self.enableAutoProxySkinLabel2.move(170, 76)

        self.enableAutoProxySoundLabel2 = QLabel(self.configTab, text="(Backup your resources folder if using custom sounds!)")
        self.enableAutoProxySoundLabel2.resize(300, 20)
        self.enableAutoProxySoundLabel2.move(170, 104)

        self.enableAutoProxyCapeLabel2 = QLabel(self.configTab, text="(Breaks sounds if skinfix is installed!)")
        self.enableAutoProxyCapeLabel2.resize(250, 20)
        self.enableAutoProxyCapeLabel2.move(170, 132)

        self.javaArgsLabel = QLabel(self.configTab, text="Java location:")
        self.javaArgsLabel.resize(100, 20)
        self.javaArgsLabel.move(20, 160)

    def getDir(self):
        fileName, _ = QFileDialog.getOpenFileName(self, "Select a Mod ZIP File", os.path.expanduser("~"), "Mod Archive (*.zip;*.jar)")
        if fileName:
            self.modZipDir.setText(fileName)

    def getJavDir(self):
        fileName, _ = QFileDialog.getOpenFileName(self, "Select a JRE", os.path.expanduser("~"), "JRE (*)")
        if fileName:
            self.javaLoc.setText(fileName)


    # Fires when options window is closed.
    def closeEvent(self, event, *args, **kwargs):
        # Saves config to file.
        mainWin.instanceConfig["javaargs"] = self.javaArgs.text()
        mainWin.instanceConfig["minram"] = self.minRamAllocation.text()
        mainWin.instanceConfig["maxram"] = self.maxRamAllocation.text()
        mainWin.instanceConfig["proxyskin"] = self.enableAutoProxySkin.isChecked()
        mainWin.instanceConfig["proxysound"] = self.enableAutoProxySound.isChecked()
        mainWin.instanceConfig["proxycape"] = self.enableAutoProxyCape.isChecked()
        mainWin.instanceConfig["javaloc"] = self.javaLoc.text()
        utils.saveInstanceSettings(mainWin.instanceConfig, mainWin.currentInstance)
コード例 #4
0
	def height ( self ):
		return QTabWidget.height ( self )