Python QGraphicsScene.addPixmap方法代码示例

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import addPixmap [as 别名]
 def on_imagesTree_currentItemChanged(self, current, previous):
     """
     Private slot to show a preview of the selected image.
     
     @param current current image entry (QTreeWidgetItem)
     @param previous old current entry (QTreeWidgetItem)
     """
     if current is None:
         return
     
     imageUrl = QUrl(current.text(1))
     if not imageUrl.host():
         imageUrl.setHost(QUrl(self.siteAddressLabel.text()).host())
         imageUrl.setScheme(QUrl(self.siteAddressLabel.text()).scheme())
     
     import Helpviewer.HelpWindow
     cache = Helpviewer.HelpWindow.HelpWindow.networkAccessManager().cache()
     if cache:
         cacheData = cache.data(imageUrl)
     else:
         cacheData = None
     pixmap = QPixmap()
     invalidPixmap = False
     scene = QGraphicsScene(self.imagePreview)
     if not cacheData:
         invalidPixmap = True
     else:
         pixmap.loadFromData(cacheData.readAll())
         if pixmap.isNull():
             invalidPixmap = True
     if invalidPixmap:
         scene.addText(self.tr("Preview not available."))
     else:
         scene.addPixmap(pixmap)
     self.imagePreview.setScene(scene)

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import addPixmap [as 别名]
class SampleImageWidget(QWidget):

  def __init__(self, parent=None):

    super(SampleImageWidget, self).__init__(parent)

    self.graphicsScene = QGraphicsScene(self)
    self.graphicsView = SampleGraphicsView(self.graphicsScene)

  def setSampleImage(self, pathToFile):

    self.graphicsView.hide()

    #clear scene
    self.graphicsScene.clear()

    #load file
    tmpImage = QImage(pathToFile)
    self.originalHeight = tmpImage.height()
    self.originalWidth = tmpImage.width()
    tmpPixmap = QPixmap(1)
    tmpPixmap.convertFromImage(tmpImage.scaledToWidth(300))
    self.scaledHeight = tmpPixmap.height()
    self.scaledWidth = tmpPixmap.width()

    #add to scene and show
    self.graphicsScene.addPixmap(tmpPixmap)
    self.graphicsView.show()

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import addPixmap [as 别名]
    def showogrenci(self):
        try:
            ogrenci = OgrenciGoster(self.parent)
            self.parent.mdi.addSubWindow(ogrenci)
            ogrenci.show()
            data = self.sender().data

            ogrenci.ad.setText(data[1])
            ogrenci.soyad.setText(data[2])
            ogrenci.anneadi.setText(data[4])
            ogrenci.babaadi.setText(data[5])

            gp = QGraphicsScene(self)
            ogrenci.graphicsView.setScene(gp)
            ogrenci.graphicsView.setFixedHeight(100)
            ogrenci.graphicsView.setFixedWidth(100)
            if data[8] is not None:
                gp.addPixmap(QPixmap("db/%s" % data[8]))
                ogrenci.graphicsView.show()

            nots = self.parent.db.getNot(data[0])
            ogrenci.tableWidget.setRowCount(len(nots))
            ogrenci.tableWidget.setColumnCount(1)
            ogrenci.tableWidget.setHorizontalHeaderLabels(["Notlar"])
            z = 0
            for i in nots:

                ogrenci.tableWidget.setItem(z,0,QTableWidgetItem(i[2]))
                z +=1

        except Exception as e:
            print(e)

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import addPixmap [as 别名]
 def __init__(self, conf, defeat):
     self.config = conf
     super().__init__()
     self.setWindowTitle(conf.get_text('victory'))
     self.setFixedSize(QSize(640, 480))
     self.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.WindowTitleHint | Qt.FramelessWindowHint)
     button = QPushButton(conf.get_text('close'), self)
     button.setCheckable(True)
     button.setFixedSize(QSize(640, 30))
     button.move(0, 450)
     # noinspection PyUnresolvedReferences
     button.clicked.connect(self.close)
     result_output = QTextEdit(self)
     result_output.setReadOnly(True)
     result_output.setFixedSize(QSize(640, 200))
     result_output.move(0, 250)
     result_output.setLineWrapMode(QTextEdit.NoWrap)
     result_output.insertHtml(self.generate_result_text())
     gview = QGraphicsView(self)
     scene = QGraphicsScene()
     if defeat:
         img = conf.theme_selected.get_defeat_pixmap()
         text = conf.get_text('defeat')
     else:
         img = conf.theme_selected.get_victory_pixmap()
         text = conf.get_text('victory')
     scene.addPixmap(img.scaled(QSize(640, 220)))
     gview.move(0, 30)
     gview.setScene(scene)
     label_title = QLabel(self)
     label_title.setText(text)
     label_title.setFixedSize(QSize(640, 30))
     label_title.setAlignment(Qt.AlignCenter)
     label_title.setFont(self.get_font_title())

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import addPixmap [as 别名]
    def __init__(self, parent, bank_name, required_input):
        DialogContainer.__init__(self, parent)

        self.required_input = required_input

        uic.loadUi(get_ui_file_path('iom_input_dialog.ui'), self.dialog_widget)

        self.dialog_widget.cancel_button.clicked.connect(lambda: self.button_clicked.emit(0))
        self.dialog_widget.confirm_button.clicked.connect(lambda: self.button_clicked.emit(1))

        if 'error_text' in required_input:
            self.dialog_widget.error_text_label.setText(required_input['error_text'])
        else:
            self.dialog_widget.error_text_label.hide()

        if 'image' in required_input['additional_data']:
            qimg = QImage()
            qimg.loadFromData(b64decode(required_input['additional_data']['image']))
            image = QPixmap.fromImage(qimg)
            scene = QGraphicsScene(self.dialog_widget.img_graphics_view)
            scene.addPixmap(image)
            self.dialog_widget.img_graphics_view.setScene(scene)
        else:
            self.dialog_widget.img_graphics_view.hide()

        self.dialog_widget.iom_input_title_label.setText(bank_name)

        vlayout = QVBoxLayout()
        self.dialog_widget.user_input_container.setLayout(vlayout)

        self.input_widgets = {}

        for specific_input in self.required_input['required_fields']:
            label_widget = QLabel(self.dialog_widget.user_input_container)
            label_widget.setText(specific_input['text'] + ":")
            label_widget.show()
            vlayout.addWidget(label_widget)

            input_widget = QLineEdit(self.dialog_widget.user_input_container)
            input_widget.setPlaceholderText(specific_input['placeholder'])
            if specific_input['type'] == 'password':
                input_widget.setEchoMode(QLineEdit.Password)

            input_widget.show()
            vlayout.addWidget(input_widget)
            self.input_widgets[specific_input['name']] = input_widget

        self.dialog_widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
        self.dialog_widget.adjustSize()

        self.on_main_window_resize()

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import addPixmap [as 别名]
def go():
    global graphic_view, status_label
    data_parent, data_child = Pipe(duplex=False)
    receiver = Process(target=generate_data, args=(data_child,))
    receiver.daemon = True
    receiver.start()

    scene = QGraphicsScene()
    graphic_view.setScene(scene)
    scene.setSceneRect(0, 0, 1024, 1024)

    x_pos = 0
    y_pos = 0
    t = time.time()
    while True:
        speed = time.time()
        data = data_parent.recv()
        spectrogram = Spectrogram(data)
        pixmap = QPixmap.fromImage(spectrogram.create_spectrogram_image(transpose=True))

        scene.setSceneRect(scene.sceneRect().adjusted(0, 0, 0, pixmap.height()))
        item = scene.addPixmap(pixmap)
        item.setPos(x_pos, y_pos)
        y_pos += pixmap.height()
        graphic_view.fitInView(scene.sceneRect())
        status_label.setText("Height: {0:.0f} // Speed: {1:.2f}  // Total Time: {2:.2f}".format(scene.sceneRect().height(),
                                                                                                1/(time.time()-speed),
                                                                                                time.time()-t))
        QApplication.instance().processEvents()

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import addPixmap [as 别名]
def main():

    app = QApplication(sys.argv)

    grview = QGraphicsView()
    scene = QGraphicsScene()
    scene.setSceneRect(0, 0, 680, 459)

    scene.addPixmap(QPixmap('../images/phototest.tif'))
    grview.setScene(scene)

    item = AreaItem(0, 0, 300, 150)
    item.areaColor = QColor(155, 155, 0, 75)
    scene.addItem(item)

    grview.fitInView(scene.sceneRect(), Qt.KeepAspectRatio)
    grview.show()
    sys.exit(app.exec_())

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import addPixmap [as 别名]
    def getAll(self,filter={}):
        self.tableWidget.clear()
        try:
            data = self.parent.db.get(filter)
            self.tableWidget.setRowCount(len(data))
            self.tableWidget.setColumnCount(5)
            self.tableWidget.setHorizontalHeaderLabels(["Resim","Ad","Soyad","No"])


            iz = 0

            for i in data:
                ad = QTableWidgetItem(i[1])
                soyad = QTableWidgetItem(i[2])
                no = QTableWidgetItem(i[3])
                gp = QGraphicsScene(self)

                resim = QGraphicsView(gp)
                resim.setFixedHeight(100)
                resim.setFixedWidth(100)
                if i[8] is not None:
                    gp.addPixmap(QPixmap("db/%s" % i[8]))
                    resim.show()

                self.tableWidget.setCellWidget(iz,0,resim)

                btn = QPushButton(self)
                btn.setText("Göster")
                btn.data = i
                btn.clicked.connect(self.showogrenci)
                self.tableWidget.setItem(iz,1,ad)
                self.tableWidget.setItem(iz,2,soyad)
                self.tableWidget.setItem(iz,3,no)
                self.tableWidget.setCellWidget(iz,4,btn)
                self.tableWidget.setRowHeight(iz,100)


                iz +=1
        except Exception as e:
            print(e)

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import addPixmap [as 别名]
    def start_beep(self):

        drawbars = str(self.verticalSlider_1.value()) + \
                   str(self.verticalSlider_2.value()) + \
                   str(self.verticalSlider_3.value()) + \
                   str(self.verticalSlider_4.value()) + \
                   str(self.verticalSlider_5.value()) + \
                   str(self.verticalSlider_6.value()) + \
                   str(self.verticalSlider_7.value()) + \
                   str(self.verticalSlider_8.value()) + \
                   str(self.verticalSlider_9.value())

        duration = self.doubleSpinBox_1.value()

        tonic_number = (12 * self.spinBox.value() + self.tonic_combo)
        tonic_frequency = 2 ** (( tonic_number - 57) / 12) * self.doubleSpinBox_2.value()
        self.statusbar.showMessage(
            'Fundamental frequency: {0:.2f} Hz. Press Enter to synthesize next sound.'.format(tonic_frequency))

        if self.radioButton_2.isChecked():
            frequencies = [tonic_frequency * 2 ** (x / 12) for x in range(len(self.pushButtons))]
        else:
            frequencies = [tonic_frequency * x for x in
                           [1, 256 / 243, 9 / 8, 32 / 27, 81 / 64, 4 / 3, 1024 / 729, 729 / 512, 3 / 2, 128 / 81,
                            27 / 16, 16 / 9, 243 / 128]]

        for i in range(len(self.pushButtons)):
            if not self.pushButtons[i].isChecked():
                frequencies[i] = 0

        t, x = self.synth.make_chord(frequencies, drawbars, duration, self.checkBox.isChecked())

        self.synth.play(x)
        xbar, inst_ph = self.synth.make_analytical(x)
        filename = 'synth.png'
        self.synth.plot_hilbert(xbar, filename)

        scene = QGraphicsScene()
        scene.addPixmap(QPixmap(filename))
        self.graphicsView.setScene(scene)

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import addPixmap [as 别名]
def visualize_data(window, data_manager, search_results):
    # Scene where everything will be drawn
    scene = QGraphicsScene()

    reference_radiograph = data_manager.left_out_radiograph
    reference_image = reference_radiograph.image
    reference_teeth = data_manager.get_all_teeth_from_radiograph(reference_radiograph)

    # Draw reference image first
    qimg = toQImage(reference_image.astype(np.uint8))
    scene.addPixmap(QPixmap.fromImage(qimg))

    for tooth in reference_teeth:
        assert isinstance(tooth, Tooth)
        tooth.outline_pen = QPen(QColor.fromRgb(0, 0, 255))
        tooth.draw(scene)

    if search_results is not None:
        for tooth in search_results:
            assert isinstance(tooth, Tooth)
            tooth.draw(scene)

    window.set_scene(scene)

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import addPixmap [as 别名]
class Image_View(QGraphicsView):
    def __init__(self, centralwidget):
        super(Image_View, self).__init__(centralwidget)

        self.scene = QGraphicsScene()
        self.pixmap = QPixmap()
        self.painter = Painter()

        self.setup_ui()

    def setup_ui(self):
        # GraphicsItem
        self.scene.addPixmap(self.pixmap)
        self.scene.addItem(self.painter)

        self.setScene(self.scene)
        self.setCacheMode(QGraphicsView.CacheBackground)

    # defs from super class
    def keyPressEvent(self, event):
        key = event.key()
        if key == Qt.Key_R:
            self.painter.reset()

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import addPixmap [as 别名]
	def init(self):
		self.window = loadUi(os.path.join(get_ui_path(),"splash.ui"))
		self.window.setWindowFlags(Qt.FramelessWindowHint|Qt.WindowStaysOnTopHint)
		self.center()
		self.window.li.setText(notice()+"\n"+version())
		self.window.setModal(Qt.WindowModal)
		self.window.image.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
		self.window.image.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)

		window_h=self.window.height()
		window_w=self.window.width()
		r=random.randint(2, 3)
		image=QPixmap(os.path.join(get_image_file_path(),"splash"+str(r)+".png"))
		image.scaledToHeight(window_h)

		w=image.width()
		h=image.height()
		x_max=w-window_h-window_w/2

		hour=float(time.strftime("%H"))*60
		m=float(time.strftime("%m"))
		tot=hour+m
		my_max=float(24*60)

		value=tot/my_max

		xpos=int(x_max*value)+window_w/2
		print("xpos=",xpos)
		scene=QGraphicsScene();
		scene.setSceneRect(xpos, 0, 0, h)
		self.window.image.setScene(scene)

		self.window.show()

		scene.addPixmap(image);

		QTimer.singleShot(1500, self.callback_destroy)

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import addPixmap [as 别名]

#.........这里部分代码省略.........
            label = QLabel()
            slider.setRange(ranges[i][0], ranges[i][1])
            slider.setValue(values[i])
            slider.valueChanged.connect(self._slider_moved)
            layout = QHBoxLayout()
            layout.addWidget(slider)
            layout.addWidget(label)
            self.scrollAreaWidgetContents.layout().addLayout(layout)
            self.sliders.append(slider)
            self.labels.append(label)

        self._set_labels()
        self._redraw()

    def _sampling_level_changed(self, value):
        self.current_sampling_level = value - 1

        self.image = self.base_image
        scale = 1.0
        for i in range(0, self.current_sampling_level):
            self.image = MultiResolutionFramework.downsample_image(self.image)
            scale *= 2

        self.graphicsView.resetTransform()
        self.graphicsView.scale(scale, scale)
        self._redraw()

    def _slider_moved(self, value):
        self._set_labels()
        self._redraw()

    def _set_labels(self):
        for i, label in enumerate(self.labels):
            value = self.sliders[i].value()
            if i < 2:
                value = value * 2 + 1 if value >= 1 else 0
            label.setText(str(value))

    def _scharr_filter(self, img):
        grad_x = cv2.Scharr(img, cv2.CV_64F, 1, 0) / 16
        grad_y = cv2.Scharr(img, cv2.CV_64F, 0, 1) / 16
        grad = np.sqrt(grad_x ** 2 + grad_y ** 2)
        return grad

    def _perform_fft(self, img):
        f = np.fft.fft2(img)
        fshift = np.fft.fftshift(f)
        return fshift

    def _focus_view(self, size):
        if not self.fit_allowed:
            self.fit_allowed = True
            return
        rect = QRectF(0, 0, size[0], size[1])
        self.scene.setSceneRect(rect)

    def _redraw(self):
        self.scene.clear()
        img = self.image.copy()

        med_kernel = self.sliders[0].value() * 2 + 1
        bi_kernel = self.sliders[1].value() * 2 + 1
        bi_color = self.sliders[2].value()

        med = cv2.medianBlur(img, med_kernel) if med_kernel > 1 else img
        med_bi = cv2.bilateralFilter(med, bi_kernel, bi_color, 200) if bi_kernel > 1 else med

        fshift = self._perform_fft(med_bi)
        # scharr = np.array([[ -1/16-1/16j, 1/2-1/8j,  +1/16 -1/16j],
        #                    [-1/8+0j, 1/2+0j, +1/8 +0j],
        #                    [ -1/16+1/16j, 0+1/8j,  +1/16 +1/16j]]) # Gx + j*Gy
        # fshift = signal.convolve2d(fshift, scharr, boundary='symm', mode='same')

        if self.sliders[3].value() != 0:
            rows, cols = img.shape
            crow, ccol = rows / 2, cols / 2
            mask = np.zeros(fshift.shape)
            cv2.circle(mask, (ccol, crow), self.sliders[3].value(), 1, -1)
            cv2.circle(mask, (ccol, crow), self.sliders[4].value(), 0, -1)
            fshift *= mask

        f_ishift = np.fft.ifftshift(fshift)
        img_back = np.fft.ifft2(f_ishift)
        img_back = np.abs(img_back)

        grad_med_bi = self._scharr_filter(img_back)

        # img = (img / img.max()) * 255
        mag = 20 * np.log(np.abs(fshift))
        mag = (mag / mag.max()) * 255
        img_back = (img_back / img_back.max()) * 255
        grad_med_bi = (grad_med_bi / grad_med_bi.max()) * 255

        together = np.hstack(
            (img.astype(np.uint8), mag.astype(np.uint8), img_back.astype(np.uint8), grad_med_bi.astype(np.uint8)))
        cv2.imwrite("together.png", together)
        qimg = toQImage(together)
        self.scene.addPixmap(QPixmap.fromImage(qimg))

        self._focus_view((qimg.width(), qimg.height()))

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import addPixmap [as 别名]
class StaticPhotos(QGraphicsView):
    def __init__(self, photoBaseDir, validPhotoFileExts, photoDeltas, picChangeMs, parent=None):
        QGraphicsView.__init__(self, parent)
        self.setAlignment(Qt.AlignLeft | Qt.AlignTop)
        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) 
        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) 
        # Vars
        self.picChangeMs = picChangeMs
        self.photoBaseDir = photoBaseDir
        # Widget
        self.scene = QGraphicsScene()
        self.setScene(self.scene)
        self.setBackgroundBrush(QColor("black"))
        self.setLineWidth(0)
        self.setFrameShape(QtWidgets.QFrame.NoFrame)
        # Class vars
        self.picChgTimer = None
        self.photoFileManager = PhotoFileManager(validPhotoFileExts, self.photoBaseDir, 7200.00, photoDeltas)
        self.photoFileManager.startPhotoListUpdate()
        self.userMovedBack = False

    # def sizeHint(self):
    #     return QSize(600, 400)

    def resizeEvent(self, evt=None):
        xWindowSize = self.width()
        yWindowSize = self.height()
        pass

    def start(self):
        self.picChgTimer = QTimer()
        self.picChgTimer.setInterval(self.picChangeMs)
        self.picChgTimer.setSingleShot(True)
        self.picChgTimer.timeout.connect(self.picChangeFn)
        self.picChgTimer.start()
        # self.picChangeFn()
        print("Static Photos - starting")

    def stop(self):
        if self.picChgTimer is not None:
            self.picChgTimer.stop()
            print("Static Photos - stopping")
            # self.picChgTimer.disconnect(self.picChangeFn)
        self.photoFileManager.stop()

    def moveNext(self):
        self.nextPicItem()

    def movePrev(self):
        self.prevPicItem()
        self.userMovedBack = True

    def reshow(self):
        self.showImage()

    def getCurPhotoFilename(self):
        return self.photoFileManager.getCurPhotoFilename()

    def picChangeFn(self):
        # pass
        if self.userMovedBack:
            # Skip this update
            self.userMovedBack = False
        else:
            self.nextPicItem()
        self.picChgTimer.setInterval(self.picChangeMs)
        self.picChgTimer.start()

    def loadImage(self):
        self.newImg = QImage()
        self.newImg.load(self.photoFileManager.getCurPhotoFilename())
        self.newImgInfo = self.photoFileManager.getCurPhotoInfo()
        transform = QTransform()
        transform.rotate(self.newImgInfo.rotationAngle)
        self.interImg = self.newImg.transformed(transform, Qt.SmoothTransformation)
        # xReqdSize = self.cellSize.width() * xFactor + self.xBetweenPics * (xFactor-1)
        # yReqdSize = self.cellSize.height() * yFactor + self.yBetweenPics * (yFactor-1)
        self.inter2Img = self.interImg.scaled(QSize(self.width(),self.height()),
                                                    Qt.KeepAspectRatio, Qt.SmoothTransformation)
        # finalImg = interImg.copy(0,0,xReqdSize,yReqdSize)
        # print("XY Size", xFactor, yFactor, xReqdSize,yReqdSize)
        return self.inter2Img, self.newImgInfo

    def showImage(self):
        (newImg, newImgInfo) = self.loadImage()
        # return PicItem(Pixmap(QPixmap(newImg)), -1, -1, xFactor, yFactor, newImgInfo)
        self.scene.clear()
        imgSz = newImgInfo.imgSize
        self.setSceneRect(QRectF(0,0,imgSz.width(), imgSz.height()))
        pixMap = QPixmap.fromImage(newImg)
        # # pixMap.setWidth(self.width())
        pixMapItem = self.scene.addPixmap(pixMap)
        # pixMapItem.setPos(50,50)
        # self.fitInView(QRectF(0, 0, self.width(), self.height()), Qt.KeepAspectRatio)
        # Add caption
        caption = QGraphicsTextItem()
        caption.setDefaultTextColor(QColor(255,255,255))
        caption.setPos(0, self.height()*0.94)
        caption.setFont(QFont("Segoe UI", 30))
        caption.setTextWidth(self.width())
#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import addPixmap [as 别名]

#.........这里部分代码省略.........
        mb = QMessageBox.information(
            self, "О программе",
            "Программа удаленного управления рабочим столом.\n\n"
            "Создатели:\n"
            "Алексей Абакумкин, ИУ7-72\n"
            "Роман Инфлянскас, ИУ7-71\n"
            "(c) 2014, Москва, МГТУ им. Н. Э. Баумана")

    def critical(self, msg, log=True):
        self.revert()
        QMessageBox.critical(self, "Ошибка", msg)
        if log:
            logging.error("{ip}\t{msg}\tОшибка".format(ip=self.client.ip, msg=msg))

    def send_incorrect_message(self):
        if self.connected:
            try:
                self.client.send_incorrect_message()
            except:
                # mb = QMessageBox.critical(self, "Ошибка", "Сервер перестал отвечать")
                self.critical("Сервер перестал отвечать")

    def refresh(self):
        self.serverList.clear()
        self.refreshLabel.setVisible(True)
        self.repaint()

        for x in self.client.refresh_server_list():
            self.serverList.addItem("{0}:{1}".format(x[0], x[1]))

        self.refreshLabel.setVisible(False)

    def connect(self):
        if self.connected:
            self.revert()
            self.client.disconnect()
            return

        try:
            login, login_ok = QInputDialog.getText(self, 'Логин', 'Введите логин:')
            if login_ok:
                passwd, password_ok = QInputDialog.getText(self, 'Пароль', 'Введите пароль:', 2)
                if password_ok:
                    server_item = self.serverList.currentItem()
                    try:
                        address = server_item.text().split(":")
                    except:
                        # server_item = self.serverList.findItems('', 0)[0]
                        self.serverList.setCurrentRow(0)
                        server_item = self.serverList.currentItem()
                        address = server_item.text().split(":")
                    if self.client.connect_to_server(address, login, passwd):
                        self.connectButton.setText("Отключиться")
                        self.connected = True
                    else:
                        self.critical("Неверный логин или пароль!", log=False)
                        # mb = QMessageBox.critical(self, "Ошибка", "Неверный логин или пароль!")

        except TimeoutError:
            self.critical("Сервер перестал отвечать")
            # mb = QMessageBox.critical(self, "Ошибка", "Сервер перестал отвечать")

    def revert(self):
        self._graphics_scene.clear()
        self.connectButton.setText("Присоединиться")
        self.connected = False

    def paintEvent(self, QPaintEvent):
        if self.connected:
            try:
                self.image_base_64 = self.client.recieve_screenshot()
            except TimeoutError:
                self.critical("Сервер перестал отвечать")
                # mb = QMessageBox.critical(self, "Ошибка", "Сервер перестал отвечать")
                return


            self.data = QByteArray.fromBase64(self.image_base_64)
            self.pm = QPixmap()
            self.pm.loadFromData(self.data, "PNG")

            self._graphics_scene.clear()
            self._graphics_scene.addPixmap(self.pm)
            self.update()

    def mouse_pressed(self, event):
        if self.connected:
            x = int(event.scenePos().x())
            y = int(event.scenePos().y())

            button = event.button()
            if button == 4:
                button = 3

            try:
                self.client.send_mouse_event(x, y, button)
            except:
                self.critical("Сервер перестал отвечать")
                # mb = QMessageBox.critical(self, "Ошибка", "Сервер перестал отвечать")
                self.revert()