I have found a very nice solution here on this site in order to store gui settings in pyqt5: Python PyQt4 functions to save and restore UI widget values?
The solution is saved in the function guisave.
Now I'm trying to implement this to my code.
The idea is to close my gui with the exitAction button. This fires the closeApp function which fires the guisave function.
The guisave function should save now all my pyqt objects.
The problem is that this does not happen. I'm not sure how I need to assign the ui variable in the guisave function.
As you can see I tried to assign the mainwindow class. But this does not work. I'm also not sure if this works at all or if I need to scan all functions separately since the QEditLine are in the tab2UI function.
import sys
from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
import inspect
class mainwindow(QMainWindow):
def __init__(self, parent = None):
super(mainwindow, self).__init__(parent)
self.initUI()
def initUI(self):
exitAction = QAction(QIcon('icon\\exit.png'), 'Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.triggered.connect(qApp.quit)
exitAction.triggered.connect(self.closeApp)
self.toolbar = self.addToolBar('Exit')
self.toolbar.setMovable(False)
self.toolbar.addAction(exitAction)
self.tab_widget = QTabWidget(self) # add tab
self.tab2 = QWidget()
self.tab_widget.addTab(self.tab2, "Tab_2")
self.tab2UI()
self.setCentralWidget(self.tab_widget)
def tab2UI(self):
self.layout = QFormLayout()
self.layout.addRow("Name",QLineEdit())
self.layout.addRow("Address",QLineEdit())
self.tab2.setLayout(self.layout)
def closeApp(self):
guisave()
def guisave():
ui = mainwindow
settings = QSettings('gui.ini', QSettings.IniFormat)
for name, obj in inspect.getmembers(ui):
if isinstance(obj, QComboBox):
name = obj.objectName() # get combobox name
index = obj.currentIndex() # get current index from combobox
text = obj.itemText(index) # get the text for current index
settings.setValue(name, text) # save combobox selection to registry
if isinstance(obj, QLineEdit):
print obj.objectName()
name = obj.objectName()
value = obj.text()
settings.setValue(name, value) # save ui values, so they can be restored next time
print name, value
if isinstance(obj, QCheckBox):
name = obj.objectName()
state = obj.isChecked()
settings.setValue(name, state)
if isinstance(obj, QRadioButton):
name = obj.objectName()
value = obj.isChecked() # get stored value from registry
settings.setValue(name, value)
def main():
app = QApplication(sys.argv)
ex = mainwindow()
ex.setGeometry(100,100,1000,600)
ex.show()
sys.exit(app.exec_())
if __name__ == '__main__':
main()
The solution that I propose is responsible for saving the states of the QWidgets, but for this you must put a name through the property objectName:
objectName : QString
This property holds the name of this object. You can find an object by name (and type) using findChild(). You can
find a set of objects with findChildren().
Access functions:
QString objectName() const
void setObjectName(const QString &name)
So you should put a name, for example:
self.tab_widget.setObjectName("tabWidget")
We can use the QApplication :: allWidgets () function to get all the widgets of the application, and then we get the properties and save them, the process of restoring is the reverse of the previous one.
def restore(settings):
finfo = QFileInfo(settings.fileName())
if finfo.exists() and finfo.isFile():
for w in qApp.allWidgets():
mo = w.metaObject()
if w.objectName() != "":
for i in range(mo.propertyCount()):
name = mo.property(i).name()
val = settings.value("{}/{}".format(w.objectName(), name), w.property(name))
w.setProperty(name, val)
def save(settings):
for w in qApp.allWidgets():
mo = w.metaObject()
if w.objectName() != "":
for i in range(mo.propertyCount()):
name = mo.property(i).name()
settings.setValue("{}/{}".format(w.objectName(), name), w.property(name))
The complete example is found here
Related
I have an application where upon start up the user is presented with a dialog to chose number of 'objects' required. This then generates necessary objects in the main window using a for loop (i.e. object1, object2, etc.). I want to move this selection into the main window so that this can be changed without the need to restart the application. I have no idea how to approach this as I'm not sure how to dynamically create/destroy once the application is running. Here's an example code that generates tabs in a tab widget with some elements in each tab.
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
class SelectionWindow(QDialog):
def __init__(self):
QDialog.__init__(self)
self.settings = QSettings('Example', 'Example')
self.numberOfTabs = QSpinBox(value = self.settings.value('numberOfTabs', type=int, defaultValue = 3), minimum = 1)
self.layout = QFormLayout(self)
self.button = QPushButton(text = 'OK', clicked = self.buttonClicked)
self.layout.addRow('Select number of tabs', self.numberOfTabs)
self.layout.addRow(self.button)
def buttonClicked(self):
self.settings.setValue('numberOfTabs', self.numberOfTabs.value())
self.accept()
class MainWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.settings = QSettings('Example', 'Example')
self.tabs = self.settings.value('numberOfTabs', type = int)
self.tabWidget = QTabWidget()
for i in range(1, self.tabs + 1):
exec(('self.tab{0} = QWidget()').format(i))
exec(("self.tabWidget.addTab(self.tab{0}, 'Tab{0}')").format(i))
exec(('self.lineEdit{0} = QLineEdit()').format(i))
exec(('self.spinBox{0} = QSpinBox()').format(i))
exec(('self.checkBox{0} = QCheckBox()').format(i))
exec(('self.layout{0} = QFormLayout(self.tab{0})').format(i))
exec(("self.layout{0}.addRow('Name', self.lineEdit{0})").format(i))
exec(("self.layout{0}.addRow('Value', self.spinBox{0})").format(i))
exec(("self.layout{0}.addRow('On/Off', self.checkBox{0})").format(i))
self.setCentralWidget(self.tabWidget)
if __name__ == "__main__":
import sys
app = QApplication(sys.argv)
dialog = SelectionWindow()
dialog.show()
if dialog.exec_() == SelectionWindow.Accepted:
mainwindow = MainWindow()
mainwindow.show()
sys.exit(app.exec_())
First of all, you should never use exec for things like these. Besides the security issues of using exec, it also makes your code less readable (and then much harder to debug) and hard to interact with.
A better (and more "elegant") solution is to use a common function to create tabs and, most importantly, setattr.
Also, you shouldn't use QSettings in this way, as it is mostly intended for cross-session persistent data, not to initialize an interface. For that case, you should just override the exec() method of the dialog and initialize the main window with that value as an argument.
And, even if it was the case (but I suggest you to avoid the above approach anyway), remember that to make settings persistent, at least organizationName and applicationName must be set.
class MainWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.settings = QSettings('Example', 'Example')
# this value does not need to be a persistent instance attribute
tabCount = self.settings.value('numberOfTabs', type = int)
# create a main widget for the whole interface
central = QWidget()
mainLayout = QVBoxLayout(central)
tabCountSpin = QSpinBox(minimum=1)
mainLayout.addWidget(tabCountSpin)
tabCountSpin.setValue(tabCount)
tabCountSpin.valueChanged.connect(self.tabCountChanged)
self.tabWidget = QTabWidget()
mainLayout.addWidget(self.tabWidget)
for t in range(tabCount):
self.createTab(t)
self.setCentralWidget(central)
def createTab(self, t):
t += 1
tab = QWidget()
self.tabWidget.addTab(tab, 'Tab{}'.format(t))
layout = QFormLayout(tab)
# create all the widgets
lineEdit = QLineEdit()
spinBox = QSpinBox()
checkBox = QCheckBox()
# add them to the layout
layout.addRow('Name', lineEdit)
layout.addRow('Value', spinBox)
layout.addRow('On/Off', checkBox)
# keeping a "text" reference to the widget is useful, but not for
# everything, as tab can be accessed like this:
# tab = self.tabWidget.widget(index)
# and so its layout:
# tab.layout()
setattr(tab, 'lineEdit{}'.format(t), lineEdit)
setattr(tab, 'spinBox{}'.format(t), spinBox)
setattr(tab, 'checkBox{}'.format(t), checkBox)
def tabCountChanged(self, count):
if count == self.tabWidget.count():
return
elif count < self.tabWidget.count():
while self.tabWidget.count() > count:
# note that I'm not deleting the python reference to each object;
# you should use "del" for both the tab and its children
self.tabWidget.removeTab(count)
else:
for t in range(self.tabWidget.count(), count):
self.createTab(t)
I created a tool using Qt Designer, where it has 3 QLineEdits that is catered for translateX, translateY and translateZ.
For each QLineEdit, I have created a context menu that allows me to set a keyframe for one of the above attribute depending on User's choice.
So instead of writing 3 separate functions that catered to each attribute, I thought of 'recycling' them by using 1 method, but I am having issues with it as I am not very sure if it will be possible since I am using a single QAction.
class MyTool(QtGui.QWidget):
def __init__(self, parent=None):
super(MyTool, self).__init__(parent = parent)
# Read off from convert uic file.
self.ui = Ui_MyWidget()
self.ui.setupUi(self)
# translateX
self.ui.xLineEdit.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.ui.xLineEdit.customContextMenuRequested.connect(self.custom_menu)
# translateY
self.ui.yLineEdit.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.ui.yLineEdit.customContextMenuRequested.connect(self.custom_menu)
# translateZ
self.ui.zLineEdit.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.ui.zLineEdit.customContextMenuRequested.connect(self.custom_menu)
self.popMenu = QtGui.QMenu(self)
set_key_action = QtGui.QAction("Set Key at Current Frame", self)
# I am having issues here..
set_key_action.triggered.connect(self.set_key)
self.popMenu.addAction(set_key_action)
...
...
def set_key(self, attr):
# assuming I am trying to effect this locator1 that already exists in the scene
current_item = "|locator1"
cmds.setKeyframe("{0}.{1}".format(current_item, attr))
def custom_menu(self, point):
self.popMenu.exec_(QtGui.QCursor.pos())
Again, because it is only a single QAction and hence I was stumped... Or will it be better for me to stick in using 3 separate functions instead?
The main problem is that when you connect the triggered signal you do not know that QLineEdit is going to be pressed. Where can we know that QLineEdit was pressed? Well, in the method custom_menu since there the method sender() returns the widget that opens its contextual menu, and to transfer it, a property or data is used, so the fine is to compare the property and the QLineEdit:
class MyTool(QtGui.QWidget):
def __init__(self, parent=None):
super(MyTool, self).__init__(parent=parent)
# Read off from convert uic file.
self.ui = Ui_MyWidget()
self.ui.setupUi(self)
for le in (self.ui.xLineEdit, self.ui.yLineEdit, self.ui.zLineEdit):
le.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
le.customContextMenuRequested.connect(self.custom_menu)
self.popMenu = QtGui.QMenu(self)
self.set_key_action = QtGui.QAction("Set Key at Current Frame", self)
self.set_key_action.triggered.connect(self.set_key)
self.popMenu.addAction(self.set_key_action)
def set_key(self):
le = self.set_key_action.property("lineedit")
# or
# le = self.set_key_action.data()
if le is self.ui.xLineEdit:
print("xLineEdit")
elif le is self.ui.yLineEdit:
print("yLineEdit")
elif le is self.ui.zLineEdit:
print("zLineEdit")
def custom_menu(self, p):
if self.sender() is not None:
self.set_key_action.setProperty("lineedit", self.sender())
# or
# self.set_key_action.setData(self.sender())
self.popMenu.exec_(QtGui.QCursor.pos())
Without debug or source code , i can't figure out what is happen here , because in theory all works , so or i can't understand correctly or have some error in other part of code.
class MyTool(QtGui.QWidget):
def __init__(self, parent=None):
super(MyTool, self).__init__(parent = parent)
# Read off from convert uic file.
self.ui = Ui_MyWidget()
self.ui.setupUi(self)
# translateX
self.ui.xLineEdit.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.ui.xLineEdit.customContextMenuRequested.connect(self.custom_menu)
# translateY
self.ui.yLineEdit.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.ui.yLineEdit.customContextMenuRequested.connect(self.custom_menu)
# translateZ
self.ui.zLineEdit.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.ui.zLineEdit.customContextMenuRequested.connect(self.custom_menu)
self.popMenu = QtGui.QMenu(self)
set_key_action = QtGui.QAction("Set Key at Current Frame", self)
**# Assuming that this phase pass !**
set_key_action.triggered.connect(self.set_key)
self.popMenu.addAction(set_key_action)
...
...
def set_key(self, attr):
**# What happen when you debug this block ?**
current_item = "|locator1"
cmds.setKeyframe("{0}.{1}".format(current_item, attr))
def custom_menu(self, point):
self.popMenu.exec_(QtGui.QCursor.pos())
I'm trying to figure out how I can get the QWidget that I insert into a QListWidget as a QListWidgetItem to be able to access the list it is a part of so that it can do the following:
Increase/decrease it's position in the list
Remove itself from the list
Pass information from it's own class to a function in the main class
My script layout is a main.py which is where the MainWindow class is. The MainWindow uses the class generated from the main ui file. I also have the custom widget which is it's own class.
Example of GUI:
Relevant code snippets:
main.py
from PyQt4.QtGui import QMainWindow, QApplication
from dungeonjournal import Ui_MainWindow
from creature_initiative_object import InitCreatureObject
from os import walk
class MainWindow(QMainWindow, Ui_MainWindow):
def __init__(self, parent=None):
super(QMainWindow, self).__init__(parent)
self.setupUi(self)
etc......
def AddToInitiative(self):
creature = self.comboBoxSelectCharacter.currentText()
if(creature):
creatureInfo = ''
with open("creatures/"+str(creature)+".creature", "r") as f:
creatureInfo = f.read()
creatureInfo = creatureInfo.split("|")
customWidget = InitCreatureObject()
customWidgetItem = QtGui.QListWidgetItem(self.initiativeList)
customWidgetItem.setSizeHint(QtCore.QSize(400,50))
self.initiativeList.addItem(customWidgetItem)
self.initiativeList.setItemWidget(customWidgetItem, customWidget)
customWidget.setName(creatureInfo[0])
return
creature_initiative_object.py
class Ui_InitCreatureObject(object):
def setupUi(self, InitCreatureObject):
etc...
class InitCreatureObject(QtGui.QWidget, Ui_InitCreatureObject):
def __init__(self, parent=None, f=QtCore.Qt.WindowFlags()):
QtGui.QWidget.__init__(self, parent, f)
self.setupUi(self)
Edit 1:
To clarify again, I need to be able to use the buttons in the widget to modify the position of itself in the list. The list is part of the main ui. The buttons for up arrow, down arrow, Select, and Remove are the one's I'm trying to get to interact with things outside of their class.
The function they call needs to be able to determine which listItem is being called, be able to modify the list.
For example, if I click remove, it then needs to know which item in the list to remove. So it needs to first know what the list is, then it needs to know what item it is. I'm not sure how to access the instance of the widget that is occupying that listitem. I also am not sure how to get that listitem based on a button press from inside that listitem's class.
Edit 2:
Per the first answer I tried to work that into my code.
main.py had the following function added
def RemoveItem(self):
cwidget = self.sender().parent()
item = self.initiativeList.itemAt(cwidget.pos())
row = self.initiativeList.row(item)
self.initiativeList.takeItem(row)
print(row)
creature_initiative_object.py had the following added to the InitCreatureObject class
class InitCreatureObject(QtGui.QWidget, Ui_InitCreatureObject):
def __init__(self, parent=None, f=QtCore.Qt.WindowFlags()):
QtGui.QWidget.__init__(self, parent, f)
self.setupUi(self)
self.mainwidget = main.MainWindow()
self.btnRemove.clicked.connect(self.mainwidget.RemoveItem)
Item is still not being passed. The parent object seems to be right but when I get the row it always says -1.
The strategy to get the QTableWidgetItem is to use the itemAt() method but for this you must know the position of some point within the QTableWidgetItem.
Since the main objective is to get the item when a signal is sent, then the connected slot is used, so I recommend connecting all the signals to that slot. Given the above the following steps are taken:
Get the object that emits the signal through sender().
Get the sender parent() since this will be the custom widget that was added to the QListWidget() along with the item.
Get the position of the custom widget through pos(), this is the position that should be used in the itemAt() method.
Then you get the text of the button or some parameter that tells me the task to know what action you want to do.
The above can be implemented as follows:
def someSlot(self):
p = self.sender().parent()
it = self.lw.itemAt(p.pos())
text = self.sender().text()
if text == "task1":
do task1
elif text == "task2":
do task2
From the above, the following example is proposed:
class CustomWidget(QWidget):
def __init__(self, text, parent=None):
QWidget.__init__(self, parent)
self.setLayout(QHBoxLayout())
self.buttons = []
vb = QVBoxLayout()
self.layout().addLayout(vb)
self.btnTask1 = QPushButton("task1")
self.btnTask2 = QPushButton("task2")
vb.addWidget(self.btnTask1)
vb.addWidget(self.btnTask2)
self.buttons.append(self.btnTask1)
self.buttons.append(self.btnTask2)
self.btnTask3 = QPushButton("task3")
self.btnTask4 = QPushButton("task4")
self.btnTask5 = QPushButton("task5")
self.btnTask6 = QPushButton("task6")
self.layout().addWidget(self.btnTask3)
self.layout().addWidget(self.btnTask4)
self.layout().addWidget(self.btnTask5)
self.layout().addWidget(self.btnTask6)
self.buttons.append(self.btnTask3)
self.buttons.append(self.btnTask4)
self.buttons.append(self.btnTask5)
self.buttons.append(self.btnTask6)
class MainWindow(QMainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.lw = QListWidget(self)
self.setCentralWidget(self.lw)
for i in range(5):
cw = CustomWidget("{}".format(i))
for btn in cw.buttons:
btn.clicked.connect(self.onClicked)
item = QListWidgetItem(self.lw)
item.setSizeHint(QSize(400, 80))
self.lw.addItem(item)
self.lw.setItemWidget(item, cw)
def onClicked(self):
p = self.sender().parent()
it = self.lw.itemAt(p.pos())
row = self.lw.row(it)
text = self.sender().text()
print("item {}, row {}, btn: {}".format(it, row, text))
#if text == "task1":
# do task1
#elif text == "task2":
# do task2
if __name__ == '__main__':
app = QApplication(sys.argv)
w = MainWindow()
w.show()
sys.exit(app.exec_())
In your Case:
class MainWindow(QMainWindow, Ui_MainWindow):
[...]
def AddToInitiative(self):
[...]
customWidget = InitCreatureObject()
customWidget.btnRemove.clicked.connect(self.RemoveItem)
# ^^^^^
[...]
def RemoveItem(self):
cwidget = self.sender().parent()
item = self.initiativeList.itemAt(cwidget.pos())
row = self.initiativeList.row(item)
self.initiativeList.takeItem(row)
print(row)
I have been trying to create a settings window for an application I'm developing and I want to populate the settings window with either a config file (which I will later write the answers to) or the system defaults if the config file is absent or cannot be opened.
I have seen examples where a few values are populated after the setupUi(self) is executed, however I have around 15-20 values and so having 2 huge if statements seems messy. Here is my current state of affairs and I can't figure out how to make it call the function I have created getConfig
Is this the best way to populate values? Or is there something else I should try?
class SettingsWindow(QtGui.QMainWindow):
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.ui = Ui_SettingsWindow()
self.ui.setupUi(self)
self.ui.getConfig(self) #my problem is here
... #all the action bindings
def getConfig(self):
if not os.path.exists('app.config'):
self.ui.setDefaults(self) #fallback to defaults if no config file
with open('app.config') as f:
self.config = json.load(f)
... #bind all the default values
Here is an example using a dictionary to store the widgets - see my comment.
Only one EditLine updated but principal is there (Note the label could also be updated in the same way.
from PyQt4 import QtGui, QtCore
class MyWindow(QtGui.QWidget): # any super class is okay
def __init__(self, parent=None):
super(MyWindow, self).__init__(parent)
self.settings = {}
var_label = QtGui.QLabel('Path')
self.settings['path'] = QtGui.QLineEdit(width=200)
quitbutton = QtGui.QPushButton('Quit')
loadbutton = QtGui.QPushButton('Load Settings')
savebutton = QtGui.QPushButton('Save Settings')
layout1 = QtGui.QHBoxLayout()
layout1.addWidget(var_label)
layout1.addWidget(self.settings['path'])
layout2 = QtGui.QHBoxLayout()
layout2.addWidget(loadbutton)
layout2.addWidget(savebutton)
layout2.addWidget(quitbutton)
layout = QtGui.QVBoxLayout()
layout.addLayout(layout1)
layout.addLayout(layout2)
self.setLayout(layout)
loadbutton.clicked.connect(self.get_config)
savebutton.clicked.connect(self.save_settings)
quitbutton.clicked.connect(QtGui.qApp.quit)
self.get_config()
def get_config(self):
# Read config file here into dictionary
# Example
config_data = {'path':'data path here'} # Example dictionary created when reading config file
for key in config_data:
self.settings[key].setText(config_data[key])
def save_settings(self): # Link to button
data = {}
for key in self.settings:
data[key] = self.settings[key].text()
# Save to config file here
print (data)
if __name__ == '__main__':
app = QtGui.QApplication([])
window = MyWindow()
window.show()
app.exec_()
If the widgets you use are not set by setText() or retrieved by text() then the code is a little more complex, various ways of doing that for TextEdit, Lists, Combo etc. can be incorporated.
I broke my question down to a very basic setup. Each tab allows a user to click a button and append and item to the list. At the same time the item is added to the list, it's also added to a global variable called ALLITEMs. Each tab is given it's over dictionary to append to as seen here..
ALLITEMS = {
"A" : [],
"B" : []
}
In the main widget on the 'closeEvent' i save this variable to a json file. Also in the main widgets 'showEvent' i load this data back into the global bariable ALLITEMS. This allows users to retain the data each time the launch the application. What I'm not sure about is how to refresh the tab widgets to repopulate the GUI's with the data from the variable. But only when the tool is initially launched. I don't want it to load each time the user clicks that tab, that would produce duplicate data.
import sys
import json
import os
from PySide import QtGui, QtCore
ALLITEMS = {
"A" : [],
"B" : []
}
# Widgets
# ------------------------------------------------------------------------------
class ExampleA(QtGui.QWidget):
def __init__(self):
super(ExampleA, self).__init__()
self.initUI()
def initUI(self):
# formatting
self.resize(550, 400)
self.setWindowTitle("Tab A")
# widgets
self.ui_listview = QtGui.QListWidget()
self.ui_add = QtGui.QPushButton("Add Item")
# signals
self.ui_add.clicked.connect(self.add_item_clicked)
# main layout
main_layout = QtGui.QVBoxLayout()
main_layout.addWidget(self.ui_add)
main_layout.addWidget(self.ui_listview)
main_layout.setContentsMargins(0,0,0,0)
self.setLayout(main_layout)
def add_item_clicked(self):
global ALLITEMS
item = "Another item A"
ALLITEMS["A"].append(item)
self.ui_listview.addItem( item )
class ExampleB(QtGui.QWidget):
def __init__(self):
super(ExampleB, self).__init__()
self.initUI()
def initUI(self):
# formatting
self.resize(550, 400)
self.setWindowTitle("Tab A")
# widgets
self.ui_listview = QtGui.QListWidget()
self.ui_add = QtGui.QPushButton("Add Item")
# signals
self.ui_add.clicked.connect(self.add_item_clicked)
# main layout
main_layout = QtGui.QVBoxLayout()
main_layout.addWidget(self.ui_add)
main_layout.addWidget(self.ui_listview)
main_layout.setContentsMargins(0,0,0,0)
self.setLayout(main_layout)
def add_item_clicked(self):
global ALLITEMS
item = "Another item B"
ALLITEMS["B"].append(item)
self.ui_listview.addItem( item )
class ExampleMain(QtGui.QWidget):
def __init__(self):
super(ExampleMain, self).__init__()
self.initUI()
def initUI(self):
# formatting
self.resize(200, 200)
self.setWindowTitle("Test")
# widgets
tab_panel = QtGui.QTabWidget()
tab_panel.addTab(ExampleA(), "Tab A")
tab_panel.addTab(ExampleB(), "Tab B")
# main layout
main_layout = QtGui.QVBoxLayout()
main_layout.addWidget(tab_panel)
main_layout.setContentsMargins(0,0,0,0)
self.setLayout(main_layout)
def closeEvent(self, event):
self.save_data()
def showEvent(self, event):
self.load_data()
def save_data(self):
print "Saving..."
global ALLITEMS
json.dump(ALLITEMS, open("Example_Data.json",'w'), indent=4)
def load_data(self):
global ALLITEMS
if os.path.exists( "Example_Data.json" ):
with open( "Example_Data.json" ) as f:
data = json.load(f)
ALLITEMS = data
# Main
# ------------------------------------------------------------------------------
if __name__ == '__main__':
app = QtGui.QApplication(sys.argv)
ex = ExampleMain()
ex.show()
sys.exit(app.exec_())
The simpliest (although not very effective) way would be to update list widget from ALLITEMS dictionary each time you change it. So on every button press you could update ALLITEMS first, then clear the content of list widget and refill it according to new value of ALLITEMS["TabName"]. Then on show event you could do the same - load ALLITEMS from file once and then update list widget.
For more effective approach take a look at Qt Model/View programming (http://doc.qt.io/qt-5/model-view-programming.html) You will probably need to replace QListWidget with QListView
I would remove the global variable entirely.
In your closeEvent, instead of saving the global variable, read the items from the listview directly and save them. In your add_item method, don't modify the global variable at all.
Then in your load_data function, read the data from the file and add the items to the listviews.
You will need to store references to the ex.ample widgets
self.example_a = ExampleA()
self.example_b = ExampleB()
tab_panel.addTab(self.example_a), "Tab A")
tab_panel.addTab(self.example_b), "Tab B")
Here's how you could save and load the data:
def save_data(self):
print "Saving..."
all_items = {}
for i in range(self.example_a.ui_listview.count()):
text = self.example_a.ui_listview.item(i).text()
all_items.set_default('A', []).append(text)
for i in range(self.example_b.ui_listview.count()):
text = self.example_b.ui_listview.item(i).text()
all_items.set_default('B', []).append(text)
json.dump(all_items, open("Example_Data.json",'w'), indent=4)
def load_data(self):
if os.path.exists( "Example_Data.json" ):
with open( "Example_Data.json" ) as f:
all_items = json.load(f)
for text in all_items.get('A', []):
self.example_a.ui_listview.addItem(text)
for text in all_items.get('B', []):
self.example_b.ui_listview.addItem(text)
Also, in general, it's usually bad design for a parent widget to access grandchild widgets directly (ui_listview is a grandchild of your main widget ExampleMain class). It's generally better form for your widgets to define some type of interface for portraying what they need saved and loaded.
class ExampleMain:
def save_data(self):
data = {}
data['example_a'] = self.example_a.save_data()
data['example_b'] = self.example_b.save_data()
# Save to file
def load_data(self):
data = ... # read from file
self.example_a.load_data(data.get('example_a'))
self.example_b.load_data(data.get('example_b'))
class ExampleA:
def save_data(self):
data = []
for i in range(self.ui_listview.count()):
text = self.ui_listview.item(i).text()
data.append(text)
return data
def load_data(self, data):
for text in data:
self.ui_listview.addItem(text)