Beispiel #1
0
class Airspeed_Tape(QGraphicsView):
    def __init__(self, parent=None):
        super(Airspeed_Tape, self).__init__(parent)
        self.myparent = parent
        self.update_period = None
        self.setStyleSheet("background-color: rgba(32, 32, 32, 75%)")
        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.setRenderHint(QPainter.Antialiasing)
        self.setFocusPolicy(Qt.NoFocus)
        self.item = fix.db.get_item("IAS")
        self.item.valueChanged[float].connect(self.setAirspeed)
        self.item.oldChanged[bool].connect(self.setAsOld)
        self.item.badChanged[bool].connect(self.setAsBad)
        self.item.failChanged[bool].connect(self.setAsFail)
        self._airspeed = self.item.value

        # V Speeds
        self.Vs = self.item.get_aux_value('Vs')
        self.Vs0 = self.item.get_aux_value('Vs0')
        self.Vno = self.item.get_aux_value('Vno')
        self.Vne = self.item.get_aux_value('Vne')
        self.Vfe = self.item.get_aux_value('Vfe')
        self.max = int(round(self.Vne*1.25))

        self.pph = 10 # Pixels per unit
        self.fontsize = 20

    def resizeEvent(self, event):
        if self.update_period is None:
            self.update_period = self.myparent.get_config_item('update_period')
            if self.update_period is None:
                self.update_period = .1
            self.last_update_time = 0
        w = self.width()
        h = self.height()
        self.markWidth = w / 5
        f = QFont()
        f.setPixelSize(self.fontsize)
        tape_height = self.max * self.pph + h
        tape_start = self.max * self.pph + h/2

        dialPen = QPen(QColor(Qt.white))

        self.scene = QGraphicsScene(0, 0, w, tape_height)
        self.scene.addRect(0, 0, w, tape_height,
                           QPen(QColor(32, 32, 32, 10)), QBrush(QColor(32, 32, 32, 10)))

        # Add Markings
        # Green Bar
        r = QRectF(QPoint(0,              -self.Vno * self.pph + tape_start),
                   QPoint(self.markWidth, -self.Vs0 * self.pph + tape_start))
        self.scene.addRect(r, QPen(QColor(0,155,0)), QBrush(QColor(0,155,0)))

        # White Bar
        r = QRectF(QPoint(self.markWidth / 2,              -self.Vs0 * self.pph + tape_start),
                   QPoint(self.markWidth, -self.Vfe * self.pph + tape_start))
        self.scene.addRect(r, QPen(Qt.white), QBrush(Qt.white))

        # Yellow Bar
        r = QRectF(QPoint(0,              -self.Vno * self.pph + tape_start),
                   QPoint(self.markWidth, -self.Vne * self.pph + tape_start))
        self.scene.addRect(r, QPen(Qt.yellow), QBrush(Qt.yellow))

        # Draw the little white lines and the text
        for i in range(self.max, -1, -5):
            if i % 10 == 0:
                self.scene.addLine(0, (- i * self.pph) + tape_start, w / 2,
                                   (- i * self.pph) + tape_start, dialPen)
                t = self.scene.addText(str(i))
                t.setFont(f)
                self.scene.setFont(f)
                t.setDefaultTextColor(QColor(Qt.white))
                t.setX(w - t.boundingRect().width())
                t.setY(((- i * self.pph) + tape_start)
                       - t.boundingRect().height() / 2)
            else:
                self.scene.addLine(0, (- i * self.pph) + tape_start,
                                   w / 2 - 20, (- i * self.pph) + tape_start,
                                   dialPen)

        # Red Line
        vnePen = QPen(QColor(Qt.red))
        vnePen.setWidth(4)
        self.scene.addLine(0, -self.Vne * self.pph + tape_start,
                           30, -self.Vne * self.pph + tape_start,
                           vnePen)

        self.numerical_display = NumericalDisplay(self)
        nbh = 50
        self.numerical_display.resize (34, nbh)
        self.numeric_box_pos = QPoint(w-38, h/2-nbh/2)
        self.numerical_display.move(self.numeric_box_pos)
        self.numeric_box_pos.setY(self.numeric_box_pos.y()+nbh/2)
        self.numerical_display.show()
        self.numerical_display.value = self._airspeed
        self.setAsOld(self.item.old)
        self.setAsBad(self.item.bad)
        self.setAsFail(self.item.fail)

        self.setScene(self.scene)
        self.centerOn(self.scene.width() / 2,
                      -self._airspeed * self.pph + tape_start)

    def redraw(self):
        if not self.isVisible():
            return
        now = time.time()
        if now - self.last_update_time >= self.update_period:
            tape_start = self.max * self.pph + self.height()/2

            self.resetTransform()
            self.centerOn(self.scene.width() / 2,
                          -self._airspeed * self.pph + tape_start)
            self.numerical_display.value = self._airspeed
            self.last_update_time = now

    #  Index Line that doesn't move to make it easy to read the airspeed.
    def paintEvent(self, event):
        super(Airspeed_Tape, self).paintEvent(event)
        w = self.width()
        h = self.height()
        p = QPainter(self.viewport())
        p.setRenderHint(QPainter.Antialiasing)

        marks = QPen(Qt.white, 3)
        p.translate(self.numeric_box_pos.x(), self.numeric_box_pos.y())
        p.setPen(marks)
        p.setBrush(QBrush(Qt.black))
        triangle_size = 6
        p.drawConvexPolygon(QPolygon([QPoint(0, -triangle_size),
                             QPoint(0, triangle_size),
                             QPoint(-triangle_size, 0)]))

    def getAirspeed(self):
        return self._airspeed

    def setAirspeed(self, airspeed):
        if airspeed != self._airspeed:
            self._airspeed = airspeed
            self.redraw()

    airspeed = property(getAirspeed, setAirspeed)

    def setAsOld(self,b):
        self.numerical_display.old = b

    def setAsBad(self,b):
        self.numerical_display.bad = b

    def setAsFail(self,b):
        self.numerical_display.fail = b
Beispiel #2
0
class Altimeter_Tape(QGraphicsView):
    def __init__(self, parent=None, maxalt=50000, fontsize=15):
        super(Altimeter_Tape, self).__init__(parent)
        self.setStyleSheet("background-color: rgba(32, 32, 32, 75%)")
        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.setRenderHint(QPainter.Antialiasing)
        self.setFocusPolicy(Qt.NoFocus)
        self.fontsize = fontsize
        self.item = fix.db.get_item("ALT")
        self._altimeter = self.item.value
        self.maxalt = maxalt
        self.pph = 0.3
        self.item.valueChanged[float].connect(self.setAltimeter)
        self.item.oldChanged[bool].connect(self.setAltOld)
        self.item.badChanged[bool].connect(self.setAltBad)
        self.item.failChanged[bool].connect(self.setAltFail)


    def resizeEvent(self, event):
        w = self.width()
        w_2 = w/2
        h = self.height()
        f = QFont()
        f.setPixelSize(self.fontsize)
        self.height_pixel = self.maxalt*self.pph + h

        dialPen = QPen(QColor(Qt.white))
        dialPen.setWidth(2)

        self.scene = QGraphicsScene(0, 0, w, self.height_pixel)
        self.scene.addRect(0, 0, w, self.height_pixel,
                           QPen(QColor(32, 32, 32, 10)), QBrush(QColor(32, 32, 32, 10)))

        for i in range(self.maxalt, -1, -100):
            y = self.y_offset(i)
            if i % 200 == 0:
                self.scene.addLine(w_2 + 15, y, w, y, dialPen)
                t = self.scene.addText(str(i))
                t.setFont(f)
                self.scene.setFont(f)
                t.setDefaultTextColor(QColor(Qt.white))
                t.setX(0)
                t.setY(y - t.boundingRect().height() / 2)
            else:
                self.scene.addLine(w_2 + 30, y, w, y, dialPen)
        self.setScene(self.scene)

        self.numerical_display = NumericalDisplay(self, total_decimals=5, scroll_decimal=2)
        nbh=50
        self.numerical_display.resize (50, nbh)
        self.numeric_box_pos = QPoint(3, h/2-nbh/2)
        self.numerical_display.move(self.numeric_box_pos)
        self.numeric_box_pos.setX(self.numeric_box_pos.x()+self.numerical_display.width())
        self.numeric_box_pos.setY(self.numeric_box_pos.y()+nbh/2)
        self.numerical_display.show()
        self.numerical_display.value = self._altimeter
        self.centerOn(self.scene.width() / 2, self.y_offset(self._altimeter))
        self.setAltOld(self.item.old)
        self.setAltBad(self.item.bad)
        self.setAltFail(self.item.fail)

    def y_offset(self, alt):
        return self.height_pixel - (alt*self.pph) - self.height()/2

    def redraw(self):
        self.resetTransform()
        self.centerOn(self.scene.width() / 2, self.y_offset(self._altimeter))
        self.numerical_display.value = self._altimeter

    #  Index Line that doesn't move to make it easy to read the altimeter.
    def paintEvent(self, event):
        super(Altimeter_Tape, self).paintEvent(event)
        w = self.width()
        h = self.height()
        p = QPainter(self.viewport())
        p.setRenderHint(QPainter.Antialiasing)

        marks = QPen(Qt.white, 3)
        p.translate(self.numeric_box_pos.x(), self.numeric_box_pos.y())
        p.setPen(marks)
        p.setBrush(QBrush(Qt.black))
        triangle_size = 6
        p.drawConvexPolygon(QPolygon([QPoint(0, -triangle_size),
                             QPoint(0, triangle_size),
                             QPoint(triangle_size, 0)]))

    def getAltimeter(self):
        return self._altimeter

    def setAltimeter(self, altimeter):
        if altimeter != self._altimeter:
            self._altimeter = altimeter
            self.redraw()

    altimeter = property(getAltimeter, setAltimeter)

    def setAltOld(self,b):
        self.numerical_display.old = b

    def setAltBad(self,b):
        self.numerical_display.bad = b

    def setAltFail(self,b):
        self.numerical_display.fail = b
Beispiel #3
0
class Altimeter_Tape(QGraphicsView):
    def __init__(self, parent=None, maxalt=50000, fontsize=15):
        super(Altimeter_Tape, self).__init__(parent)
        self.setStyleSheet("background-color: rgba(32, 32, 32, 75%)")
        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.setRenderHint(QPainter.Antialiasing)
        self.setFocusPolicy(Qt.NoFocus)
        self.fontsize = fontsize
        self.item = fix.db.get_item("ALT")
        self._altimeter = self.item.value
        self.maxalt = maxalt
        self.pph = 0.3
        self.myparent = parent
        self.update_period = None

    def resizeEvent(self, event):
        if self.update_period is None:
            self.update_period = self.myparent.get_config_item('update_period')
            if self.update_period is None:
                self.update_period = .1
            self.last_update_time = 0
        w = self.width()
        w_2 = w / 2
        h = self.height()
        f = QFont()
        f.setPixelSize(self.fontsize)
        self.height_pixel = self.maxalt * self.pph + h

        dialPen = QPen(QColor(Qt.white))
        dialPen.setWidth(2)

        self.scene = QGraphicsScene(0, 0, w, self.height_pixel)
        self.scene.addRect(0, 0, w, self.height_pixel,
                           QPen(QColor(32, 32, 32, 10)),
                           QBrush(QColor(32, 32, 32, 10)))

        for i in range(self.maxalt, -1, -100):
            y = self.y_offset(i)
            if i % 200 == 0:
                self.scene.addLine(w_2 + 15, y, w, y, dialPen)
                t = self.scene.addText(str(i))
                t.setFont(f)
                self.scene.setFont(f)
                t.setDefaultTextColor(QColor(Qt.white))
                t.setX(0)
                t.setY(y - t.boundingRect().height() / 2)
            else:
                self.scene.addLine(w_2 + 30, y, w, y, dialPen)
        self.setScene(self.scene)

        self.numerical_display = NumericalDisplay(self,
                                                  total_decimals=5,
                                                  scroll_decimal=2)
        nbh = 50
        self.numerical_display.resize(50, nbh)
        self.numeric_box_pos = QPoint(3, h / 2 - nbh / 2)
        self.numerical_display.move(self.numeric_box_pos)
        self.numeric_box_pos.setX(self.numeric_box_pos.x() +
                                  self.numerical_display.width())
        self.numeric_box_pos.setY(self.numeric_box_pos.y() + nbh / 2)
        self.numerical_display.show()
        self.numerical_display.value = self._altimeter
        self.centerOn(self.scene.width() / 2, self.y_offset(self._altimeter))
        self.setAltOld(self.item.old)
        self.setAltBad(self.item.bad)
        self.setAltFail(self.item.fail)
        self.item.valueChanged[float].connect(self.setAltimeter)
        self.item.oldChanged[bool].connect(self.setAltOld)
        self.item.badChanged[bool].connect(self.setAltBad)
        self.item.failChanged[bool].connect(self.setAltFail)

    def y_offset(self, alt):
        return self.height_pixel - (alt * self.pph) - self.height() / 2

    def redraw(self):
        now = time.time()
        if now - self.last_update_time < self.update_period:
            return
        self.last_update_time = now
        self.resetTransform()
        self.centerOn(self.scene.width() / 2, self.y_offset(self._altimeter))
        self.numerical_display.value = self._altimeter

    #  Index Line that doesn't move to make it easy to read the altimeter.
    def paintEvent(self, event):
        super(Altimeter_Tape, self).paintEvent(event)
        w = self.width()
        h = self.height()
        p = QPainter(self.viewport())
        p.setRenderHint(QPainter.Antialiasing)

        marks = QPen(Qt.white, 3)
        p.translate(self.numeric_box_pos.x(), self.numeric_box_pos.y())
        p.setPen(marks)
        p.setBrush(QBrush(Qt.black))
        triangle_size = 6
        p.drawConvexPolygon(
            QPolygon([
                QPoint(0, -triangle_size),
                QPoint(0, triangle_size),
                QPoint(triangle_size, 0)
            ]))

    def getAltimeter(self):
        return self._altimeter

    def setAltimeter(self, altimeter):
        if altimeter != self._altimeter:
            self._altimeter = altimeter
            self.redraw()

    altimeter = property(getAltimeter, setAltimeter)

    def setAltOld(self, b):
        self.numerical_display.old = b

    def setAltBad(self, b):
        self.numerical_display.bad = b

    def setAltFail(self, b):
        self.numerical_display.fail = b