Created
July 6, 2022 08:13
-
-
Save rqx110/47915e3e48e67a96b90ed1a8bc45180c to your computer and use it in GitHub Desktop.
python 2.7 PyQt5 RoundProgressBar
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| from __future__ import division | |
| from PyQt5 import QtWidgets | |
| from PyQt5.QtCore import QSize, Qt | |
| from PyQt5.QtGui import QPainter, QPen, QColor, QFont | |
| class RoundProgressBar(QtWidgets.QWidget): | |
| def __init__(self, parent=None): | |
| super(RoundProgressBar, self).__init__(parent) | |
| self.positionX = 0 | |
| self.positionY = 0 | |
| self.posFactor = 0 | |
| self.rpb_minimumSize = (0, 0) | |
| self.rpb_maximumSize = (0, 0) | |
| self.rpb_dynamicMin = True | |
| self.rpb_dynamicMax = True | |
| self.rpb_Size = 0 | |
| self.sizeFactor = 0 | |
| self.rpb_maximum = 100 | |
| self.rpb_minimum = 0 | |
| self.rpb_type = self.barStyleFlags.Donet | |
| self.startPosition = self.startPosFlags.North | |
| self.rpb_direction = self.rotationFlags.Clockwise | |
| self.rpb_textType = self.textFlags.Percentage | |
| self.rpb_textColor = (0, 159, 227) | |
| self.rpb_textWidth = self.rpb_Size / 8 | |
| self.rpb_textFont = 'Segoe UI' | |
| self.rpb_textValue = '12%' | |
| self.rpb_textRatio = 8 | |
| self.textFactorX = 0 | |
| self.textFactorY = 0 | |
| self.dynamicText = True | |
| self.rpb_textActive = True | |
| self.lineWidth = 5 | |
| self.pathWidth = 5 | |
| self.rpb_lineStyle = self.lineStyleFlags.SolidLine | |
| self.rpb_lineCap = self.lineCapFlags.SquareCap | |
| self.lineColor = (0, 159, 227) | |
| self.pathColor = (218, 218, 218) | |
| self.rpb_circleColor = (218, 218, 218) | |
| self.rpb_circleRatio = 0.8 | |
| self.rpb_circlePosX = 0 | |
| self.rpb_circlePosY = 0 | |
| self.rpb_pieColor = (200, 200, 200) | |
| self.rpb_pieRatio = 1 | |
| self.rpb_piePosX = 0 | |
| self.rpb_piePosY = 0 | |
| self.rpb_value = -45 * 16 | |
| if self.rpb_dynamicMin: | |
| self.setMinimumSize(QSize(self.lineWidth * 6 + self.pathWidth * 6, self.lineWidth * 6 + self.pathWidth * 6)) | |
| # ------------------------------------------------------CLASS ENUMERATORS | |
| class lineStyleFlags: | |
| SolidLine = Qt.SolidLine | |
| DotLine = Qt.DotLine | |
| DashLine = Qt.DashLine | |
| class lineCapFlags: | |
| SquareCap = Qt.SquareCap | |
| RoundCap = Qt.RoundCap | |
| class barStyleFlags: | |
| Donet = 0 | |
| Line = 1 | |
| Pie = 2 | |
| Pizza = 3 | |
| Hybrid1 = 4 | |
| Hybrid2 = 5 | |
| class rotationFlags: | |
| Clockwise = -1 | |
| AntiClockwise = 1 | |
| class textFlags: | |
| Value = 0 | |
| Percentage = 1 | |
| class startPosFlags: | |
| North = 90 * 16 | |
| South = -90 * 16 | |
| East = 0 * 16 | |
| West = 180 * 16 | |
| # ------------------------------------------------------METHODS FOR CHANGING THE PROPERTY OF THE ROUNDPROGRESSBAR :SOLTS | |
| def rpb_setMinimumSize(self, width, height): | |
| """ | |
| Minimum Size of the Widget | |
| ... | |
| Parameters | |
| -------------- | |
| width : int | |
| width of the Widget | |
| height : int | |
| height of the Widget | |
| Raises | |
| -------------- | |
| Exception : Sorry Width/Height should be an int | |
| """ | |
| if type(width) != type(5) or type(height) != type(5): | |
| raise Exception('Sorry Width/Height should be an int') | |
| return | |
| self.rpb_dynamicMin = False | |
| self.setMinimumSize(width, height) | |
| self.rpb_minimumSize = (width, height) | |
| self.update() | |
| def rpb_setMaximumSize(self, width, height): | |
| """ | |
| Maximum Size of the Widget | |
| ... | |
| Parameters | |
| -------------- | |
| width : int | |
| width of the Widget | |
| height : int | |
| height of the Widget | |
| Raises | |
| -------------- | |
| Exception : Sorry Width/Height should be an int | |
| """ | |
| if type(width) != type(5) or type(height) != type(5): | |
| raise Exception('Sorry Width/Height should be an int') | |
| self.rpb_dynamicMax = False | |
| self.setMaximumSize(width, height) | |
| self.rpb_maximumSize = (width, height) | |
| self.update() | |
| def rpb_setMaximum(self, maximum): | |
| """ | |
| Maximum Value of the Progressbar | |
| ... | |
| Parameters | |
| -------------- | |
| maximum : int | |
| Maximum value of the round progress bar | |
| Raises | |
| -------------- | |
| Exception : Maximum and Minimum cannot be the Same | |
| """ | |
| if self.rpb_minimum == maximum: # FOR AVOIDING DIVISION BY ZERO ERROR IN FUTURE | |
| raise Exception("Maximum and Minimum cannot be the Same") | |
| if self.rpb_maximum != maximum: | |
| self.rpb_maximum = maximum | |
| self.update() | |
| def rpb_setMinimum(self, minimum): | |
| """ | |
| Minimum Value of the Progressbar | |
| ... | |
| Parameters | |
| -------------- | |
| minimum : int | |
| Minimum value of the round progress bar | |
| Raises | |
| -------------- | |
| Exception : Maximum and Minimum cannot be the Same | |
| """ | |
| if self.rpb_maximum == minimum: # FOR AVOIDING DIVISION BY ZERO ERROR IN FUTURE | |
| raise Exception("Maximum and Minimum cannot be the Same") | |
| if self.rpb_minimum != minimum: | |
| self.rpb_minimum = minimum | |
| self.update() | |
| def rpb_setRange(self, maximum, minimum): | |
| """ | |
| Range include the maximum and the minimum in one go. | |
| ... | |
| Parameters | |
| -------------- | |
| maximum : int | |
| Maximum value of the round progress bar | |
| minimum : int | |
| Minimum value for the round progress bar | |
| Raises | |
| -------------- | |
| none | |
| """ | |
| if minimum > maximum: | |
| maximum, minimum = minimum, maximum | |
| if self.rpb_maximum != maximum: | |
| self.rpb_maximum = maximum | |
| if self.rpb_minimum != minimum: | |
| self.rpb_minimum = minimum | |
| self.update() | |
| def rpb_setInitialPos(self, pos): | |
| """ | |
| Starting position of the round progress bar | |
| ... | |
| Parameters | |
| -------------- | |
| pos : String | |
| Position string: 'North', 'South', 'East' and 'West' | |
| Raises | |
| -------------- | |
| ValueError : Maximum and Minimum cannot be the Same | |
| """ | |
| if pos == 'North': | |
| self.startPosition = self.startPosFlags.North | |
| elif pos == 'South': | |
| self.startPosition = self.startPosFlags.South | |
| elif pos == 'East': | |
| self.startPosition = self.startPosFlags.East | |
| elif pos == 'West': | |
| self.startPosition = self.startPosFlags.West | |
| else: | |
| raise Exception("Initial Position String can be: 'South', 'North'") | |
| return | |
| def rpb_setValue(self, value): | |
| """ | |
| Set progress value | |
| ... | |
| Parameters | |
| -------------- | |
| value : int | |
| The value of the progress bar in int. The value should be: min<=value<=max | |
| Raises | |
| -------------- | |
| none | |
| """ | |
| if self.rpb_value != value: | |
| if value >= self.rpb_maximum: | |
| RoundProgressBar.convertInputValue(self, self.rpb_maximum) | |
| elif value < self.rpb_minimum: | |
| RoundProgressBar.convertInputValue(self, self.rpb_minimum) | |
| else: | |
| RoundProgressBar.convertInputValue(self, value) | |
| self.update() | |
| def rpb_reset(self): | |
| """ | |
| Reset the progress bar to 0% | |
| ... | |
| Parameters | |
| -------------- | |
| none | |
| Raises | |
| -------------- | |
| none | |
| """ | |
| RoundProgressBar.convertInputValue(self, self.rpb_minimum) | |
| self.update() | |
| def rpb_setGeometry(self, posX, posY): | |
| """ | |
| Set the X and Y position of the round progress bar. | |
| ... | |
| Parameters | |
| -------------- | |
| posX : int | |
| The position of the round progress bar in int for X axis. | |
| posY : int | |
| The position of the round progress bar in int for Y axis. | |
| Raises | |
| -------------- | |
| none | |
| """ | |
| if self.positionX != posX: | |
| self.positionX = posX | |
| if self.positionY != posY: | |
| self.positionY = posY | |
| self.update() | |
| def rpb_setLineWidth(self, width): | |
| """ | |
| Line Width of the line in round progress bar. | |
| ... | |
| Parameters | |
| -------------- | |
| width: int | |
| Line width corresponding to the width in px. | |
| Raises | |
| -------------- | |
| Exception: Line Width should be in int | |
| """ | |
| if type(width) != type(5): | |
| raise Exception('Line Width should be in int') | |
| return | |
| if self.lineWidth != width: | |
| self.lineWidth = width | |
| self.update() | |
| def rpb_setLineColor(self, rgb): | |
| """ | |
| Line Color of the progress bar. | |
| ... | |
| Parameters | |
| -------------- | |
| rgb: tuple: (R, G, B) | |
| Color is passed as a tuple of values for red, blue and green in the order: (R, G, B) | |
| Raises | |
| -------------- | |
| Exception: Line Color accepts a tuple: (R, G, B). | |
| """ | |
| if type(rgb) != type(()): | |
| raise Exception("Line Color accepts a tuple: (R, G, B).") | |
| return | |
| if self.lineColor != rgb: | |
| self.lineColor = rgb | |
| self.update() | |
| def rpb_setPathColor(self, rgb): | |
| """ | |
| Path Color settings. | |
| ... | |
| Parameters | |
| -------------- | |
| rgb: tuple: (R, G, B) | |
| Color is passed as a tuple of values for red, blue and green in the order: (R, G, B) | |
| Raises | |
| -------------- | |
| Exception: Path Color accepts a tuple: (R, G, B). | |
| """ | |
| if type(rgb) != type(()): | |
| raise Exception("Path Color accepts a tuple: (R, G, B).") | |
| return | |
| if self.pathColor != rgb: | |
| self.pathColor = rgb | |
| self.update() | |
| def rpb_setPathWidth(self, width): | |
| """ | |
| Path width settings. | |
| ... | |
| Parameters | |
| -------------- | |
| width: int | |
| Width of the path in px | |
| Raises | |
| -------------- | |
| Exception: Line Width should be in int | |
| """ | |
| if type(width) != type(5): | |
| raise Exception('Path Width should be in int') | |
| return | |
| if self.pathWidth != width: | |
| self.pathWidth = width | |
| self.update() | |
| def rpb_setDirection(self, direction): | |
| """ | |
| Direction of rotation of the progress bar. | |
| ... | |
| Parameters | |
| -------------- | |
| direction: string | |
| string can be: 'AntiClockwise' or 'Clockwise'. Default: 'Clockwise'. | |
| Raises | |
| -------------- | |
| Exception: Direction can only be: 'Clockwise' and 'AntiClockwise' | |
| """ | |
| if direction == 'Clockwise' or direction == -1: | |
| self.rpb_direction = self.rotationFlags.Clockwise | |
| elif direction == 'AntiClockwise' or direction == 1: | |
| self.rpb_direction = self.rotationFlags.AntiClockwise | |
| else: | |
| raise Exception("Direction can only be: 'Clockwise' and 'AntiClockwise' and Not: " + str(direction)) | |
| return | |
| self.update() | |
| def rpb_setBarStyle(self, style): | |
| """ | |
| Bar Style of the progress bar. | |
| ... | |
| Parameters | |
| -------------- | |
| style: String | |
| String of the styles of the progress bar: 'Donet', 'Pie', 'line', 'Hybrid1', 'Hybrid2', 'Pizza' | |
| Raises | |
| -------------- | |
| Exception: Round Progress Bar has only the following styles: 'Line', 'Donet', 'Hybrid1', 'Pizza', 'Pie' and 'Hybrid2' | |
| """ | |
| if style == 'Donet': | |
| self.rpb_type = self.barStyleFlags.Donet | |
| elif style == 'Line': | |
| self.rpb_type = self.barStyleFlags.Line | |
| elif style == 'Pie': | |
| self.rpb_type = self.barStyleFlags.Pie | |
| elif style == 'Pizza': | |
| self.rpb_type = self.barStyleFlags.Pizza | |
| elif style == 'Hybrid1': | |
| self.rpb_type = self.barStyleFlags.Hybrid1 | |
| elif style == 'Hybrid2': | |
| self.rpb_type = self.barStyleFlags.Hybrid2 | |
| else: | |
| raise Exception( | |
| "Round Progress Bar has only the following styles: 'Line', 'Donet', 'Hybrid1', 'Pizza', 'Pie' and 'Hybrid2'") | |
| return | |
| self.update() | |
| def rpb_setLineStyle(self, style): | |
| """ | |
| Line Style setting. | |
| ... | |
| Parameters | |
| -------------- | |
| style: String | |
| Line style: 'DotLine', 'DashLine', 'SolidLine', passed as a string. | |
| Raises | |
| -------------- | |
| none | |
| """ | |
| if style == 'SolidLine': | |
| self.rpb_lineStyle = self.lineStyleFlags.SolidLine | |
| elif style == 'DotLine': | |
| self.rpb_lineStyle = self.lineStyleFlags.DotLine | |
| elif style == 'DashLine': | |
| self.rpb_lineStyle = self.lineStyleFlags.DashLine | |
| else: | |
| self.rpb_lineStyle = self.lineStyleFlags.SolidLine | |
| def rpb_setLineCap(self, cap): | |
| """ | |
| Line Cap setting. | |
| ... | |
| Parameters | |
| -------------- | |
| cap: String | |
| Cap is the end point of a stroke. It can be: 'RoundCap' or 'SquareCap' | |
| Raises | |
| -------------- | |
| none | |
| """ | |
| if cap == 'SquareCap': | |
| self.rpb_lineCap = self.lineCapFlags.SquareCap | |
| elif cap == 'RoundCap': | |
| self.rpb_lineCap = self.lineCapFlags.RoundCap | |
| def rpb_setTextColor(self, rgb): | |
| """ | |
| Text color of the text inside the progress bar | |
| ... | |
| Parameters | |
| -------------- | |
| rgb: tuple | |
| Color of the text in the format: (R, G, B) | |
| Raises | |
| -------------- | |
| none | |
| """ | |
| if self.rpb_textColor != rgb: | |
| self.rpb_textColor = rgb | |
| self.update() | |
| def rpb_setTextFont(self, font): | |
| """ | |
| Font of the text inside the round progress bar | |
| ... | |
| Parameters | |
| -------------- | |
| font: str | |
| Name of the font in string | |
| Raises | |
| -------------- | |
| none | |
| """ | |
| if self.rpb_textFont != font: | |
| self.rpb_textFont = font | |
| self.update() | |
| def rpb_setTextFormat(self, textTyp): | |
| """ | |
| Text formatter i.e. the value or the percentage. | |
| ... | |
| Parameters | |
| -------------- | |
| textTyp: str | |
| 'value', 'percentage' | |
| Raises | |
| -------------- | |
| none | |
| """ | |
| if textTyp == 'Value': | |
| self.rpb_textType = self.textFlags.Value | |
| elif textTyp == 'Percentage': | |
| self.rpb_textType = self.textFlags.Percentage | |
| else: | |
| self.rpb_textType = self.textFlags.Percentage | |
| def rpb_setTextRatio(self, ratio): | |
| """ | |
| Text ratio with respect to the size of the progress bar. | |
| ... | |
| Parameters | |
| -------------- | |
| ratio: int | |
| In number from 3 to 50 corresponding to 1/3 or 1/50 the size of the roundprogressbar. | |
| Raises | |
| -------------- | |
| none | |
| """ | |
| if self.rpb_textRatio != ratio: | |
| if ratio < 3: | |
| ratio = 3 | |
| elif ratio > 50: | |
| ratio = 50 | |
| self.rpb_textRatio = ratio | |
| self.update() | |
| def rpb_setTextWidth(self, width): | |
| """ | |
| Text Width. | |
| ... | |
| Parameters | |
| -------------- | |
| font: int | |
| Text constant width. Will not change during the widget resize. | |
| Raises | |
| -------------- | |
| none | |
| """ | |
| self.dynamicText = False | |
| if width > 0: | |
| self.rpb_textWidth = width | |
| self.update() | |
| def rpb_setCircleColor(self, rgb): | |
| """ | |
| Circle color fill inside the circle. | |
| ... | |
| Parameters | |
| -------------- | |
| font: tuple | |
| The color of the circle in the tuple corresponding to the (R, G, B). | |
| Raises | |
| -------------- | |
| none | |
| """ | |
| if self.rpb_circleColor != rgb: | |
| self.rpb_circleColor = rgb | |
| self.update() | |
| def rpb_setCircleRatio(self, ratio): | |
| """ | |
| Circle ration corresponding to the round progress bar. | |
| ... | |
| Parameters | |
| -------------- | |
| font: int | |
| Integer corresponding to the size of the progress bar to that of the round progress bar. | |
| Raises | |
| -------------- | |
| none | |
| """ | |
| if self.rpb_circleRatio != ratio: | |
| self.rpb_circleRatio = ratio | |
| self.update() | |
| def rpb_setPieColor(self, rgb): | |
| """ | |
| Pie color inside the fill. | |
| ... | |
| Parameters | |
| -------------- | |
| font: tuple | |
| Tuple consist in format (R, G, B). Same as color setting to Line. | |
| Raises | |
| -------------- | |
| none | |
| """ | |
| if self.rpb_pieColor != rgb: | |
| self.rpb_pieColor = rgb | |
| self.update() | |
| def rpb_setPieRatio(self, ratio): | |
| """ | |
| Pie Ratio | |
| ... | |
| Parameters | |
| -------------- | |
| font: int | |
| Ratio corresponding to the size between the roundprogressbar and the pie size. | |
| Raises | |
| -------------- | |
| none | |
| """ | |
| if self.rpb_pieRatio != ratio: | |
| self.rpb_pieRatio = ratio | |
| self.update() | |
| def rpb_enableText(self, enable): | |
| """ | |
| Makes the Text visible/Hidden | |
| ... | |
| Parameters | |
| -------------- | |
| font: bool | |
| True: Text visible, False: Text invisible. | |
| Raises | |
| -------------- | |
| none | |
| """ | |
| if enable: | |
| self.rpb_textActive = enable | |
| else: | |
| self.rpb_textActive = enable | |
| self.update() | |
| # ------------------------------------------------------METHODS FOR GETTING THE PROPERTY OF ROUNDPROGRESSBAR SLOTS | |
| def rpb_getSize(self): | |
| """ | |
| Get the present size of the progress bar. | |
| ... | |
| Returns | |
| -------------- | |
| Return the size of the round progress bar in int. | |
| """ | |
| return self.rpb_Size | |
| def rpb_getValue(self): | |
| """ | |
| Present value of the progress bar. | |
| ... | |
| Returns | |
| -------------- | |
| int corresponding to the present progress bar value. | |
| """ | |
| return self.rpb_value / 16 | |
| def rpb_getRange(self): | |
| """ | |
| Progress bar range. | |
| ... | |
| Returns | |
| -------------- | |
| tuple consisting of minimu and maximum as elements. | |
| """ | |
| return (self.rpb_minimum, self.rpb_maximum) | |
| def rpb_getTextWidth(self): | |
| """ | |
| Text width of the present text in the central of the widget. | |
| ... | |
| Returns | |
| -------------- | |
| int corresponding to the width of the text | |
| """ | |
| return self.rpb_textWidth | |
| # ------------------------------------------------------ENGINE: WHERE ALL THE REAL STUFF TAKE PLACE: WORKING OF THE ROUNDPROGRESSBA | |
| def rpb_MinimumSize(self, dynamicMax, minimum, maximum): | |
| """ | |
| Minimum size calculating code: Takes consideration of the width of the line/path/circle/pie and the user defined | |
| width and also the size of the frame/window of the application. | |
| """ | |
| rpb_Height = self.height() | |
| rpb_Width = self.width() | |
| if dynamicMax: | |
| if rpb_Width >= rpb_Height and rpb_Height >= minimum[1]: | |
| self.rpb_Size = rpb_Height | |
| elif rpb_Width < rpb_Height and rpb_Width >= minimum[0]: | |
| self.rpb_Size = rpb_Width | |
| else: | |
| if rpb_Width >= rpb_Height and rpb_Height <= maximum[1]: | |
| self.rpb_Size = rpb_Height | |
| elif rpb_Width < rpb_Height and rpb_Width <= maximum[0]: | |
| self.rpb_Size = rpb_Width | |
| def convertInputValue(self, value): | |
| """ | |
| CONVERTS ANY INPUT VALUE TO THE 0*16-360*16 DEGREE REFERENCE OF THE QPainter.drawArc NEEDED. | |
| """ | |
| self.rpb_value = ((value - self.rpb_minimum) / (self.rpb_maximum - self.rpb_minimum)) * 360 * 16 | |
| self.rpb_value = self.rpb_direction * self.rpb_value | |
| if self.rpb_textType == RoundProgressBar.textFlags.Percentage: | |
| self.rpb_textValue = str( | |
| round(((value - self.rpb_minimum) / (self.rpb_maximum - self.rpb_minimum)) * 100)) + "%" | |
| else: | |
| self.rpb_textValue = str(value) | |
| # SINCE THE THICKNESS OF THE LINE OR THE PATH CAUSES THE WIDGET TO WRONGLY FIT INSIDE THE SIZE OF THE WIDGET DESIGNED IN THE | |
| # QTDESIGNER, THE CORRECTION FACTOR IS NECESSERY CALLED THE GEOMETRYFACTOR, WHICH CALCULATE THE TWO FACTORS CALLED THE | |
| # self.posFactor AND THE self.sizeFactor, CALCULATION THIS IS NECESSERY AS THE | |
| def geometryFactor(self): | |
| if self.lineWidth > self.pathWidth: | |
| self.posFactor = self.lineWidth / 2 + 1 | |
| self.sizeFactor = self.lineWidth + 1 | |
| else: | |
| self.posFactor = self.pathWidth / 2 + 1 | |
| self.sizeFactor = self.pathWidth + 1 | |
| def rpb_textFactor(self): | |
| if self.dynamicText: | |
| self.rpb_textWidth = self.rpb_Size / self.rpb_textRatio | |
| self.textFactorX = self.posFactor + (self.rpb_Size - self.sizeFactor) / 2 - self.rpb_textWidth * 0.75 * ( | |
| len(self.rpb_textValue) / 2) | |
| self.textFactorY = self.rpb_textWidth / 2 + self.rpb_Size / 2 | |
| def rpb_circleFactor(self): | |
| self.rpb_circlePosX = self.positionX + self.posFactor + ((self.rpb_Size) * (1 - self.rpb_circleRatio)) / 2 | |
| self.rpb_circlePosY = self.positionY + self.posFactor + ((self.rpb_Size) * (1 - self.rpb_circleRatio)) / 2 | |
| def rpb_pieFactor(self): | |
| self.rpb_piePosX = self.positionX + self.posFactor + ((self.rpb_Size) * (1 - self.rpb_pieRatio)) / 2 | |
| self.rpb_piePosY = self.positionY + self.posFactor + ((self.rpb_Size) * (1 - self.rpb_pieRatio)) / 2 | |
| def paintEvent(self, event): | |
| # THIS BELOW CODE AMKE SURE THAT THE SIZE OF THE ROUNDPROGRESSBAR DOESNOT REDUCES TO ZERO WHEN THE USER RESIZES THE WINDOW | |
| if self.rpb_dynamicMin: | |
| self.setMinimumSize(QSize(self.lineWidth * 6 + self.pathWidth * 6, self.lineWidth * 6 + self.pathWidth * 6)) | |
| RoundProgressBar.rpb_MinimumSize(self, self.rpb_dynamicMax, self.rpb_minimumSize, self.rpb_maximumSize) | |
| RoundProgressBar.geometryFactor(self) | |
| RoundProgressBar.rpb_textFactor(self) | |
| RoundProgressBar.rpb_circleFactor(self) | |
| RoundProgressBar.rpb_pieFactor(self) | |
| if self.rpb_type == 0: # DONET TYPE | |
| RoundProgressBar.pathComponent(self) | |
| RoundProgressBar.lineComponent(self) | |
| RoundProgressBar.textComponent(self) | |
| elif self.rpb_type == 1: # LINE TYPE | |
| RoundProgressBar.lineComponent(self) | |
| RoundProgressBar.textComponent(self) | |
| elif self.rpb_type == 2: # Pie | |
| RoundProgressBar.pieComponent(self) | |
| RoundProgressBar.textComponent(self) | |
| elif self.rpb_type == 3: # PIZZA | |
| RoundProgressBar.circleComponent(self) | |
| RoundProgressBar.lineComponent(self) | |
| RoundProgressBar.textComponent(self) | |
| elif self.rpb_type == 4: # HYBRID1 | |
| RoundProgressBar.circleComponent(self) | |
| RoundProgressBar.pathComponent(self) | |
| RoundProgressBar.lineComponent(self) | |
| RoundProgressBar.textComponent(self) | |
| elif self.rpb_type == 5: # HYBRID2 | |
| RoundProgressBar.pieComponent(self) | |
| RoundProgressBar.lineComponent(self) | |
| RoundProgressBar.textComponent(self) | |
| def lineComponent(self): | |
| linePainter = QPainter(self) | |
| linePainter.setRenderHint(QPainter.Antialiasing) | |
| penLine = QPen() | |
| penLine.setStyle(self.rpb_lineStyle) | |
| penLine.setWidth(self.lineWidth) | |
| penLine.setBrush(QColor(self.lineColor[0], self.lineColor[1], self.lineColor[2])) | |
| penLine.setCapStyle(self.rpb_lineCap) | |
| penLine.setJoinStyle(Qt.RoundJoin) | |
| linePainter.setPen(penLine) | |
| linePainter.drawArc(self.positionX + self.posFactor, self.positionY + self.posFactor, | |
| self.rpb_Size - self.sizeFactor, self.rpb_Size - self.sizeFactor, self.startPosition, | |
| self.rpb_value) | |
| linePainter.end() | |
| def pathComponent(self): | |
| pathPainter = QPainter(self) | |
| pathPainter.setRenderHint(QPainter.Antialiasing) | |
| penPath = QPen() | |
| penPath.setStyle(Qt.SolidLine) | |
| penPath.setWidth(self.pathWidth) | |
| penPath.setBrush(QColor(self.pathColor[0], self.pathColor[1], self.pathColor[2])) | |
| penPath.setCapStyle(Qt.RoundCap) | |
| penPath.setJoinStyle(Qt.RoundJoin) | |
| pathPainter.setPen(penPath) | |
| pathPainter.drawArc(self.positionX + self.posFactor, self.positionY + self.posFactor, | |
| self.rpb_Size - self.sizeFactor, self.rpb_Size - self.sizeFactor, 0, 360 * 16) | |
| pathPainter.end() | |
| def textComponent(self): | |
| if self.rpb_textActive: | |
| textPainter = QPainter(self) | |
| penText = QPen() | |
| penText.setColor(QColor(self.rpb_textColor[0], self.rpb_textColor[1], self.rpb_textColor[2])) | |
| textPainter.setPen(penText) | |
| fontText = QFont() | |
| fontText.setFamily(self.rpb_textFont) | |
| fontText.setPointSize(self.rpb_textWidth) | |
| textPainter.setFont(fontText) | |
| textPainter.drawText(self.positionX + self.textFactorX, self.positionY + self.textFactorY, | |
| self.rpb_textValue) | |
| textPainter.end() | |
| def circleComponent(self): | |
| circlePainter = QPainter(self) | |
| penCircle = QPen() | |
| penCircle.setWidth(0) | |
| penCircle.setColor(QColor(self.rpb_circleColor[0], self.rpb_circleColor[1], self.rpb_circleColor[2])) | |
| circlePainter.setRenderHint(QPainter.Antialiasing) | |
| circlePainter.setPen(penCircle) | |
| circlePainter.setBrush(QColor(self.rpb_circleColor[0], self.rpb_circleColor[1], self.rpb_circleColor[2])) | |
| circlePainter.drawEllipse(self.rpb_circlePosX, self.rpb_circlePosY, | |
| (self.rpb_Size - self.sizeFactor) * self.rpb_circleRatio, | |
| (self.rpb_Size - self.sizeFactor) * self.rpb_circleRatio) | |
| def pieComponent(self): | |
| piePainter = QPainter(self) | |
| penPie = QPen() | |
| penPie.setWidth(0) | |
| penPie.setColor(QColor(self.rpb_pieColor[0], self.rpb_pieColor[1], self.rpb_pieColor[2])) | |
| piePainter.setRenderHint(QPainter.Antialiasing) | |
| piePainter.setPen(penPie) | |
| piePainter.setBrush(QColor(self.rpb_pieColor[0], self.rpb_pieColor[1], self.rpb_pieColor[2])) | |
| piePainter.drawPie(self.rpb_piePosX, self.rpb_piePosY, (self.rpb_Size - self.sizeFactor) * self.rpb_pieRatio, | |
| (self.rpb_Size - self.sizeFactor) * self.rpb_pieRatio, self.startPosition, self.rpb_value) | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
https://anjalp.github.io/PySide2extn/