конвертировать .ui в .py файл, который содержит повышенный кадр

Question

У меня есть .h файл , и ему соответствует .cpp файл , который является виджетом контроллера частоты.Я могу использовать его в QtCreator и C ++, без проблем добавив виджет Qframe в этот файл .h.но я хочу построить пользовательский интерфейс в QTDesigner и преобразовать его в python, используя pyuic5.Конечно, Pyuic5 не может понять коды C ++, и даже в файле .ui нет ни подсказки, ни ссылки на файл .cpp!Итак, как я могу преобразовать и использовать форму, которая содержит продвинутый код QFrame для кода Python и использовать его в приложении PyQT?

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>MainWindow</class>
 <widget class="QMainWindow" name="MainWindow">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>456</width>
    <height>280</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>MainWindow</string>
  </property>
  <widget class="QWidget" name="centralwidget">
   <widget class="CFreqCtrl" name="freqCtrl">
    <property name="geometry">
     <rect>
      <x>80</x>
      <y>70</y>
      <width>280</width>
      <height>40</height>
     </rect>
    </property>
    <property name="sizePolicy">
     <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
      <horstretch>0</horstretch>
      <verstretch>0</verstretch>
     </sizepolicy>
    </property>
    <property name="minimumSize">
     <size>
      <width>280</width>
      <height>40</height>
     </size>
    </property>
    <property name="toolTip">
     <string/>
    </property>
    <property name="frameShape">
     <enum>QFrame::StyledPanel</enum>
    </property>
    <property name="frameShadow">
     <enum>QFrame::Raised</enum>
    </property>
   </widget>
  </widget>
 </widget>
 <customwidgets>
  <customwidget>
   <class>CFreqCtrl</class>
   <extends>QFrame</extends>
   <header>freqctrl.h</header>
   <container>1</container>
  </customwidget>
 </customwidgets>
 <resources/>
 <connections/>
</ui>

Answer 1

pyuic - это всего лишь инструмент, который преобразует .ui в .py, так что он сделал это, сгенерировав следующее:

pyuic5 file.ui -o file_ui.py -x

file_ui.py

# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'file.ui'
#
# Created by: PyQt5 UI code generator 5.12.1
#
# WARNING! All changes made in this file will be lost!

from PyQt5 import QtCore, QtGui, QtWidgets


class Ui_MainWindow(object):
    def setupUi(self, MainWindow):
        MainWindow.setObjectName("MainWindow")
        MainWindow.resize(456, 280)
        self.centralwidget = QtWidgets.QWidget(MainWindow)
        self.centralwidget.setObjectName("centralwidget")
        self.freqCtrl = CFreqCtrl(self.centralwidget)
        self.freqCtrl.setGeometry(QtCore.QRect(80, 70, 280, 40))
        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
        sizePolicy.setHorizontalStretch(0)
        sizePolicy.setVerticalStretch(0)
        sizePolicy.setHeightForWidth(self.freqCtrl.sizePolicy().hasHeightForWidth())
        self.freqCtrl.setSizePolicy(sizePolicy)
        self.freqCtrl.setMinimumSize(QtCore.QSize(280, 40))
        self.freqCtrl.setToolTip("")
        self.freqCtrl.setFrameShape(QtWidgets.QFrame.StyledPanel)
        self.freqCtrl.setFrameShadow(QtWidgets.QFrame.Raised)
        self.freqCtrl.setObjectName("freqCtrl")
        MainWindow.setCentralWidget(self.centralwidget)

        self.retranslateUi(MainWindow)
        QtCore.QMetaObject.connectSlotsByName(MainWindow)

    def retranslateUi(self, MainWindow):
        _translate = QtCore.QCoreApplication.translate
        MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))


from freqctrl import CFreqCtrl


if __name__ == "__main__":
    import sys
    app = QtWidgets.QApplication(sys.argv)
    MainWindow = QtWidgets.QMainWindow()
    ui = Ui_MainWindow()
    ui.setupUi(MainWindow)
    MainWindow.show()
    sys.exit(app.exec_())

И, как вы можете видеть, он имеет следующую инструкцию from freqctrl import CFreqCtrl, указывающую, что вы хотите импортировать класс CFreqCtrl, который должен быть в файле freqctrlv.py.

PyQt5 или pyuic5 не в состоянииЧтобы понять код C ++, ваша задача - вручную перенести код C ++ на python, другой вариант - создать привязку с помощью SIP, используйте первый параметр:

freqctrl.py

from enum import Enum, auto
from PyQt5 import QtCore, QtGui, QtWidgets

class FctlUnit(Enum):
    FCTL_UNIT_NONE = 0
    FCTL_UNIT_HZ = auto()
    FCTL_UNIT_KHZ = auto()
    FCTL_UNIT_MHZ = auto()
    FCTL_UNIT_GHZ = auto()
    FCTL_UNIT_SEC = auto()
    FCTL_UNIT_MSEC = auto()
    FCTL_UNIT_USEC = auto()
    FCTL_UNIT_NSEC = auto()


FCTL_MAX_DIGITS = 12
FCTL_MIN_DIGITS = 4

# Manual adjustment of Font size as percent of control height
DIGIT_SIZE_PERCENT = 90
UNITS_SIZE_PERCENT = 60

# adjustment for separation between digits
SEPRATIO_N = 100 # separation rectangle size ratio numerator times 100
SEPRATIO_D = 3  # separation rectangle size ratio denominator

STATUS_TIP = "Scroll or left-click to increase/decrease digit. " \
             "Right-click to clear digits."

class CFreqCtrl(QtWidgets.QFrame):
    newFrequency = QtCore.pyqtSignal(int)

    def __init__(self, parent=None):
        super(CFreqCtrl, self).__init__(parent)
        self.m_UnitsRect = QtCore.QRect()
        self.m_Pixmap = QtGui.QPixmap()
        self.m_UnitsFont = QtGui.QFont()

        self.m_DigitInfo = [
            {"weight": 0, "incval": 0, "dQRect": QtCore.QRect(), "val": 0, "modified": False, "editmode": False}
            for _ in range(FCTL_MAX_DIGITS) 
        ]
        self.m_SepRect = [QtCore.QRect() for _ in range(FCTL_MAX_DIGITS)]
        self.m_LeadZeroPos = 0
        self.setAutoFillBackground(False)
        self.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
        self.setFocusPolicy(QtCore.Qt.StrongFocus)
        self.setMouseTracking(True)
        self.m_BkColor = QtGui.QColor(0x1F, 0x1D, 0x1D, 0xFF)
        self.m_DigitColor = QtGui.QColor(0xFF, 0xFF, 0xFF, 0xFF)
        self.m_HighlightColor = QtGui.QColor(0x5A, 0x5A, 0x5A, 0xFF)
        self.m_UnitsColor = QtCore.Qt.gray
        self.m_freq = 0;
        self.setup(0, 1, 4000000000, 1, FctlUnit.FCTL_UNIT_NONE)
        self.m_Oldfreq = 0
        self.m_LastLeadZeroPos = 0
        self.m_LRMouseFreqSel = False
        self.m_ActiveEditDigit = -1
        self.m_ResetLowerDigits = True
        self.fm_UnitsFont = QtGui.QFont("Arial", 12, QtGui.QFont.Normal)
        self.m_DigitFont = QtGui.QFont("Arial", 12, QtGui.QFont.Normal);
        self.setStatusTip(self.tr(STATUS_TIP))

    def minimumSizeHint(self):
        return QtCore.QSize(100, 20)

    def sizeHint(self):
        return QtCore.QSize(100, 20)

    @staticmethod
    def fmax_to_numdigits(fmax):
        if fmax < 10e6:
            return 7
        elif fmax < 100e6:
            return 8
        elif fmax < 1e9:
            return 9
        elif fmax < 10e9:
            return 10
        elif fmax < 100e9:
            return 11
        return 12

    def setup(self, NumDigits, Minf, Maxf, MinStep, unit):
        pwr = 1
        self.m_LastEditDigit = 0
        self.m_Oldfreq = -1
        self.m_NumDigits = NumDigits if NumDigits else CFreqCtrl.fmax_to_numdigits(Maxf)
        self.m_NumDigits = min(max(self.m_NumDigits, FCTL_MIN_DIGITS), FCTL_MAX_DIGITS)
        self.m_UnitString = ""
        self.m_MinStep = 1 if MinStep == 0 else MinStep
        self.m_MinFreq = Minf
        self.m_MaxFreq = Maxf
        self.m_freq = min(max(self.m_freq, self.m_MinFreq), self.m_MaxFreq)
        for i in range(self.m_NumDigits):
            self.m_DigitInfo[i]["weight"] = pwr
            self.m_DigitInfo[i]["incval"] = pwr
            self.m_DigitInfo[i]["modified"] = True
            self.m_DigitInfo[i]["editmode"] = False
            self.m_DigitInfo[i]["val"] = 0
            pwr *= 10
        if self.m_MaxFreq > pwr: self.m_MaxFreq = pwr - 1
        self.m_MaxFreq -= self.m_MaxFreq % self.m_MinStep
        if self.m_MinFreq > pwr: self.m_MinFreq = 1
        self.m_MinFreq -= self.m_MinFreq % self.m_MinStep
        self.m_DigStart = 0
        self.setUnit(unit)
        for i in range(self.m_NumDigits-1, -1, -1):
            if self.m_DigitInfo[i]["weight"] <= self.m_MinStep:
                if self.m_DigStart == 0:
                    self.m_DigitInfo[i]["incval"] = self.m_MinStep
                    self.m_DigStart = i
                else:
                    if (self.m_MinStep % self.m_DigitInfo[i + 1]["weight"]) != 0:
                        self.m_DigStart = i
                    self.m_DigitInfo[i]["incval"] = 0
        self.m_NumSeps = (self.m_NumDigits - 1) / 3 - self.m_DigStart / 3

    def setFrequency(self, freq):
        acc = 0
        if freq == self.m_Oldfreq:
            return
        freq = max(min(freq, self.m_MaxFreq), self.m_MinFreq)
        self.m_freq = freq - freq % self.m_MinStep
        rem = self.m_freq
        self.m_LeadZeroPos = self.m_NumDigits
        for i in range(self.m_NumDigits - 1, self.m_DigStart-1, -1):
            val = int(rem /self. m_DigitInfo[i]["weight"])
            if self.m_DigitInfo[i]["val"] != val:
                self.m_DigitInfo[i]["val"] = val
                self.m_DigitInfo[i]["modified"] = True
            rem -= (val * self.m_DigitInfo[i]["weight"])
            acc += val
            if acc == 0 and i > self.m_DecPos:
                self.m_LeadZeroPos = i

        if self.m_Oldfreq * self.m_freq < 0 and self.m_DigitInfo[self.m_LeadZeroPos - 1]["val"] == 0:
            self.m_DigitInfo[self.m_LeadZeroPos - 1]["modified"] = True
        if self.m_freq < 0:
            if self.m_DigitInfo[self.m_LeadZeroPos - 1]["val"] > 0:
                self.m_DigitInfo[self.m_LeadZeroPos - 1]["val"] *= -1

        for i in range(self.m_LeadZeroPos - 1):
            if self.m_DigitInfo[i]["val"] < 0:
                self.m_DigitInfo[i]["val"] *= -1
        self.m_Oldfreq = self.m_freq
        self.newFrequency.emit(self.m_freq)
        self.updateCtrl(self.m_LastLeadZeroPos != self.m_LeadZeroPos)
        self.m_LastLeadZeroPos = self.m_LeadZeroPos

    def setDigitColor(self, col):
        self.m_UpdateAll = True
        self.m_DigitColor = col;
        for i in range(self.m_DigStart, self.m_NumDigits):
            self.m_DigitInfo[i]["modified"] = True
            self.updateCtrl(True)

    def setUnit(self, unit):
        self.m_NumDigitsForUnit = 0 if unit == FctlUnit.FCTL_UNIT_NONE else 2
        d = {
            FctlUnit.FCTL_UNIT_NONE: (0, ""),
            FctlUnit.FCTL_UNIT_HZ: (0, "Hz"),
            FctlUnit.FCTL_UNIT_KHZ: (3, "KHz"),
            FctlUnit.FCTL_UNIT_MHZ: (6, "MHz"),
            FctlUnit.FCTL_UNIT_GHZ: (9, "GHz"),
            FctlUnit.FCTL_UNIT_SEC: (6, "Sec"),
            FctlUnit.FCTL_UNIT_MSEC: (3, "mS"),
            FctlUnit.FCTL_UNIT_USEC: (0, "uS"),
            FctlUnit.FCTL_UNIT_NSEC: (0, "nS")
        }
        self.m_DecPos, self.m_UnitString = d[unit]
        self. m_Unit = unit
        self.m_UpdateAll = True
        self.updateCtrl(True)

    def setBgColor(self, col):
        self.m_UpdateAll = True
        self.m_BkColor = col
        for i in range(self.m_DigStart, self.m_NumDigits):
            self.m_DigitInfo[i]["modified"] = True
        self.updateCtrl(True)

    def setUnitsColor(self, col):
        self.m_UpdateAll = True
        self.m_UnitsColor = col
        self.updateCtrl(True);

    def setHighlightColor(self, col):
        self.m_UpdateAll = True
        self.m_HighlightColor = col
        self.updateCtrl(True)

    def updateCtrl(self, _all):
        if _all:
            self.m_UpdateAll = True
            for i in range(self.m_DigStart, self.m_NumDigits):
                self.m_DigitInfo[i]["modified"] = True
        self.update()


    def resizeEvent(self, event):
        self.m_Pixmap = QtGui.QPixmap(self.size())
        self.m_Pixmap.fill(self.m_BkColor)
        self.m_UpdateAll = True
        self.updateCtrl(True)

    def leaveEvent(self, event):
        if self.m_ActiveEditDigit >= 0:
            if self.m_DigitInfo[self.m_ActiveEditDigit]["editmode"]:
                self.m_DigitInfo[self.m_ActiveEditDigit]["editmode"] = False
                self.m_DigitInfo[self.m_ActiveEditDigit]["modified"] = True;
                self.m_ActiveEditDigit = -1
                self.updateCtrl(False)

    def paintEvent(self, event):
        painter = QtGui.QPainter(self.m_Pixmap)
        if self.m_UpdateAll:
            self.drawBkGround(painter)
            self.m_UpdateAll = False
        self.drawDigits(painter)
        scrnpainter = QtGui.QPainter(self)
        scrnpainter.drawPixmap(0, 0, self.m_Pixmap)

    def mouseMoveEvent(self, event):
        pt = event.pos()
        if self.isActiveWindow():
            if not self.hasFocus():
                self.setFocus(QtCore.Qt.MouseFocusReason)
            for i in range(self.m_DigStart, self.m_NumDigits):
                if self.m_DigitInfo[i]["dQRect"].contains(pt):
                    if not self.m_DigitInfo[i]["editmode"]:
                        self.m_DigitInfo[i]["editmode"] = True
                        self.m_ActiveEditDigit = i
                else:
                    if self.m_DigitInfo[i]["editmode"]:
                        self.m_DigitInfo[i]["editmode"] = False
                        self.m_DigitInfo[i]["modified"] = True
            self.updateCtrl(False)

    def mousePressEvent(self, event):
        pt = event.pos()
        if event.button() == QtCore.Qt.LeftButton:
            for i in range(self.m_DigStart, self.m_NumDigits):
                if self.m_DigitInfo[i]["dQRect"].contains(pt):
                    if self.m_LRMouseFreqSel:
                        self.incFreq()
                    else:
                        if pt.y() < self.m_DigitInfo[i]["dQRect"].bottom():
                            self.incFreq()
                        else:
                            self.decFreq()
        elif event.button() == QtCore.Qt.RightButton:
            for i in range(self.m_DigStart, self.m_NumDigits):
                if self.m_DigitInfo[i]["dQRect"].contains(pt):
                    if self.m_LRMouseFreqSel:
                        self.decFreq()
                    else:
                        self.clearFreq()

    def wheelEvent(self, event):
        pt = event.pos()
        numDegrees = event.angleDelta().y() / 8
        numSteps = numDegrees / 15
        for i in range(self.m_DigStart, self.m_NumDigits):
            if self.m_DigitInfo[i]["dQRect"].contains(pt):
                if numSteps > 0:
                    self.incFreq()
                elif numSteps < 0:
                    self.decFreq()

    def keyPressEvent(self, event):
        fSkipMsg = False
        if event.key() in (QtCore.Qt.Key_0, QtCore.Qt.Key_1, QtCore.Qt.Key_2, 
            QtCore.Qt.Key_3, QtCore.Qt.Key_4, QtCore.Qt.Key_5, QtCore.Qt.Key_6, 
            QtCore.Qt.Key_7, QtCore.Qt.Key_8, QtCore.Qt.Key_9,):
            if self.m_ActiveEditDigit >= 0:
                if self.m_DigitInfo[self.m_ActiveEditDigit]["editmode"]:
                    tmp = int((self.m_freq / self.m_DigitInfo[self.m_ActiveEditDigit]["weight"]) % 10)
                    self.m_freq -= tmp * self.m_DigitInfo[self.m_ActiveEditDigit]["weight"]
                    self.m_freq += (event.key() - ord('0')) * self.m_DigitInfo[self.m_ActiveEditDigit]["weight"]
                    self.setFrequency(self.m_freq)
            self.moveCursorRight()
            fSkipMsg = True
        elif event.key() in (QtCore.Qt.Key_Backspace, QtCore.Qt.Key_Left,):
            if self.m_ActiveEditDigit != -1:
                self.moveCursorLeft()
                fSkipMsg = True;
        elif event.key() == QtCore.Qt.Key_Up:
            if self.m_ActiveEditDigit != -1:
                self.incFreq()
                fSkipMsg = True
        elif event.key() == QtCore.Qt.Key_Down:
            if self.m_ActiveEditDigit != -1:
                self.decFreq()
                fSkipMsg = True
        elif event.key() == QtCore.Qt.Key_Right:
            if self.m_ActiveEditDigit != -1:
                self.moveCursorRight()
                fSkipMsg = True
        elif event.key() == QtCore.Qt.Key_Home:
            self.cursorHome()
            fSkipMsg = True
        if event.key() == QtCore.Qt.Key_End:
            self.cursorEnd()
            fSkipMsg = True

        if not fSkipMsg:
            super(CFreqCtrl, self).keyPressEvent(event)

    def drawBkGround(self, painter):
        rect = self.rect()
        cellwidth = int(100 * rect.width() / (100 * (self.m_NumDigits + self.m_NumDigitsForUnit) + (self.m_NumSeps * SEPRATIO_N) / SEPRATIO_D))
        sepwidth = int((SEPRATIO_N * cellwidth) / (100 * SEPRATIO_D))
        if self.m_Unit != FctlUnit.FCTL_UNIT_NONE:
            self.m_UnitsRect.setRect(rect.right() - 2 * cellwidth, rect.top(), 2 * cellwidth, rect.height())
            painter.fillRect(self.m_UnitsRect, self.m_BkColor)
            self.m_UnitsFont.setPixelSize((UNITS_SIZE_PERCENT * rect.height()) / 100)
            self.m_UnitsFont.setFamily("Arial")
            painter.setFont(self.m_UnitsFont)
            painter.setPen(self.m_UnitsColor)
            painter.drawText(self.m_UnitsRect, QtCore.Qt.AlignCenter, self.m_UnitString)
        self.m_DigitFont.setPixelSize((DIGIT_SIZE_PERCENT * rect.height()) / 100)
        self.m_DigitFont.setFamily("Arial")
        painter.setFont(self.m_DigitFont)
        painter.setPen(self.m_DigitColor)
        dgsep = ' '
        digpos = rect.right() - self.m_NumDigitsForUnit * cellwidth - 1
        for i in range(self.m_DigStart, self.m_NumDigits):
            if i > self.m_DigStart and (i % 3) == 0:
                self.m_SepRect[i].setCoords(digpos - sepwidth, rect.top(), digpos, rect.bottom())
                painter.fillRect(self.m_SepRect[i], self.m_BkColor)
                digpos -= sepwidth
                if self.m_Unit == FctlUnit.FCTL_UNIT_NONE:
                    dgsep = '.' if self.m_LeadZeroPos > i else ' '
                else:
                    dgsep = '.' if i == self.m_DecPos else ' '
                painter.drawText(self.m_SepRect[i], QtCore.Qt.AlignCenter, dgsep)
            else:
                self.m_SepRect[i].setCoords(0, 0, 0, 0)
            self.m_DigitInfo[i]["dQRect"].setCoords(digpos - cellwidth, rect.top(), digpos, rect.bottom())
            digpos -= cellwidth

    def drawDigits(self, painter):
        painter.setFont(self.m_DigitFont)
        self.m_FirstEditableDigit = self.m_DigStart
        for i in range(self.m_DigStart, self.m_NumDigits):
            if self.m_DigitInfo[i]["incval"] == 0: 
                self.m_FirstEditableDigit += 1
            if self.m_DigitInfo[i]["modified"] or self.m_DigitInfo[i]["editmode"]:
                if self.m_DigitInfo[i]["editmode"] and self.m_DigitInfo[i]["incval"] != 0:
                    painter.fillRect(self.m_DigitInfo[i]["dQRect"], self.m_HighlightColor)
                else:
                    painter.fillRect(self.m_DigitInfo[i]["dQRect"], self.m_BkColor)
                painter.setPen(self.m_BkColor if i >= self.m_LeadZeroPos else self.m_DigitColor)
                if self.m_freq < 0 and i == self.m_LeadZeroPos - 1 and self.m_DigitInfo[i]["val"] == 0:
                    painter.drawText(self.m_DigitInfo[i]["dQRect"], QtCore.Qt.AlignCenter, "-0")
                else:
                    painter.drawText(self.m_DigitInfo[i]["dQRect"], QtCore.Qt.AlignCenter, str(self.m_DigitInfo[i]["val"]))
                self.m_DigitInfo[i]["modified"] = False

    def incDigit(self):
        if self.m_ActiveEditDigit >= 0:
            if self.m_DigitInfo[self.m_ActiveEditDigit]["editmode"]:
                if self.m_DigitInfo[self.m_ActiveEditDigit]["weight"] == self.m_DigitInfo[self.m_ActiveEditDigit]["incval"]:
                    tmp = int((self.m_freq / self.m_DigitInfo[self.m_ActiveEditDigit]["weight"]) % 10)
                    self.m_freq -= tmp * self.m_DigitInfo[self.m_ActiveEditDigit]["weight"]
                    tmp += 1
                    if tmp > 9: tmp = 0
                    self.m_freq += int(tmp*self.m_DigitInfo[self.m_ActiveEditDigit]["weight"])
                else:
                    tmp = int((self.m_freq / self.m_DigitInfo[self.m_ActiveEditDigit + 1]["weight"]) % 10)
                    tmpl = self.m_freq + self.m_DigitInfo[m_ActiveEditDigit]["incval"]
                    if tmp != int((tmpl / m_DigitInfo[m_ActiveEditDigit + 1]["weight"]) %10):
                        tmpl -= self.m_DigitInfo[self.m_ActiveEditDigit + 1]["weight"]
                    self.m_freq = tmpl
                self.setFrequency(self.m_freq)

    def incFreq(self):
        if self.m_ActiveEditDigit >= 0:
            if self.m_DigitInfo[self.m_ActiveEditDigit]["editmode"]:
                self.m_freq += self.m_DigitInfo[self.m_ActiveEditDigit]["incval"]
                if self.m_ResetLowerDigits:
                    self.m_freq -= self.m_freq % self.m_DigitInfo[self.m_ActiveEditDigit]["weight"]
                self.setFrequency(self.m_freq)
                self.m_LastEditDigit = self.m_ActiveEditDigit

    def decDigit(self):
        if self.m_ActiveEditDigit >= 0:
            if self.m_DigitInfo[m_ActiveEditDigit]["editmode"]:
                if self.m_DigitInfo[self.m_ActiveEditDigit]["weight"] == self. m_DigitInfo[self.m_ActiveEditDigit]["incval"]:
                    tmp = int((m_freq / m_DigitInfo[m_ActiveEditDigit]["weight"]) % 10)
                    self.m_freq -= tmp * self.m_DigitInfo[self.m_ActiveEditDigit]["weight"]
                    tmp -= 1                
                    if tmp < 0: tmp = 9
                    self.m_freq += int(tmp *m_DigitInfo[m_ActiveEditDigit]["weight"])
                else:
                    tmp = int((self.m_freq / self.m_DigitInfo[self.m_ActiveEditDigit + 1]["weight"]) % 10)
                    tmpl = m_freq - self.m_DigitInfo[self.m_ActiveEditDigit]["incval"]
                    if tmp != int((tmpl / m_DigitInfo[m_ActiveEditDigit + 1]["weight"]) % 10):
                        tmpl += self.m_DigitInfo[self.m_ActiveEditDigit + 1]["weight"]
                    self.m_freq = tmpl
                self.setFrequency(self.m_freq)

    def decFreq(self):
        if self.m_ActiveEditDigit >= 0:
            if self.m_DigitInfo[self.m_ActiveEditDigit]["editmode"]:
                self.m_freq -= self.m_DigitInfo[self.m_ActiveEditDigit]["incval"]
                if self.m_ResetLowerDigits:
                    self.m_freq -= self.m_freq % self.m_DigitInfo[self.m_ActiveEditDigit]["weight"]
                self.setFrequency(self.m_freq)
                self.m_LastEditDigit = self.m_ActiveEditDigit

    def clearFreq(self):
        if self.m_ActiveEditDigit >= 0:
            if self.m_DigitInfo[self.m_ActiveEditDigit]["editmode"]:
                self.m_freq -= self.m_DigitInfo[self.m_ActiveEditDigit]["val"] * self.m_DigitInfo[self.m_ActiveEditDigit]["incval"]
                self.m_freq -= self.m_freq % self.m_DigitInfo[self.m_ActiveEditDigit]["weight"]
                self.setFrequency(self.m_freq)
                self.m_LastEditDigit = self.m_ActiveEditDigit

    def moveCursorLeft(self):
        if 0 <= self.m_ActiveEditDigit < (self.m_NumDigits - 1):
            self.m_ActiveEditDigit += 1
            self.cursor().setPos(self.mapToGlobal(self.m_DigitInfo[self.m_ActiveEditDigit]["dQRect"].center()))

    def moveCursorRight(self):
        if self.m_ActiveEditDigit > self.m_FirstEditableDigit:
            self.m_ActiveEditDigit -= 1
            self.cursor().setPos(self.mapToGlobal(self.m_DigitInfo[self.m_ActiveEditDigit]["dQRect"].center()))

    def cursorHome(self):
        if self.m_ActiveEditDigit >= 0:
            self.cursor().setPos(self.mapToGlobal(self.m_DigitInfo[self.m_NumDigits - 1]["dQRect"].center()))

    def cursorEnd(self):
        if self.m_ActiveEditDigit > 0:
            self.cursor().setPos(self.mapToGlobal(self.m_DigitInfo[self.m_FirstEditableDigit]["dQRect"].center()))

if __name__ == '__main__':
    import sys
    app = QtWidgets.QApplication(sys.argv)
    w = CFreqCtrl()
    w.setup(10, 0, 1e10, 1, FctlUnit.FCTL_UNIT_GHZ)
    w.setFrequency(1234567890)
    w.show()
    sys.exit(app.exec_())

Answer 2

Если вы используете PyQt5, вы можете использовать функцию loadUi из PyQt5.uic.Не уверен, что есть эквивалент для PyQt4.

# imports
.
.
.
from PyQt5.uic import loadUi

# ui file:
ui_file = 'MyUI_file.ui'

# window implementation
class MyDialog(QMainWindow):
    def __init__(self):
        super(testDialog, self).__init__()
        loadUi(ui_file, self)
#... etc.
    # access the ui elements by their names. eg:
    self.frameShape.Property = xyz

HTH, Y.