We Keep Coding

PyQt4 - QLineEdit() and QCheckbox()

I am building a GUI for obtaining user inputs and then using them in some complex step later. I have a group of checkboxes from which the user has to choose at least one and also provide an 'alias' name for it in the QLineEdit right below the checkbox (default name is taken otherwise).
Currently, I have to first enter the alias name and then check the checkbox to register the entered name in the line edit to get the value entered by the user and connected checkbox name. This order is not normal.
Is there a way to get the Editline data and the connected checkbox name when 'Continue' is clicked?
Here is my code:
from PyQt4 import QtGui, QtCore
import sys
checkpoint_list = ['Amsterdam','Munich','Paris','Mumbai']
class MyGui(QtGui.QWidget):
def __init__(self):
super(MyGui, self).__init__()
self.initUI()
self.final_list = []
self.platform_list = {}
self.qem = None
def initUI(self):
lay_out = QtGui.QVBoxLayout(self)
# select the CPs
cp_lbl = QtGui.QLabel("Please select CP versions to compare:", self)
lay_out.addWidget(cp_lbl)
self.cb = []
self.platform_label = []
i = 0
for cp in checkpoint_list:
self.cb.append(QtGui.QCheckBox(cp, self))
self.platform_label.append(QtGui.QLineEdit(cp, self))
self.cb[i].stateChanged.connect(self.clickBoxStateChanged)
lay_out.addWidget(self.cb[i])
lay_out.addWidget(self.platform_label[i])
i += 1
lay_out.addStretch(10)
# Continue and cancel button
btn_cancel = QtGui.QPushButton('Cancel', self)
btn_continue = QtGui.QPushButton('Continue', self)
hbox = QtGui.QHBoxLayout()
hbox.addStretch()
hbox.addWidget(btn_continue)
hbox.addWidget(btn_cancel)
vbox = QtGui.QVBoxLayout()
vbox.addStretch()
lay_out.addLayout(hbox)
lay_out.addLayout(vbox)
self.setLayout(lay_out)
btn_cancel.clicked.connect(self.onclick_cancel)
btn_cancel.setToolTip('To <b>Cancel</b> with this process')
btn_continue.clicked.connect(self.onclick_Continue)
btn_continue.setToolTip('To <b>Continue</b> with the matching')
# Screen show
self.setGeometry(300, 300, 500, 400)
self.setWindowTitle('CP Selection Window')
self.show()
def clickBoxStateChanged(self, cb):
self.final_list = []
self.platform_list = {}
for i in range(len(self.cb)):
if self.cb[i].isChecked():
if self.cb[i] not in self.final_list:
self.final_list.append(str(self.cb[i].text()))
self.platform_list[str(self.cb[i].text())] = str(self.platform_label[i].text())
print self.final_list
print self.platform_list
elif self.cb[i].isChecked() == False:
if self.cb[i].text() in self.final_list:
self.final_list.remove(str(self.cb[i].text()))
del self.platform_list[str(self.cb[i].text())]
print self.final_list
print self.platform_list
def onclick_Continue(self):
try:
if len(self.final_list) == 0:
self.qem = QtGui.QErrorMessage(self)
self.qem.showMessage("Please select at least 1 checkpoint to continue...")
else:
self.close()
except:
print "No CP was selected..."
def onclick_cancel(self):
sys.exit()
if __name__ == "__main__":
# GUI code
app = QtGui.QApplication(sys.argv)
w = MyGui()
app.exec_()

The simplest solution is to create a method that analyzes the information and that returns a dictionary of the selected elements:
class MyGui(QtGui.QWidget):
def __init__(self):
super(MyGui, self).__init__()
self.initUI()
def initUI(self):
lay_out = QtGui.QVBoxLayout(self)
# select the CPs
cp_lbl = QtGui.QLabel("Please select CP versions to compare:")
lay_out.addWidget(cp_lbl)
self.cb = []
self.platform_label = []
for cp in checkpoint_list:
cb = QtGui.QCheckBox(cp)
le = QtGui.QLineEdit(cp)
lay_out.addWidget(cb)
lay_out.addWidget(le)
self.cb.append(cb)
self.platform_label.append(le)
lay_out.addStretch(10)
# Continue and cancel button
btn_cancel = QtGui.QPushButton("Cancel")
btn_continue = QtGui.QPushButton("Continue")
hbox = QtGui.QHBoxLayout()
hbox.addStretch()
hbox.addWidget(btn_continue)
hbox.addWidget(btn_cancel)
vbox = QtGui.QVBoxLayout()
vbox.addStretch()
lay_out.addLayout(hbox)
lay_out.addLayout(vbox)
btn_cancel.clicked.connect(self.onclick_cancel)
btn_cancel.setToolTip("To <b>Cancel</b> with this process")
btn_continue.clicked.connect(self.onclick_Continue)
btn_continue.setToolTip("To <b>Continue</b> with the matching")
# Screen show
self.setGeometry(300, 300, 500, 400)
self.setWindowTitle("CP Selection Window")
self.show()
def get_elements_selected(self):
values_selected = dict()
for cb, le in zip(self.cb, self.platform_label):
if cb.isChecked():
values_selected[cb.text()] = le.text()
return values_selected
def onclick_Continue(self):
values = self.get_elements_selected()
if values:
print(values)
self.close()
else:
qem = QtGui.QErrorMessage(self)
qem.showMessage("Please select at least 1 checkpoint to continue...")
qem.exec_()
def onclick_cancel(self):
sys.exit()

Position internal widget inside QStackedWidget object

I have several tabs and inside the "admin" tab I want to display two pages: one locked page (before entering credentials) and another unlocked page (after successful login). To do this, I'm using a QStackedWidget() to switch between the two pages. I have created a locked login screen but can't seem to move the object to the center of the page.
I have looked at moving widgets inside QStackedWidget and centering widgets in the center of the screen but my objects do not seem to change position. I've tried to move the entire internal widget using move() to the center of the screen using the desktop dimension and the parent widget to no avail. How would I be able to move the login fields to the center of the page? Thanks!
Current:
Desired:
Code:
from PyQt4 import QtGui, QtCore
# from load_CSS import load_CSS
# from widgets import UniversalPlotWidget
import sys
import time
def exit_application():
"""Exit program event handler"""
sys.exit(1)
class VerticalTabBar(QtGui.QTabBar):
def __init__(self, width, height, parent=None):
super(VerticalTabBar, self).__init__(parent)
self.width = width
self.height = height
def tabSizeHint(self, index):
return QtCore.QSize(self.width, self.height)
def paintEvent(self, event):
painter = QtGui.QStylePainter(self)
tab_options = QtGui.QStyleOptionTab()
for tab in range(self.count()):
self.initStyleOption(tab_options, tab)
painter.drawControl(QtGui.QStyle.CE_TabBarTabShape, tab_options)
painter.save()
size = tab_options.rect.size()
size.transpose()
rectangle = QtCore.QRect(QtCore.QPoint(), size)
rectangle.moveCenter(tab_options.rect.center())
tab_options.rect = rectangle
center = self.tabRect(tab).center()
painter.translate(center)
painter.rotate(90)
painter.translate(-center)
painter.drawControl(QtGui.QStyle.CE_TabBarTabLabel, tab_options);
painter.restore()
class TabWidget(QtGui.QTabWidget):
def __init__(self, *args, **kwargs):
QtGui.QTabWidget.__init__(self, *args, **kwargs)
self.setTabBar(VerticalTabBar(kwargs.pop('width'), kwargs.pop('height')))
self.setTabPosition(QtGui.QTabWidget.West)
self.setTabShape(QtGui.QTabWidget.Rounded)
class AdminTabWidget(QtGui.QWidget):
def __init__(self, parent=None):
super(AdminTabWidget, self).__init__(parent)
self.setWindowModality(QtCore.Qt.ApplicationModal)
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.admin_page_locked_init()
self.admin_page_unlocked_init()
self.admin_page_layout = QtGui.QGridLayout()
self.admin_page_switch = QtGui.QStackedWidget()
self.admin_page_switch.addWidget(self.admin_locked_tab)
self.admin_page_switch.addWidget(self.admin_unlocked_tab)
self.admin_page_switch.setCurrentIndex(0)
self.admin_page_layout.addWidget(self.admin_page_switch,0,0)
def admin_page_locked_init(self):
self.admin_locked_tab = QtGui.QWidget()
self.admin_locked_tab.setFixedSize(550,225)
self.admin_locked_layout = QtGui.QGridLayout()
self.username_label = QtGui.QLabel('Username: ')
self.username_field = QtGui.QLineEdit()
self.username_field.returnPressed.connect(self.verify_credentials)
self.space_label = QtGui.QLabel(' ')
self.space_label.setFixedHeight(25)
self.password_label = QtGui.QLabel('Password: ')
self.password_field = QtGui.QLineEdit()
self.password_field.returnPressed.connect(self.verify_credentials)
self.password_field.setEchoMode(QtGui.QLineEdit.Password)
self.verify_button = QtGui.QPushButton('Ok')
self.verify_button.clicked.connect(self.verify_credentials)
self.cancel_button = QtGui.QPushButton('Cancel')
self.cancel_button.clicked.connect(self.unauthorized)
self.status_label = QtGui.QLabel('')
self.status_label.setAlignment(QtCore.Qt.AlignCenter)
self.button_layout = QtGui.QGridLayout()
self.button_layout.addWidget(self.verify_button,0,0,1,1)
self.button_layout.addWidget(self.cancel_button,0,1,1,1)
self.admin_locked_layout.addWidget(self.username_label,0,0,1,1)
self.admin_locked_layout.addWidget(self.username_field,0,1,1,1)
self.admin_locked_layout.addWidget(self.space_label,1,0,1,3)
self.admin_locked_layout.addWidget(self.password_label,2,0,1,1)
self.admin_locked_layout.addWidget(self.password_field,2,1,1,1)
self.admin_locked_layout.addWidget(self.status_label,3,0,1,3)
self.admin_locked_layout.addLayout(self.button_layout,4,0,1,3)
self.admin_locked_tab.setLayout(self.admin_locked_layout)
def verify_credentials(self):
print('button pressed')
# Grab username/password from input fields
self.username = str(self.username_field.text())
self.password = str(self.password_field.text())
self.status_label.setText('Verifying')
self.status_label.setStyleSheet('QLabel {color: rgb(117,255,161)}')
self.spin(.001)
print('verified')
def spin(self, seconds):
"""Pause for set amount of seconds, replaces time.sleep so program doesnt stall"""
time_end = time.time() + seconds
while time.time() < time_end:
QtGui.QApplication.processEvents()
def unauthorized(self):
print('unauthorized')
self.status_label.setText('Invalid username and/or password')
self.status_label.setStyleSheet('QLabel {color: rgb(255,65,106)}')
def admin_page_unlocked_init(self):
self.admin_unlocked_tab = QtGui.QWidget()
admin_unlocked_layout = QtGui.QGridLayout()
admin_unlocked_button = QtGui.QPushButton('unlocked')
admin_unlocked_layout.addWidget(admin_unlocked_button)
self.admin_unlocked_tab.setLayout(admin_unlocked_layout)
def get_admin_page_layout(self):
return self.admin_page_layout
if __name__ == '__main__':
# Create main application window
app = QtGui.QApplication(sys.argv)
# app.setStyleSheet(load_CSS(1))
app.setStyle(QtGui.QStyleFactory.create("Cleanlooks"))
font = QtGui.QFont('Ubuntu', 20)
font.setWeight(70)
app.setFont(font)
screen_height = QtGui.QApplication.desktop().screenGeometry().height()
main_window_tab = TabWidget(width=300, height=screen_height/8)
main_window_tab.setWindowTitle("Tab Layout")
main_window_tab.setWindowFlags(QtCore.Qt.FramelessWindowHint)
main_window_tab.showMaximized()
tab1 = QtGui.QWidget()
tab2 = QtGui.QWidget()
tab3 = QtGui.QWidget()
tab4 = QtGui.QWidget()
tab5 = QtGui.QWidget()
tab6 = QtGui.QWidget()
tab7 = QtGui.QWidget()
admin_tab = QtGui.QWidget()
admin_tab_widget = AdminTabWidget()
admin_tab.setLayout(admin_tab_widget.get_admin_page_layout())
main_window_tab.addTab(admin_tab, "Admin")
main_window_tab.addTab(tab1, "tab1")
main_window_tab.addTab(tab2, "tab2")
main_window_tab.addTab(tab3, "tab3")
main_window_tab.addTab(tab4, "tab4")
main_window_tab.addTab(tab5, "tab5")
main_window_tab.addTab(tab6, "tab6")
main_window_tab.addTab(tab7, "tab7")
main_window_tab.show()
QtGui.QShortcut(QtGui.QKeySequence('Ctrl+Q'), main_window_tab, exit_application)
sys.exit(app.exec_())

The idea is to set the QStackedWidget with the Qt::AlignCenter alignment in the layout so it changes:
self.admin_page_layout.addWidget(self.admin_page_switch, 0, 0)
to:
self.admin_page_layout.addWidget(self.admin_page_switch, 0, 0, alignment=QtCore.Qt.AlignCenter)

QlineEdit and signal & slot

I have created a widget with QLineEdit and QLabel, I want to get input from QlineEdit and display it with QLabel. I have used Signal and Slot connection, I do not know what I do wrong, but it is not working correctly. I would like to get both values from QLineEdit and later show it.
Current window
what I want?
Code:
import os
import sys
from PyQt5 import QtCore, QtGui, QtWidgets
class WinDialog(QtWidgets.QDialog):
currenttextedited = QtCore.pyqtSignal(int)
def __init__(self, parent=None):
super(WinDialog, self).__init__(parent)
self.setGeometry(300,300,350,300)
self.setWindowTitle("Signal & Slot")
self.propertyWidget = PropertyWidget()
section_lay = QtWidgets.QHBoxLayout()
section_label = QtWidgets.QLabel("Name: ")
section_edit = QtWidgets.QLineEdit('')
length_lay = QtWidgets.QHBoxLayout()
length_label = QtWidgets.QLabel("Input a number: L = ")
self.length_edit = QtWidgets.QLineEdit('1000')
self.length_edit.setInputMask("999999")
self.length_edit.setFocus(True)
thick_lay = QtWidgets.QHBoxLayout()
thick_label = QtWidgets.QLabel("Input a text: T = ")
thick_edit = QtWidgets.QLineEdit('')
section_lay.addWidget(section_label)
section_lay.addWidget(section_edit)
length_lay.addWidget(length_label)
length_lay.addWidget(self.length_edit)
length_lay.addStretch()
thick_lay.addWidget(thick_label)
thick_lay.addWidget(thick_edit)
thick_lay.addStretch()
VB_lay = QtWidgets.QVBoxLayout()
VB_lay.addStretch()
VB_lay.addLayout(length_lay)
VB_lay.addLayout(thick_lay)
VB_lay.addStretch()
buttonBox = QtWidgets.QDialogButtonBox()
buttonBox.setStandardButtons(QtWidgets.QDialogButtonBox.Cancel
|QtWidgets.QDialogButtonBox.Ok)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
grid = QtWidgets.QGridLayout(self)
grid.addLayout(section_lay, 0, 0, 1, 2)
grid.addLayout(VB_lay, 1, 0)
grid.addWidget(self.propertyWidget, 2, 0)
grid.addWidget(buttonBox, 3, 0, 1, 2)
self.length_edit.textEdited.connect(self.textchanged)
def textchanged(self, text):
print(text)
self.currenttextedited.emit(text)
class PropertyWidget(QtWidgets.QWidget):
def __init__(self, parent=None):
super(PropertyWidget, self).__init__(parent)
HB_lay = QtWidgets.QHBoxLayout(self)
self.Displaylabel = QtWidgets.QLabel('')
HB_lay.addWidget(self.Displaylabel)
HB_lay.addStretch()
#QtCore.pyqtSlot(int)
def Display(self, text):
try:
L_Display = int(text)
T_Display = int(text)
fmt = "L = {}mm\nT = {}mm"
self.Displaylabel.setText(fmt.format(L_Display, T_Display))
except ValueError:
print("Error")
if __name__ == '__main__':
app = QtWidgets.QApplication(sys.argv)
w = WinDialog()
w.show()
sys.exit(app.exec_())

according to samples in the image you want to show different texts but you are converting the same number to whole: L_Display = int(text) and T_Display = int(text) so how do you expect to show 2 different texts?, obviously the function display needs 2 entries (2 different entries to self plus I have changed to lowercase since it is recommended that the functions have a lowercase name).
Now the logic is as follows: if any of the texts of length_edit or thick_edit changes then you must call display() passing the new texts. So the solution is to use a slot that connects to the textEdited signals of both QLineEdits and in it obtain the text and pass the texts.
Finally I see that you want the QLineEdits receive only numbers so one option is to use a QIntValidator so that only numbers are acceptable (another better option is to use QSpinBox instead of QLineEdit)
import sys
from PyQt5 import QtCore, QtGui, QtWidgets
class WinDialog(QtWidgets.QDialog):
def __init__(self, parent=None):
super(WinDialog, self).__init__(parent)
self.setGeometry(300,300,350,300)
self.setWindowTitle("Signal & Slot")
self.propertyWidget = PropertyWidget()
section_lay = QtWidgets.QHBoxLayout()
section_label = QtWidgets.QLabel("Name: ")
section_edit = QtWidgets.QLineEdit('')
length_lay = QtWidgets.QHBoxLayout()
length_label = QtWidgets.QLabel("Input a number: L = ")
self.length_edit = QtWidgets.QLineEdit()
self.length_edit.setFocus(True)
val_lenght = QtGui.QIntValidator(0, 100000, self.length_edit)
self.length_edit.setValidator(val_lenght)
thick_lay = QtWidgets.QHBoxLayout()
thick_label = QtWidgets.QLabel("Input a text: T = ")
self.thick_edit = QtWidgets.QLineEdit()
val_thick = QtGui.QIntValidator(0, 100000, self.thick_edit)
self.thick_edit.setValidator(val_thick)
section_lay.addWidget(section_label)
section_lay.addWidget(section_edit)
length_lay.addWidget(length_label)
length_lay.addWidget(self.length_edit)
length_lay.addStretch()
thick_lay.addWidget(thick_label)
thick_lay.addWidget(self.thick_edit)
thick_lay.addStretch()
VB_lay = QtWidgets.QVBoxLayout()
VB_lay.addStretch()
VB_lay.addLayout(length_lay)
VB_lay.addLayout(thick_lay)
VB_lay.addStretch()
buttonBox = QtWidgets.QDialogButtonBox()
buttonBox.setStandardButtons(QtWidgets.QDialogButtonBox.Cancel
| QtWidgets.QDialogButtonBox.Ok)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
grid = QtWidgets.QGridLayout(self)
grid.addLayout(section_lay, 0, 0, 1, 2)
grid.addLayout(VB_lay, 1, 0)
grid.addWidget(self.propertyWidget, 2, 0)
grid.addWidget(buttonBox, 3, 0, 1, 2)
self.length_edit.textEdited.connect(self.onTextEdited)
self.thick_edit.textEdited.connect(self.onTextEdited)
def onTextEdited(self):
l = self.length_edit.text()
t = self.thick_edit.text()
self.propertyWidget.display(l, t)
class PropertyWidget(QtWidgets.QWidget):
def __init__(self, parent=None):
super(PropertyWidget, self).__init__(parent)
HB_lay = QtWidgets.QHBoxLayout(self)
self.Displaylabel = QtWidgets.QLabel('')
HB_lay.addWidget(self.Displaylabel)
HB_lay.addStretch()
def display(self, l, t):
try:
L_Display = int(l)
T_Display = int(t)
fmt = "L = {}mm\nT = {}mm"
self.Displaylabel.setText(fmt.format(L_Display, T_Display))
except ValueError:
self.Displaylabel.clear()
if __name__ == '__main__':
app = QtWidgets.QApplication(sys.argv)
w = WinDialog()
w.show()
sys.exit(app.exec_())

Send a string to a QLineEdit

I'm wondering if there is a way make a button send a message to a lineEdit variable in PyQt4. Here is my code so far:
import sys
from PyQt4 import QtGui,QtCore
class Example(QtGui.QWidget):
def __init__(self):
super(Example, self).__init__()
self.initUI()
def initUI(self):
qanda = QtGui.QLineEdit()
one = QtGui.QPushButton('1',self)
two = QtGui.QPushButton('2',self)
three = QtGui.QPushButton('3',self)
four = QtGui.QPushButton('4',self)
five = QtGui.QPushButton('5',self)
six = QtGui.QPushButton('6',self)
seven = QtGui.QPushButton('7',self)
eight = QtGui.QPushButton('8',self)
nine = QtGui.QPushButton('9',self)
zero = QtGui.QPushButton('0',self)
dot = QtGui.QPushButton('.',self)
minus = QtGui.QPushButton('-',self)
plus = QtGui.QPushButton('+',self)
multiply = QtGui.QPushButton('x',self)
divide = QtGui.QPushButton('/',self)
equals = QtGui.QPushButton('=',self)
backspace = QtGui.QPushButton('Backspace',self)
xsquared = QtGui.QPushButton('x^2',self)
xcubed = QtGui.QPushButton('x^3',self)
clear = QtGui.QPushButton('C',self)
one.clicked.connect(self.buttonClicked)
two.clicked.connect(self.buttonClicked)
three.clicked.connect(self.buttonClicked)
four.clicked.connect(self.buttonClicked)
five.clicked.connect(self.buttonClicked)
six.clicked.connect(self.buttonClicked)
seven.clicked.connect(self.buttonClicked)
eight.clicked.connect(self.buttonClicked)
nine.clicked.connect(self.buttonClicked)
zero.clicked.connect(self.buttonClicked)
dot.clicked.connect(self.buttonClicked)
minus.clicked.connect(self.buttonClicked)
plus.clicked.connect(self.buttonClicked)
multiply.clicked.connect(self.buttonClicked)
divide.clicked.connect(self.buttonClicked)
equals.clicked.connect(self.buttonClicked)
backspace.clicked.connect(self.buttonClicked)
xsquared.clicked.connect(self.buttonClicked)
xcubed.clicked.connect(self.buttonClicked)
clear.clicked.connect(self.buttonClicked)
grid = QtGui.QGridLayout()
grid.setSpacing(5)
grid.addWidget(qanda,0,0,1,4)
grid.addWidget(one,4,0)
grid.addWidget(two,4,1)
grid.addWidget(three,4,2)
grid.addWidget(four,3,0)
grid.addWidget(five,3,1)
grid.addWidget(six,3,2)
grid.addWidget(seven,2,0)
grid.addWidget(eight,2,1)
grid.addWidget(nine,2,2)
grid.addWidget(zero,5,0)
grid.addWidget(dot,5,1)
grid.addWidget(minus,5,3)
grid.addWidget(plus,4,3)
grid.addWidget(multiply,2,3)
grid.addWidget(divide,3,3)
grid.addWidget(equals,5,2)
grid.addWidget(backspace,1,0)
grid.addWidget(xsquared,1,1)
grid.addWidget(xcubed,1,2)
grid.addWidget(clear,1,3)
self.setLayout(grid)
self.setGeometry(300, 300, 250, 200)
self.setWindowTitle('ldm;sasdklhsdghk dgh jkl;')
self.show()
def buttonClicked(self):
sender = self.sender()
print(sender.text())
def main():
app = QtGui.QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())
if __name__ == '__main__':
main()
My goal is when someone clicks a button, such as x^2, x^2 will be displayed on the empty space that is the variable qanda.
If you are wondering, this is a calculator.

You need to keep a reference to the line-edit so that you can access it later:
def initUI(self):
self.qanda = QtGui.QLineEdit(self)
...
grid.addWidget(self.qanda,0,0,1,4)
...
Now you can set the text of the line-edit, like so:
def buttonClicked(self):
sender = self.sender()
print(sender.text())
self.qanda.setText(sender.text())

Have you tried setText method?
http://pyqt.sourceforge.net/Docs/PyQt4/qlineedit.html#setText

PyQt4 layout delete all QLabels

I have a toolbar with right-left controls, and I want to display 2 pages each time the loop ends and then, add them to self.pdf_layout and delete the old ones. The point is to step forwards and backwards 2 pages each time.
How can i replace (or delete and reset) the self.pdf_layout widgets (QLabels- I use them as image placeholders) ???
class pdfViewer(QtGui.QWidget):
def __init__(self, parent,filepath):
QtGui.QWidget.__init__(self, parent)
#temp = tempfile.gettempdir()
#tempfilename=temp+'/unf120.pdf'
self.filepath = filepath
# global CurrentPage
#global currentPage
self.currentPage = 0
self.doc = popplerqt4.Poppler.Document.load(self.filepath)
self.doc.setRenderHint(popplerqt4.Poppler.Document.Antialiasing)
self.doc.setRenderHint(popplerqt4.Poppler.Document.TextAntialiasing)
self.scroll_area = QtGui.QScrollArea()
self.scroll_area.setBackgroundRole(QtGui.QPalette.Dark)
self.mainlayout = QtGui.QVBoxLayout()
#PDF READER CONTROLS
self.ControlsLayout = QtGui.QHBoxLayout()
self.ControlsWidget = QtGui.QWidget()
self.ControlsWidget.setLayout(self.ControlsLayout)
self.pdf_widget = QtGui.QWidget()
self.pdf_layout = QtGui.QHBoxLayout()
self.pdf_widget.setLayout(self.pdf_layout)
#toolBar
self.toolbar = QtGui.QToolBar()
#left Button action
leftAction = QtGui.QAction(QtGui.QIcon('left.png'),'Left',self)
self.toolbar.addAction(leftAction)
#right Button Action
rightAction = QtGui.QAction(QtGui.QIcon('right.png'),'Right',self)
#rightRender = self.renderPages(1,currentPage,100)
self.toolbar.addAction(rightAction)
rightAction.triggered.connect(self.forwardPages)
#start Button Action
startAction = QtGui.QAction(QtGui.QIcon('start.png'),'Go to: Start',self)
self.toolbar.addAction(startAction)
#end Window Action
endAction = QtGui.QAction(QtGui.QIcon('end.png'),'Go to: end',self)
self.toolbar.addAction(endAction)
self.ControlsLayout.addWidget(self.toolbar)
#Zoom Controls
# Zoom Label
zoomLabel = QtGui.QLabel("Zoom: ")
zoomLabel.setMaximumWidth(50)
self.ControlsLayout.addWidget(zoomLabel)
#Zoom ComboBox Widget
combo = QtGui.QComboBox()
combo.addItem("50%")
combo.addItem("60%")
combo.addItem("70%")
combo.addItem("80%")
combo.addItem("90%")
combo.addItem("100%")
combo.addItem("120%")
combo.addItem("150%")
combo.addItem("170%")
combo.addItem("200%")
combo.setMaximumWidth(100)
self.ControlsLayout.addWidget(combo)
# add PDF READER Controls to mainlayout
self.ControlsWidget.setMaximumWidth(300)
self.mainlayout.addWidget(self.ControlsWidget)
# by default goes to firstPage of the current document
self.forwardPages(100)
self.scroll_area.setWidget(self.pdf_widget)
self.mainlayout.addWidget(self.scroll_area)
self.setLayout(self.mainlayout)
self.resize(1700,900)
self.move(500,80)
def firstPage(self,zoomLevel=100):
self.currentPage = 0
pdfpage = self.doc.page(self.currentPage)
image = pdfpage.renderToImage(zoomLevel,zoomLevel)
pixmap = QtGui.QPixmap.fromImage(image)
self.label = QtGui.QLabel()
self.label.setScaledContents(True)
currentWidth = self.scroll_area.frameGeometry().width()-100
#print currentWidth
pixScaled = pixmap.scaledToWidth(currentWidth,QtCore.Qt.FastTransformation)
self.label.setPixmap(pixScaled)
self.pdf_layout.addWidget(self.label)
print 'set first page'
here is the method....
def forwardPages(self,zoomLevel=100):
renderingTime = time.time()
sum_pages = self.doc.numPages()
currentPage = self.currentPage
for currentPage in range(1):
print currentPage
pdfpage = self.doc.page(self.currentPage+1)
image = pdfpage.renderToImage(zoomLevel,zoomLevel)
pixmap = QtGui.QPixmap.fromImage(image)
label = QtGui.QLabel()
label.setScaledContents(True)
currentWidth = self.scroll_area.frameGeometry().width()-100
#print currentWidth
pixScaled = pixmap.scaledToWidth(currentWidth,QtCore.Qt.FastTransformation)
label.setPixmap(pixScaled)
for i in range(self.pdf_layout.count()): self.pdf_layout.itemAt(i).widget().close()
self.pdf_layout.addWidget(label)
print "rendering time = {0}".format(time.time()-renderingTime)
self.scroll_area.setWidget(self.pdf_widget)
self.currentPage = currentPage

You can little bit change your code.
First you store current pages like this
currentLeftPage = self.currentLeftPage
currentRightPage = self.currentRightPage
And you change the pdfpage like
pdfLeftPage = self.doc.page(self.currentLeftPage+2)
pdfRightPage = self.doc.page(self.currentRightPage+2)
then you renderd leftImage and rightImage separatly.
Note: You may modify or optimize the above thing.