ProgressBarEditor Example

import sys, os
sys.path.append(os.path.dirname(os.path.realpath(__file__)) + "/../../shared")

from DevMachines import __pyside2__, __pyside6__
from DevMachines import QtitanBase
from DevMachines.QtitanBase import Qtitan
from DevMachines.QtitanGrid import (getGridVersion, Grid, GridColumn, GridEditor,
                                    CellButtonClickEventArgs, ContextMenuEventArgs,
                                    EditorValidationEventArgs)

if __pyside2__:
    from PySide2 import QtCore
    from PySide2.QtCore import Qt, QTimer
    from PySide2.QtGui import QStandardItemModel
    from PySide2.QtWidgets import QWidget, QApplication, QMessageBox, QHBoxLayout, QVBoxLayout, QCheckBox, QLabel, QComboBox, QSlider, QPushButton

if __pyside6__:
    from PySide6 import QtCore
    from PySide6.QtCore import Qt, QTimer
    from PySide6.QtGui import QStandardItemModel
    from PySide6.QtWidgets import QWidget, QApplication, QMessageBox, QHBoxLayout, QVBoxLayout, QCheckBox, QLabel, QComboBox, QSlider, QPushButton

from DemoMainWindow import DemoMainWindow

class Window(DemoMainWindow):
    up = True
    def __init__(self):
        DemoMainWindow.__init__(self, "QtitanDataGrid", getGridVersion())
        self.setWindowTitle(self.tr("QtitanDataGrid - Progress Editor Demo"))
        self.setGeometry(150, 150, 1000, 600)
        self.setMinimumHeight(10)

        Grid.loadTranslation()
        self.grid = Grid()
        model = QStandardItemModel(100, 3, self.grid)
        model.setHeaderData(0, Qt.Horizontal, "Progress Bar")
        model.setHeaderData(1, Qt.Horizontal, "Integer Value")
        model.setHeaderData(2, Qt.Horizontal, "String Value")
        for row in range(0, model.rowCount()):
            for column in range(0, model.columnCount()):
                model.setData(model.index(row, column), row)

        # Configure grid view
        self.grid.setViewType(Grid.TableView)
        view = self.grid.view()
        view.options().setGridLineWidth(1)

        # Connect Grid's context menu handler.
        self.connect(view, QtCore.SIGNAL("contextMenu(ContextMenuEventArgs*)"), self, QtCore.SLOT("contextMenu(ContextMenuEventArgs*)"))
        self.connect(view, QtCore.SIGNAL("editorModifying(GridEditor *)"), self, QtCore.SLOT("editorModifying(GridEditor*)"))
        self.connect(view, QtCore.SIGNAL("editorValidating(EditorValidationEventArgs*)"), self, QtCore.SLOT("editorValidating(EditorValidationEventArgs*)"))

        view.setModel(model)

        # Configure the frozen rows.
        row = view.getRow(0)
        row.setPinned(True)
        row = view.getRow(1)
        row.setPinned(True)

        # Configure the grid columns.
        column = view.getColumn(0)
        column.setEditorType(GridEditor.ProgressBar)
        column.editorRepository().setDialEdit(True)

        column = view.getColumn(1)
        column.setEditorType(GridEditor.Numeric)
        column.editorRepository().setMinimum(-10000)
        column.editorRepository().setMaximum(10000)

        column = view.getColumn(2)
        column.setEditorType(GridEditor.String);
        column.editorRepository().setValidateOnEnter(False)
        column.editorRepository().setEditorActivationPolicy(GridEditor.ActivationPolicy(GridEditor.ActivateByKeyPress_WithEating | GridEditor.ActivateByEnter))

        # Add cell button to the column.
        column.addButton(GridColumn.TextButtonIcon, Qtitan.AtEnd)
        column.addButton(GridColumn.ChoiceButtonIcon, Qtitan.AtEnd)
        self.connect(column, QtCore.SIGNAL("buttonClicked(CellButtonClickEventArgs*)"),
            self, QtCore.SLOT("cellButtonClicked(CellButtonClickEventArgs*)"));

        # Show button menu for all column headers.
        for i in range(0, view.getColumnCount()):
            view.getColumn(i).setMenuButtonVisible(True)

        self.setDemoWidget(self.grid, self.createSettingsWidget())

        self.timer = QTimer(self)
        self.connect(self.timer, QtCore.SIGNAL("timeout()"), self, QtCore.SLOT("updateGridData()"))
        self.timer.start(150)

    def createSettingsWidget(self):
        # Create settings widget
        settings = QWidget(self)
        l = QVBoxLayout(settings)
        autoWidthCheck = QCheckBox(settings)
        autoWidthCheck.setText("Column auto width")
        self.connect(autoWidthCheck, QtCore.SIGNAL("stateChanged(int)"), self, QtCore.SLOT("autoWidthStateChanged(int)"))
        autoWidthCheck.setChecked(True)
        l.addWidget(autoWidthCheck)

        fastScrollCheck = QCheckBox(settings)
        fastScrollCheck.setText("Fast scroll effect")
        self.connect(fastScrollCheck, QtCore.SIGNAL("stateChanged(int)"), self, QtCore.SLOT("fastScrollChanged(int)"))
        l.addWidget(fastScrollCheck)
        fastScrollCheck.setChecked(True)

        dottedLineCheck = QCheckBox(settings)
        dottedLineCheck.setText("Dotted grid line")
        self.connect(dottedLineCheck, QtCore.SIGNAL("stateChanged(int)"), self, QtCore.SLOT("dottedLineChanged(int)"))
        l.addWidget(dottedLineCheck)
        dottedLineCheck.setChecked(True)

        label = QLabel(self)
        hl = QHBoxLayout()
        label.setText("Grid line style:")
        lineStylesSelect = QComboBox(settings)

        lineStylesSelect.addItem("None")
        lineStylesSelect.addItem("Both")
        lineStylesSelect.addItem("Both2D")
        lineStylesSelect.addItem("Horizontal")
        lineStylesSelect.addItem("Horizontal2D")
        lineStylesSelect.addItem("Vertical")
        lineStylesSelect.addItem("Vertical2D")
        self.connect(lineStylesSelect, QtCore.SIGNAL("currentIndexChanged(int)"), self, QtCore.SLOT("selectGridLineStyles(int)"))
        hl.addWidget(label)
        hl.addWidget(lineStylesSelect)
        l.addLayout(hl)
        lineStylesSelect.setCurrentIndex(2)

        zoomEnable = QCheckBox(settings)
        zoomEnable.setText(self.tr("Zoom enabled"))
        zoomEnable.setChecked(True)
        self.connect(zoomEnable, QtCore.SIGNAL("stateChanged(int)"), self, QtCore.SLOT("zoomEnabledChanged(int)"))
        l.addWidget(zoomEnable)

        zoomIndicator = QCheckBox(settings)
        zoomIndicator.setText(self.tr("Show zoom indicator"))
        zoomIndicator.setChecked(True)
        self.connect(zoomIndicator, QtCore.SIGNAL("stateChanged(int)"), self, QtCore.SLOT("zoomIndicatorChanged(int)"))
        l.addWidget(zoomIndicator)

        zoomSlider = QSlider(settings)
        zoomSlider.setOrientation(Qt.Horizontal)
        zoomSlider.setTickPosition(QSlider.TicksBothSides)
        zoomSlider.setMinimum(25)
        zoomSlider.setMaximum(300)
        zoomSlider.setTickInterval(25)
        zoomSlider.setSingleStep(25)
        zoomSlider.setValue(100)
        self.connect(zoomSlider, QtCore.SIGNAL("sliderMoved(int)"), self, QtCore.SLOT("zoomValueChanged(int)"))
        self.connect(self.grid.view(), QtCore.SIGNAL("zoomChanged(int)"), zoomSlider, QtCore.SLOT("setValue(int)"))
        l.addWidget(zoomSlider)

        cellAutoRaise = QCheckBox(settings)
        cellAutoRaise.setText(self.tr("Auto raise cell button"))
        self.connect(cellAutoRaise, QtCore.SIGNAL("stateChanged(int)"), self, QtCore.SLOT("cellButtonAutoRaiseEnabled(int)"))
        cellAutoRaise.setChecked(True)
        l.addWidget(cellAutoRaise)

        frozenRowsBox = QCheckBox(settings)
        frozenRowsBox.setText(self.tr("Frozen Rows"))
        self.connect(frozenRowsBox, QtCore.SIGNAL("stateChanged(int)"), self, QtCore.SLOT("frozenRowsEnabled(int)"))
        frozenRowsBox.setChecked(True)
        l.addWidget(frozenRowsBox)

        transparentBox = QCheckBox(settings)
        transparentBox.setText(self.tr("Transparent Background"))
        self.connect(transparentBox, QtCore.SIGNAL("stateChanged(int)"), self, QtCore.SLOT("transparentBackgroundEnabled(int)"))
        transparentBox.setChecked(False)
        l.addWidget(transparentBox)

        printButton = QPushButton(settings)
        printButton.setText(self.tr("Print Preview"))
        self.connect(printButton, QtCore.SIGNAL("clicked()"), self, QtCore.SLOT("printPreview()"))
        l.addWidget(printButton)
        return settings

    @QtCore.Slot(int)
    def autoWidthStateChanged(self, state):
        view = self.grid.view()
        view.tableOptions().setColumnAutoWidth(Qt.CheckState(state) == Qt.Checked)

    @QtCore.Slot(int)
    def fastScrollChanged(self, state):
        view = self.grid.view()
        view.options().setFastScrollEffect(Qt.CheckState(state) == Qt.Checked)

    @QtCore.Slot(int)
    def dottedLineChanged(self, state):
        view = self.grid.view()
        pen = view.options().gridLinePen()
        if Qt.CheckState(state) == Qt.Checked:
            pen.setStyle(Qt.DotLine)
        else:
            pen.setStyle(Qt.SolidLine)
        view.options().setGridLinePen(pen)

    @QtCore.Slot(int)
    def selectGridLineStyles(self, index):
        view = self.grid.view()
        if index == 0:
            view.options().setGridLines(Qtitan.LinesNone)
        elif index == 1:
            view.options().setGridLines(Qtitan.LinesBoth)
        elif index == 2:
            view.options().setGridLines(Qtitan.LinesBoth2D)
        elif index == 3:
            view.options().setGridLines(Qtitan.LinesHorizontal)
        elif index == 4:
            view.options().setGridLines(Qtitan.LinesHorizontal2D)
        elif index == 5:
            view.options().setGridLines(Qtitan.LinesVertical)
        elif index == 6:
            view.options().setGridLines(Qtitan.LinesVertical2D)
        else:
            view.options().setGridLines(Qtitan.LinesBoth)

    @QtCore.Slot(int)
    def zoomEnabledChanged(self, state):
        view = self.grid.view()
        view.options().setZoomEnabled(Qt.CheckState(state) == Qt.Checked)

    @QtCore.Slot(int)
    def zoomIndicatorChanged(self, state):
        view = self.grid.view()
        view.options().setZoomIndicatorActive(Qt.CheckState(state) == Qt.Checked)

    @QtCore.Slot(int)
    def zoomValueChanged(self, value):
        factor = (float(value) / 25) * 25
        view = self.grid.view()
        view.options().setZoomFactor(factor / 100)

    @QtCore.Slot(int)
    def cellButtonAutoRaiseEnabled(self, state):
        view = self.grid.view()
        view.options().setCellButtonAutoRaise(Qt.CheckState(state) == Qt.Checked)

    @QtCore.Slot(int)
    def frozenRowsEnabled(self, state):
        view = self.grid.view()
        view.tableOptions().setRowFrozenButtonVisible(Qt.CheckState(state) == Qt.Checked)
        view.tableOptions().setFrozenPlaceQuickSelection(Qt.CheckState(state) == Qt.Checked)

    @QtCore.Slot(int)
    def transparentBackgroundEnabled(self, state):
        view = self.grid.view()
        view.options().setTransparentBackground(Qt.CheckState(state) == Qt.Checked)
        view.options().setAlternatingRowColors(not view.options().alternatingRowColors())

    @QtCore.Slot(GridEditor)
    def editorModifying(self, editor):
        editor = editor

    @QtCore.Slot(EditorValidationEventArgs)
    def editorValidating(self, args):
        args.setValueValid(True)
        #args.setEditingValue(args.editValue())
        args.setHandled(True)

    @QtCore.Slot(ContextMenuEventArgs)
    def contextMenu(self, args):
        args.contextMenu().addAction("Print Preview", self, QtCore.SLOT("printPreview()"))
        args.contextMenu().addSeparator()
        args.contextMenu().addAction("Developer Machines on the Web", self, QtCore.SLOT("showCompanyWebSite()"))

    @QtCore.Slot(CellButtonClickEventArgs)
    def cellButtonClicked(self, args):
        QMessageBox.information(self, "Cell button clicked",
            "Clicked: Button - " + str(args.buttonIndex()) + ", Column Title - " + args.column().caption() + ", RowIndex - " + str(args.row().rowIndex()))

    @QtCore.Slot()
    def printPreview(self):
        self.grid.view().printPreview()

    def setShadeColor(self, color):
        self.grid.themeManager().setShadeColor(color)

    @QtCore.Slot(int)
    def updateGridData(self):
        view = self.grid.view()
        view.options().setShowWaitCursor(False)
        model = view.model()
        if model != None:
            i = model.data(model.index(0, 0))
            if i >= 100:
                self.up = False
            elif i < 0:
                self.up = True

            if self.up:
                i = i + 2
            else:
                i = i - 2
            model.setData(model.index(0, 0), i)
        view.options().setShowWaitCursor(True)

if __name__ == "__main__":
    app = QApplication(sys.argv)
    w = Window()
    w.show()
    sys.exit(app.exec_())