def demoWidget(self):
cb = QCheckBox("MyCheckBox", self)
cb.move(0, 0)
cb.resize(cb.sizeHint()) #가장 최적의 사이즈를 찾아줌
cb.stateChanged.connect(self.changed)
#stateChanged는 시그널임. self.changed
s = QSlider(QtCore.Qt.Horizontal , self)
s.move(30,30)
s.setRange(0,100) #범위 지정
s.resize(300,10)
s.setSingleStep(2) #최소 단위 설정
s.valueChanged.connect(self.slider)
self.label = QLabel(self)
self.label.move(0, 100)
self.label.setText("Hello <b style='color: red'>QLabel</b>")
self.qle1 = QLineEdit(self)
self.qle2 = QLineEdit(self)
label2 = QLabel(self)
self.qle1.move(0,150)
label2.move(110,150)
label2.setText("+")
label2.resize(20,30)
self.qle2.move(130,150)
self.button = QPushButton("result", self)
self.button.move(0,200)
self.button.clicked.connect(self.calculation_add)
self.result = QLabel(self)
self.result.move(0,250)
self.result.setFont(QtGui.QFont('SansSerif', 20))
label = QLabel(
"Informe a nota que você acredita que \no teste de usabilidade irá resultar: ",
janela)
label.move(20, 20)
label.resize(200, 40)
label_slider_0 = QLabel("0", janela)
label_slider_0.move(20, 60)
label_slider_0.resize(20, 20)
label_slider_100 = QLabel("100", janela)
label_slider_100.move(260, 60)
label_slider_100.resize(20, 20)
slider = QSlider(janela)
slider.move(20, 80)
slider.resize(260, 20)
slider.setOrientation(Qt.Horizontal)
slider.setMinimum(0)
slider.setMaximum(100)
text_hipotese = QLabel("Hipótese: ", janela)
text_hipotese.move(20, 110)
text_hipotese.resize(60, 20)
result_hipotese = QLabel("", janela)
result_hipotese.move(70, 110)
result_hipotese.resize(60, 20)
botao = QPushButton("Importar CSV", janela)
botao.move(20, 140)
class ToolBoxWidget(QWidget):
'''
Class which creates a toolbox storing all available tools and handles text input
'''
numberOfButtons = 4
textButtonName = 'textButton'
markerButtonName = 'markerButton'
okButtonName = 'okButton'
cancelButtonName = 'cancelButton'
items = IndexedOrderedDict()
textInputFinished = Signal(int, int, int, bool, str)
currentPageNumber = -1
currentX = -1
currentY = -1
editMode = editModes.none
prevEditMode = editModes.none
editModeChange = Signal(str)
suggestUpdate = Signal()
settingsChanged = Signal()
editTextBox = False
buttons = IndexedOrderedDict()
def __init__(self, parent):
'''
Creates the toolboxwidget as child of the window widget
:param parent: Parent window widget.
'''
QWidget.__init__(self, parent)
self.initUI()
def initUI(self):
'''
Sets up major UI components
'''
# Create a rectengle from teh given outer dimensions
textBoxRect = self.rect()
# Shrink it for matiching textBox size
textBoxRect.adjust(+30, +30, -12, -12)
buttonRect = self.rect()
buttonRect.adjust(+29, +30, +15, -20)
self.row1Left = buttonRect.topLeft()
self.row1Right = buttonRect.topRight()
self.row2Left = QPoint(self.row1Left.x(), self.row1Left.y() + 35)
self.row2Right = QPoint(self.row1Right.x(), self.row1Right.y() + 35)
self.row3Left = QPoint(self.row2Left.x(), self.row2Left.y() + 35)
self.row3Right = QPoint(self.row2Right.x(), self.row2Right.y() + 35)
self.bottomLeft = QPoint(buttonRect.topLeft().x(),
buttonRect.topLeft().y() + 140)
self.bottomRight = QPoint(self.row1Right.x(), self.row1Right.y() + 140)
self.bottomMiddle = QPoint(self.row1Left.x() + 65, self.row1Right.y())
# We use a textEdit for making text boxes editable for user
self.pTextEdit = QTextEdit(self)
# Always enable line wrapping
self.pTextEdit.setLineWrapMode(QTextEdit.WidgetWidth)
self.pTextEdit.setAutoFormatting(QTextEdit.AutoAll)
self.pTextEdit.setAcceptRichText(True)
self.pTextEdit.setFontPointSize(10)
self.pTextEdit.setPlaceholderText("Text Box Content")
# Forward keypressevents from the textEdit to the parent toolBoxWidget
self.keyPressEvent = self.pTextEdit.keyPressEvent
self.keyReleaseEvent = self.pTextEdit.keyReleaseEvent
# We need a layout to add the textBox to the toolBoxWidget
widgetLayout = QGridLayout(self)
widgetLayout.addWidget(self.pTextEdit)
self.pTextEdit.setGeometry(textBoxRect)
buttonSize = QSize(60, 30)
# -----------------------------
# Toolbuttons
# -----------------------------
self.textButton = QPushButton(self)
self.textButton.setFixedSize(buttonSize)
self.textButton.move(self.row1Right)
self.textButton.setIcon(QIcon(":/assets/text.png"))
self.textButton.setCheckable(True)
self.buttons['textButton'] = self.textButton
self.markerButton = QPushButton(self)
self.markerButton.setFixedSize(buttonSize)
self.markerButton.move(self.row1Left)
self.markerButton.setIcon(QIcon(":/assets/marker.png"))
self.markerButton.setCheckable(True)
self.buttons['markerButton'] = self.markerButton
self.freehandButton = QPushButton(self)
self.freehandButton.setFixedSize(buttonSize)
self.freehandButton.move(self.row2Left)
self.freehandButton.setIcon(QIcon(":/assets/freehand.png"))
self.freehandButton.setCheckable(True)
self.buttons['freehandButton'] = self.freehandButton
self.markdownButton = QPushButton(self)
self.markdownButton.setFixedSize(buttonSize)
self.markdownButton.move(self.row2Right)
self.markdownButton.setIcon(QIcon(":/assets/markdown.png"))
self.markdownButton.setCheckable(True)
self.buttons['markdownButton'] = self.markdownButton
self.formsButton = QPushButton(self)
self.formsButton.setFixedSize(buttonSize)
self.formsButton.move(self.row3Left)
self.formsButton.setIcon(QIcon(":/assets/forms.png"))
self.formsButton.setCheckable(True)
self.buttons['formsButton'] = self.formsButton
self.eraserButton = QPushButton(self)
self.eraserButton.setFixedSize(buttonSize)
self.eraserButton.move(self.row3Right)
self.eraserButton.setIcon(QIcon(":/assets/eraser.png"))
self.eraserButton.setCheckable(True)
self.buttons['eraserButton'] = self.eraserButton
self.okButton = QPushButton(self)
self.okButton.setFixedSize(buttonSize)
self.okButton.move(self.bottomLeft)
self.okButton.setIcon(QIcon(":/assets/ok.png"))
self.buttons['okButton'] = self.okButton
self.cancelButton = QPushButton(self)
self.cancelButton.setFixedSize(buttonSize)
self.cancelButton.move(self.bottomRight)
self.cancelButton.setIcon(QIcon(":/assets/cancel.png"))
self.buttons['cancelButton'] = self.cancelButton
self.deleteButton = QPushButton(self)
self.deleteButton.setFixedSize(buttonSize)
self.deleteButton.move(self.bottomRight)
self.deleteButton.setIcon(QIcon(":/assets/delete.png"))
self.buttons['deleteButton'] = self.deleteButton
self.undoButton = QPushButton(self)
self.undoButton.setFixedSize(buttonSize)
self.undoButton.move(self.bottomLeft)
self.undoButton.setIcon(QIcon(":/assets/undo.png"))
self.buttons['undoButton'] = self.undoButton
self.redoButton = QPushButton(self)
self.redoButton.setFixedSize(buttonSize)
self.redoButton.move(self.bottomRight)
self.redoButton.setIcon(QIcon(":/assets/redo.png"))
self.buttons['redoButton'] = self.redoButton
# -----------------------------
# Preference Buttons
# -----------------------------
self.sizeButton = QPushButton(self)
self.sizeButton.setFixedSize(buttonSize)
self.sizeButton.setIcon(QIcon(":/assets/size.png"))
self.sizeButton.setCheckable(True)
self.buttons['sizeButton'] = self.sizeButton
self.colorButton = QPushButton(self)
self.colorButton.setFixedSize(buttonSize)
self.colorButton.setIcon(QIcon(":/assets/color.png"))
self.colorButton.setCheckable(True)
self.buttons['colorButton'] = self.colorButton
# Set Shortcuts for the buttons
self.textButton.setShortcut("Ctrl+T")
self.markerButton.setShortcut("Ctrl+M")
self.freehandButton.setShortcut("Ctrl+D")
self.eraserButton.setShortcut("Ctrl+E")
self.okButton.setShortcut("Ctrl+Return")
self.cancelButton.setShortcut("Esc")
self.deleteButton.setShortcut("Ctrl+Del")
self.undoButton.setShortcut("Ctrl+Z")
self.redoButton.setShortcut("Ctrl+Y")
self.sizeButton.setShortcut("Ctrl+X")
self.colorButton.setShortcut("Ctrl+L")
# Connect Events for the buttons
self.okButton.clicked.connect(self.handleOkButton)
self.markerButton.clicked.connect(self.handleMarkerButton)
self.textButton.clicked.connect(self.handleTextButton)
self.formsButton.clicked.connect(self.handleFormsButton)
self.freehandButton.clicked.connect(self.handleFreehandButton)
self.eraserButton.clicked.connect(self.handleEraserButton)
self.markdownButton.clicked.connect(self.handleMarkdownButton)
self.cancelButton.clicked.connect(self.handleCancelButton)
self.deleteButton.clicked.connect(self.handleDeleteButton)
self.undoButton.clicked.connect(self.handleUndoButton)
self.redoButton.clicked.connect(self.handleRedoButton)
self.sizeButton.clicked.connect(self.handleSizeButton)
self.colorButton.clicked.connect(self.handleColorButton)
sliderSize = QSize(15, 140)
self.slider = QSlider(Qt.Vertical, self)
self.slider.setMinimum(50)
self.slider.setMaximum(150)
self.slider.setValue(100)
self.slider.move(self.bottomMiddle)
self.slider.setFixedSize(sliderSize)
self.slider.setEnabled(False)
self.slider.valueChanged.connect(self.handleSliderValueChange)
self.slider.sliderReleased.connect(self.handleSliderValueChanged)
self.slider.sliderMoved.connect(self.handleSliderDrag)
self.setButtonState()
def restoreDefaults(self):
'''
Restores defaults for certain edit components
'''
black = (0, 0, 0)
yellow = (1, 1, 0)
# restore defaults for better ux
Preferences.updateKeyValue('freehandColor',
tuple(map(lambda x: str(x), black)))
Preferences.updateKeyValue('markerColor',
tuple(map(lambda x: str(x), yellow)))
Preferences.updateKeyValue('formColor',
tuple(map(lambda x: str(x), black)))
self.settingsChanged.emit()
def paintEvent(self, event):
'''
Overrides the default paint event to either draw a textBox or a toolBox
'''
if self.editTextBox:
# Draw the toolBoxShape
self.drawRectShape(event)
else:
self.drawToolBoxShape(event)
# Run the parent paint Event
return QWidget.paintEvent(self, event)
def drawToolBoxShape(self, paintEvent):
'''
Draws the circular toolBox shape
'''
outerCircleRect = self.rect()
outerCircleRect.adjust(+OUTEROFFSETBOTTOM, +OUTEROFFSETTOP,
-OUTEROFFSETBOTTOM, -OUTEROFFSETBOTTOM)
topMiddle = (outerCircleRect.topRight() - outerCircleRect.topLeft()
) / 2 + outerCircleRect.topLeft()
bottomMiddle = (outerCircleRect.bottomRight() - outerCircleRect.
bottomLeft()) / 2 + outerCircleRect.bottomLeft()
shapePainter = QPainter(self)
shapePainter.setRenderHint(shapePainter.Antialiasing)
# shapePainter.setPen(QPen(QColor(14,125,145), OUTERLINEWIDTH, Qt.SolidLine))
# shapePainter.drawArc(outerCircleRect, CIRCLE/2, CIRCLE/2)
# shapePainter.setPen(QPen(QColor(14,125,145), 5, Qt.SolidLine))
# shapePainter.drawLine(topMiddle, bottomMiddle)
if self.editMode == editModes.freehand:
if Preferences.data['comboBoxThemeSelect'] == 0 and toBool(
Preferences.data['radioButtonAffectsPDF']) == True:
try:
color = tuple(
map(lambda x: (1 - float(x)) * 255,
Preferences.data['freehandColor']))
except ValueError as identifier:
color = rgb.white
else:
try:
color = tuple(
map(lambda x: float(x) * 255,
Preferences.data['freehandColor']))
except ValueError as identifier:
color = rgb.black
try:
size = pdf_annots.defaultPenSize * (
int(Preferences.data['freehandSize']) /
pdf_annots.freeHandScale)
except ValueError as identifier:
size = pdf_annots.defaultPenSize
elif self.editMode == editModes.marker:
if Preferences.data['comboBoxThemeSelect'] == 0 and toBool(
Preferences.data['radioButtonAffectsPDF']) == True:
try:
color = tuple(
map(lambda x: (1 - float(x)) * 255,
Preferences.data['markerColor']))
except ValueError as identifier:
color = rgb.white
else:
try:
color = tuple(
map(lambda x: float(x) * 255,
Preferences.data['markerColor']))
except ValueError as identifier:
color = rgb.black
try:
size = pdf_annots.defaultPenSize * (int(
Preferences.data['markerSize']) / pdf_annots.freeHandScale)
except ValueError as identifier:
size = pdf_annots.defaultPenSize
elif self.editMode == editModes.forms:
if Preferences.data['comboBoxThemeSelect'] == 0 and toBool(
Preferences.data['radioButtonAffectsPDF']) == True:
try:
color = tuple(
map(lambda x: (1 - float(x)) * 255,
Preferences.data['formColor']))
except ValueError as identifier:
color = rgb.white
else:
try:
color = tuple(
map(lambda x: float(x) * 255,
Preferences.data['formColor']))
except ValueError as identifier:
color = rgb.black
try:
size = pdf_annots.defaultPenSize * (int(
Preferences.data['formSize']) / pdf_annots.freeHandScale)
except ValueError as identifier:
size = pdf_annots.defaultPenSize
else:
color = rgb.main
size = 0.1
shapePainter.setPen(QPen(QColor(*color), size * 3, Qt.SolidLine))
arcRect = QRect(bottomMiddle.x() - 5, bottomMiddle.y() - 6, 13, 13)
shapePainter.drawArc(arcRect, 0, CIRCLE)
self.pTextEdit.setEnabled(False)
self.pTextEdit.setVisible(False)
def drawRectShape(self, event):
'''
Draws a rectangle for the textEdit box
'''
textBoxRect = self.rect()
outerCircleRect = self.rect()
textBoxRect.adjust(+30, +30, -12, -12)
outerCircleRect.adjust(+8, +8, -8, -15)
moveRect = QRect(0, 0, 11, 11)
shapePainter = QPainter(self)
shapePainter.setRenderHint(shapePainter.Antialiasing)
# shapePainter.setPen(QPen(QColor(14,125,145), 5, Qt.SolidLine))
# shapePainter.drawRect(textBoxRect)
shapePainter.setPen(QPen(QColor(14, 125, 145), 5, Qt.SolidLine))
shapePainter.drawLine(outerCircleRect.topLeft(),
outerCircleRect.bottomLeft())
# shapePainter.setPen(QPen(QColor(14,125,145), 2, Qt.SolidLine))
# arcRect = QRect(outerCircleRect.bottomLeft().x() - 6, outerCircleRect.bottomLeft().y()+1, 12, 12)
# shapePainter.drawArc(arcRect, 0, CIRCLE)
self.pTextEdit.setEnabled(True)
self.pTextEdit.setVisible(True)
self.pTextEdit.ensureCursorVisible()
self.pTextEdit.setFocus()
def setButtonState(self):
'''
Sets the button state depending on the current edit mode
'''
if self.editTextBox and self.editMode == editModes.newTextBox:
self.setEnableOnAllButtonsButThose(['okButton', 'cancelButton'])
self.setVisibleOnAllButtonsButThose(['okButton', 'cancelButton'])
self.slider.setVisible(False)
elif self.editTextBox and self.editMode == editModes.editTextBox:
self.setEnableOnAllButtonsButThose(['okButton', 'deleteButton'])
self.setVisibleOnAllButtonsButThose(['okButton', 'deleteButton'])
self.slider.setVisible(False)
elif self.editMode == editModes.newTextBox:
self.setEnableOnAllButtonsButThose(
['textButton', 'sizeButton', 'colorButton'])
self.setVisibleOnAllButtonsButThose(
['textButton', 'sizeButton', 'colorButton'])
self.buttons['sizeButton'].move(self.row1Left)
self.buttons['colorButton'].move(self.row2Left)
elif self.editMode == editModes.marker:
self.prevEditMode = editModes.marker
self.setEnableOnAllButtonsButThose([
'markerButton', 'sizeButton', 'colorButton', 'eraserButton',
'undoButton', 'redoButton'
])
self.setVisibleOnAllButtonsButThose([
'markerButton', 'sizeButton', 'colorButton', 'eraserButton',
'undoButton', 'redoButton'
])
self.buttons['sizeButton'].move(self.row1Right)
self.buttons['colorButton'].move(self.row2Right)
elif self.editMode == editModes.freehand:
self.prevEditMode = editModes.freehand
self.setEnableOnAllButtonsButThose([
'freehandButton', 'sizeButton', 'colorButton', 'eraserButton',
'undoButton', 'redoButton'
])
self.setVisibleOnAllButtonsButThose([
'freehandButton', 'sizeButton', 'colorButton', 'eraserButton',
'undoButton', 'redoButton'
])
self.buttons['sizeButton'].move(self.row1Right)
self.buttons['colorButton'].move(self.row2Right)
elif self.editMode == editModes.eraser:
self.setEnableOnAllButtonsButThose(
['eraserButton', 'undoButton', 'redoButton'])
elif self.editMode == editModes.forms:
self.prevEditMode = editModes.forms
self.setEnableOnAllButtonsButThose([
'formsButton', 'sizeButton', 'colorButton', 'eraserButton',
'undoButton', 'redoButton'
])
self.setVisibleOnAllButtonsButThose([
'formsButton', 'sizeButton', 'colorButton', 'eraserButton',
'undoButton', 'redoButton'
])
self.buttons['sizeButton'].move(self.row1Right)
self.buttons['colorButton'].move(self.row2Right)
elif self.editMode == editModes.markdown:
self.setEnableOnAllButtonsButThose(['markdownButton'])
elif self.editMode == editModes.none:
self.setVisibleOnAllButtonsButThose([
'textButton', 'eraserButton', 'formsButton', 'freehandButton',
'markerButton', 'markdownButton', 'undoButton', 'redoButton'
])
self.setEnableOnAllButtonsButThose([
'textButton', 'eraserButton', 'formsButton', 'freehandButton',
'markerButton', 'markdownButton', 'undoButton', 'redoButton'
])
self.setCheckedOnAllButtonsButThose([])
self.slider.setVisible(True)
self.repaint()
def setEnableOnAllButtonsButThose(self, names, value=False):
for buttonName, buttonInst in self.buttons.items():
if not buttonName in names:
buttonInst.setEnabled(value)
else:
buttonInst.setEnabled(not value)
def setVisibleOnAllButtonsButThose(self, names, value=False):
for buttonName, buttonInst in self.buttons.items():
if not buttonName in names:
buttonInst.setVisible(value)
else:
buttonInst.setVisible(not value)
def setCheckedOnAllButtonsButThose(self, names, value=False):
for buttonName, buttonInst in self.buttons.items():
if not buttonName in names:
buttonInst.setChecked(value)
else:
buttonInst.setChecked(not value)
def insertCurrentContent(self, content):
'''
Used to append the provided content to the textEdit box
:param content: Text which should be displayed in the textEdit
'''
if content != "":
self.pTextEdit.setText(content)
return True
else:
self.pTextEdit.setText("")
return False
def mousePressEvent(self, event):
'''
Overrides the default event
'''
self.__mousePressPos = None
self.__mouseMovePos = None
if event.button() == Qt.LeftButton:
self.__mousePressPos = event.globalPos()
self.__mouseMovePos = event.globalPos()
QWidget.mousePressEvent(self, event)
def mouseMoveEvent(self, event):
'''
Overrides the default event
'''
if event.buttons() == Qt.LeftButton:
try:
# adjust offset from clicked point to origin of widget
currPos = self.mapToGlobal(self.pos())
globalPos = event.globalPos()
diff = globalPos - self.__mouseMovePos
newPos = self.mapFromGlobal(currPos + diff)
self.move(newPos)
self.__mouseMovePos = globalPos
except AttributeError:
pass # We are in touch screen mode here
QWidget.mouseMoveEvent(self, event)
# def mouseReleaseEvent(self, event):
# '''
# Overrides the default event
# '''
# if self.__mousePressPos is not None:
# moved = event.globalPos() - self.__mousePressPos
# if moved.manhattanLength() > 3:
# event.ignore()
# return
# QWidget.mouseReleaseEvent(self, event)
@Slot(int, int, int, str)
def handleTextInputRequest(self, x, y, pageNumber, currentContent):
'''
Slot when toolBox receives a textInput request. This is the case, when the user wants to insert a new or edit an existing textBox
'''
# Switch in to text box mode and redraw Widget
self.currentPageNumber = pageNumber
self.currentContent = currentContent
if self.insertCurrentContent(currentContent):
self.editMode = editModes.editTextBox
else:
self.editMode = editModes.newTextBox
self.editTextBox = True
self.setButtonState()
self.currentX = x
self.currentY = y
self.repaint()
def handleTextButton(self):
if self.textButton.isChecked():
self.editMode = editModes.newTextBox
else:
self.editMode = editModes.none
self.editModeChange.emit(self.editMode)
self.setButtonState()
def handleMarkerButton(self):
if self.markerButton.isChecked():
self.editMode = editModes.marker
else:
self.editMode = editModes.none
self.editModeChange.emit(self.editMode)
self.setButtonState()
def handleEraserButton(self):
if self.eraserButton.isChecked():
self.editMode = editModes.eraser
else:
self.editMode = self.prevEditMode
self.prevEditMode = editModes.none
self.editModeChange.emit(self.editMode)
self.setButtonState()
def handleFormsButton(self):
if self.formsButton.isChecked():
self.editMode = editModes.forms
else:
self.editMode = editModes.none
self.editModeChange.emit(self.editMode)
self.setButtonState()
def handleFreehandButton(self):
if self.freehandButton.isChecked():
self.editMode = editModes.freehand
else:
self.editMode = editModes.none
self.editModeChange.emit(self.editMode)
self.setButtonState()
def handleMarkdownButton(self):
if self.markdownButton.isChecked():
self.editMode = editModes.markdown
else:
self.editMode = editModes.none
self.editModeChange.emit(self.editMode)
self.setButtonState()
def handleOkButton(self):
'''
This method handles all the stuff that needs to be done, when the user successfully finished textEditing
'''
if self.editMode == editModes.newTextBox or self.editMode == editModes.editTextBox:
self.textInputFinished.emit(self.currentX, self.currentY,
self.currentPageNumber, True,
self.pTextEdit.toPlainText())
self.editMode = editModes.none
self.editTextBox = False
self.setButtonState()
self.repaint()
self.currentPageNumber = -1
self.currentX = -1
self.currentY = -1
def handleCancelButton(self):
'''
This method handles all the stuff that needs to be done, when the user canceled textEditing
'''
if self.editMode == editModes.newTextBox or self.editMode == editModes.editTextBox:
self.textInputFinished.emit(self.currentX, self.currentY,
self.currentPageNumber, False,
self.currentContent)
self.editMode = editModes.none
self.editTextBox = False
self.setButtonState()
self.repaint()
self.currentPageNumber = -1
self.currentX = -1
self.currentY = -1
def handleDeleteButton(self):
'''
This method handles all the stuff that needs to be done, when the user canceled textEditing
'''
if self.editMode == editModes.newTextBox or self.editMode == editModes.editTextBox:
self.textInputFinished.emit(self.currentX, self.currentY,
self.currentPageNumber, False, "")
self.editMode = editModes.none
self.editTextBox = False
self.setButtonState()
self.repaint()
self.currentPageNumber = -1
self.currentX = -1
self.currentY = -1
def handleUndoButton(self):
History.undo()
self.suggestUpdate.emit()
def handleRedoButton(self):
History.redo()
self.suggestUpdate.emit()
def restoreSliderValue(self):
try:
if self.sizeButton.isChecked():
if self.editMode == editModes.newTextBox:
lastSliderValue = int(Preferences.data['textSize'])
elif self.editMode == editModes.marker:
lastSliderValue = int(Preferences.data['markerSize'])
elif self.editMode == editModes.freehand:
lastSliderValue = int(Preferences.data['freehandSize'])
elif self.editMode == editModes.forms:
lastSliderValue = int(Preferences.data['formSize'])
elif self.colorButton.isChecked():
if self.editMode == editModes.marker:
try:
normRGB = tuple(
map(lambda x: float(x),
str(Preferences.data['markerColor'])))
hsv = colorsys.rgb_to_hsv(*normRGB)
except TypeError as identifier:
raise ValueError
lastSliderValue = int(hsv[0] * 100)
elif self.editMode == editModes.freehand:
try:
normRGB = tuple(
map(lambda x: float(x),
str(Preferences.data['freehandColor'])))
hsv = colorsys.rgb_to_hsv(*normRGB)
except TypeError as identifier:
raise ValueError
lastSliderValue = int(hsv[0] * 100)
elif self.editMode == editModes.forms:
try:
normRGB = tuple(
map(lambda x: float(x),
str(Preferences.data['formColor'])))
hsv = colorsys.rgb_to_hsv(*normRGB)
except TypeError as identifier:
raise ValueError
lastSliderValue = int(hsv[0] * 100)
except ValueError:
self.storeSliderValue()
return
self.slider.setValue(lastSliderValue)
def storeSliderValue(self):
if self.sizeButton.isChecked():
if self.editMode == editModes.newTextBox:
Preferences.updateKeyValue('textSize', self.slider.value())
elif self.editMode == editModes.marker:
Preferences.updateKeyValue('markerSize', self.slider.value())
elif self.editMode == editModes.freehand:
Preferences.updateKeyValue('freehandSize', self.slider.value())
elif self.editMode == editModes.forms:
Preferences.updateKeyValue('formSize', self.slider.value())
elif self.colorButton.isChecked():
normRGB = colorsys.hsv_to_rgb(self.slider.value() / 100, 1, 1)
if self.editMode == editModes.marker:
Preferences.updateKeyValue(
'markerColor', tuple(map(lambda x: str(x), normRGB)))
elif self.editMode == editModes.freehand:
Preferences.updateKeyValue(
'freehandColor', tuple(map(lambda x: str(x), normRGB)))
elif self.editMode == editModes.forms:
Preferences.updateKeyValue(
'formColor', tuple(map(lambda x: str(x), normRGB)))
self.settingsChanged.emit()
def handleSizeButton(self):
'''
This method will set the slider value to match the current size
'''
if self.sizeButton.isChecked():
self.slider.setEnabled(True)
self.restoreSliderValue()
else:
self.storeSliderValue()
self.slider.setEnabled(False)
self.slider.setValue(100)
self.repaint()
def handleColorButton(self):
'''
Handles color button presses
'''
if self.colorButton.isChecked():
self.slider.setEnabled(True)
self.restoreSliderValue()
else:
self.restoreDefaults()
self.slider.setEnabled(False)
self.slider.setValue(100)
self.repaint()
def handleSliderDrag(self, value):
'''
Called when the user moves the slider
'''
self.slider.setValue(10 * round(value / 10))
self.storeSliderValue()
self.repaint()
def handleSliderValueChange(self, value):
'''
Triggered when user changes the slider value
'''
self.slider.setValue(10 * round(value / 10))
def handleSliderValueChanged(self):
'''
Triggered when user has changed the slider value
'''
self.storeSliderValue()
import sys
from PySide2.QtWidgets import QApplication, QMainWindow, QSlider, QPushButton, QLabel
from PySide2.QtCore import Qt
aplicacao = QApplication(sys.argv)
janela = QMainWindow()
janela.setGeometry(100, 50, 300, 200)
janela.setWindowTitle("Primeira Janela")
slider = QSlider(janela)
slider.resize(100, 30)
slider.move(100, 20)
slider.setOrientation(Qt.Horizontal)
slider.setMinimum(0)
slider.setMaximum(100)
label = QLabel("Valor do slider", janela)
label.move(100, 90)
label.resize(100, 20)
resultado = QLabel("", janela)
resultado.move(100, 120)
label.resize(100, 20)
def onButtonClicked():
resultado.setText(str(slider.value()))
botao = QPushButton("Obter valor", janela)
import sys
from PySide2.QtWidgets import QApplication, QMainWindow, QSlider
from PySide2.QtCore import Qt
aplicacao = QApplication(sys.argv)
janela = QMainWindow()
# setGeometry(esquerda, topo, largura, altura)
janela.setGeometry(100, 50, 300, 200)
janela.setWindowTitle("Primeira Janela")
# cria um objeto slider dentro da janela
slider = QSlider(janela)
slider.resize(100, 30)
slider.move(100, 85)
# modifica a orientação do slider
slider.setOrientation(Qt.Horizontal)
janela.show()
aplicacao.exec_()
sys.exit()
