示例#1
0
	def __init__(self, root_node, parent=None):
		super(AddDeviceDlg, self).__init__(parent)
		self.setWindowTitle("Add Relief Device")

		id_label = QLabel("&Relief Device ID:")
		self.id_lineedit = QLineEdit()
		self.id_lineedit.setMaxLength(200)
		id_label.setBuddy(self.id_lineedit)
		area_label = QLabel("Associated Relief Device &Area:")
		self.area_combobox = QComboBox()
		for area in root_node.children:
			self.area_combobox.addItem(area.name, area)
		area_label.setBuddy(self.area_combobox)
		color_label = QLabel("&Text Color:")
		self.color_combobox = QComboBox()
		for key in sorted(COLORS.keys()):
			pixmap = QPixmap(26, 26)
			pixmap.fill(COLORS[key])
			self.color_combobox.addItem(QIcon(pixmap), key)
		color_label.setBuddy(self.color_combobox)
		button_box = QDialogButtonBox(QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
			
		layout = QGridLayout()
		layout.addWidget(id_label, 0, 0)
		layout.addWidget(self.id_lineedit, 0, 1)
		layout.addWidget(area_label, 1, 0)
		layout.addWidget(self.area_combobox, 1, 1)
		layout.addWidget(color_label, 2, 0)
		layout.addWidget(self.color_combobox, 2, 1)
		layout.addWidget(button_box, 3, 1)
		self.setLayout(layout)
		
		button_box.accepted.connect(self.accept)
		button_box.rejected.connect(self.reject)
示例#2
0
    def drawIconWithShadow(icon, rect, p, iconMode, radius, color, offset):
        cache = QPixmap()
        pixmapName = "icon {0} {1} {2}".format(icon.cacheKey(), iconMode, rect.height())

        if not QPixmapCache.find(pixmapName, cache):
            px = icon.pixmap(rect.size())
            cache = QPixmap(px.size() + QSize(radius * 2, radius * 2))
            cache.fill(Qt.transparent)

            cachePainter = QPainter(cache)
            if iconMode == QIcon.Disabled:
                im = px.toImage().convertToFormat(QImage.Format_ARGB32)
                for y in range(im.height()):
                    scanLine = im.scanLine(y)
                    for x in range(im.width()):
                        pixel = scanLine
                        intensity = qGray(pixel)
                        scanLine = qRgba(intensity, intensity, intensity, qAlpha(pixel))
                        scanLine += 1
                px = QPixmap.fromImage(im)

            # Draw shadow
            tmp = QImage(px.size() + QSize(radius * 2, radius * 2 + 1), QImage.Format_ARGB32_Premultiplied)
            tmp.fill(Qt.transparent)

            tmpPainter = QPainter(tmp)
            tmpPainter.setCompositionMode(QPainter.CompositionMode_Source)
            tmpPainter.drawPixmap(QPoint(radius, radius), px)
            tmpPainter.end()

            # blur the alpha channel
            blurred = QImage(tmp.size(), QImage.Format_ARGB32_Premultiplied)
            blurred.fill(Qt.transparent)
            blurPainter = QPainter(blurred)
            # todo : blur image
            blurPainter.end()

            tmp = blurred

            # blacken the image
            tmpPainter.begin(tmp)
            tmpPainter.setCompositionMode(QPainter.CompositionMode_SourceIn)
            tmpPainter.fillRect(tmp.rect(), color)
            tmpPainter.end()

            tmpPainter.begin(tmp)
            tmpPainter.setCompositionMode(QPainter.CompositionMode_SourceIn)
            tmpPainter.fillRect(tmp.rect(), color)
            tmpPainter.end()

            # draw the blurred drop shadow...
            cachePainter.drawImage(QRect(0, 0, cache.rect().width(), cache.rect().height()), tmp)

            # Draw the actual pixmap...
            cachePainter.drawPixmap(QPoint(radius, radius) + offset, px)
            QPixmapCache.insert(pixmapName, cache)

        targetRect = cache.rect()
        targetRect.moveCenter(rect.center())
        p.drawPixmap(targetRect.topLeft() - offset, cache)
示例#3
0
 def _update_cursor(self):
     x = self.diameter
     w, h = x, x
     pixmap = QPixmap(w, h)
     pixmap.fill(Qt.transparent)
     p = QPainter(pixmap)
     p.drawPoints(self._points)
     p.end()
     self._cursor_pixmap = pixmap.createMaskFromColor(Qt.transparent)
示例#4
0
    def size_changed(self, value):
        "Handle the slider drag event."

        size = self.ui.brush_demo_label.size()
        pixmap = QPixmap(100, 100)
        pixmap.fill(Qt.white)
        cx, cy = int(size.width() / 2), int(size.height() / 2)
        self.current_brush.set_size(value)
        self.current_brush.draw_marker(cx, cy, pixmap, 1)
        self.ui.brush_demo_label.setPixmap(pixmap)
示例#5
0
    def size_changed(self, value):
        "Handle the slider drag event."

        size = self.ui.brush_demo_label.size()
        pixmap = QPixmap(100, 100)
        pixmap.fill(Qt.white)
        cx, cy = int(size.width()/2), int(size.height()/2)
        self.current_brush.set_size(value)
        self.current_brush.draw_marker(cx, cy, pixmap, 1)
        self.ui.brush_demo_label.setPixmap(pixmap)
示例#6
0
    def x_bitmap_opaque ( self, bitmap ):
        """ Returns a version of the specified bitmap with no transparency.
        """
        dx = bitmap.width()
        dy = bitmap.height()
        opaque_bitmap = QPixmap( dx, dy )
        opaque_bitmap.fill( WindowColor )
        q = QPainter( opaque_bitmap )
        q.drawPixmap( 0, 0, bitmap )

        return opaque_bitmap
示例#7
0
def choose_color():
    color = QColorDialog().getColor()

    msgbox = QMessageBox()
    if color.isValid():
        pixmap = QPixmap(50, 50)
        pixmap.fill(color)
        msgbox.setWindowTitle(u'Selected Color')
        msgbox.setIconPixmap(pixmap)
    else:
        msgbox.setWindowTitle(u'No Color was Selected')
    msgbox.exec_()
示例#8
0
文件: app5.py 项目: eueung/python
def choose_color():
    color  = QColorDialog().getColor()
    
    msgbox = QMessageBox()
    if color.isValid():
        pixmap = QPixmap(50, 50)
        pixmap.fill(color)
        msgbox.setWindowTitle(u'Selected Color')
        msgbox.setIconPixmap(pixmap)
    else:
        msgbox.setWindowTitle(u'No Color was Selected')
    msgbox.exec_()
示例#9
0
    def __init__(self, dock):
        """Construct a DragDockLabel for the given dock."""
        super(DragDockLabel, self).__init__("Drag Me")

        self.dock = dock
        self.setAcceptDrops(True)
        self.setScaledContents(True)
        self.setAlignment(Qt.AlignHCenter | Qt.AlignTop)
        self.setToolTip("Click and drag to change parent.")

        pm = QPixmap(1, 10)
        pm.fill(Qt.black)
        self.setPixmap(pm)
示例#10
0
    def __init__(self, dock):
        """Construct a DragDockLabel for the given dock."""
        super(DragDockLabel, self).__init__("Drag Me")

        self.dock = dock
        self.setAcceptDrops(True)
        self.setScaledContents(True)
        self.setAlignment(Qt.AlignHCenter | Qt.AlignTop)
        self.setToolTip("Click and drag to change parent.")

        pm = QPixmap(1, 10)
        pm.fill(Qt.black)
        self.setPixmap(pm)
示例#11
0
def choose_color():
    # Select color
    color = QColorDialog().getColor()
    
    # Report about result of selection in QMessageBox dialog
    msgbox = QMessageBox()
    if color.isValid():
        # Create a memory image 50x50 filled with selected color to display
        # as a icon in the msgbox dialog
        pixmap = QPixmap(50, 50)
        pixmap.fill(color)
        msgbox.setWindowTitle(u'Selected Color')
        msgbox.setIconPixmap(pixmap)
    else:
        msgbox.setWindowTitle(u'No Color was Selected')
    msgbox.exec_()
def choose_color():
    # Select color
    color = QColorDialog().getColor()

    # Report about result of selection in QMessageBox dialog
    msgbox = QMessageBox()
    if color.isValid():
        # Create a memory image 50x50 filled with selected color to display
        # as a icon in the msgbox dialog
        pixmap = QPixmap(50, 50)
        pixmap.fill(color)
        msgbox.setWindowTitle(u'Selected Color')
        msgbox.setIconPixmap(pixmap)
    else:
        msgbox.setWindowTitle(u'No Color was Selected')
    msgbox.exec_()
示例#13
0
    def paint(self, painter, option, widget=None):
        """@reimp @public
    virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0)
    """
        #Q_UNUSED(option)
        #Q_UNUSED(widget)
        d = self.__d
        key = d.hash
        pm = QPixmap()
        if not QPixmapCache.find(key, pm):
            # Set up a convenient path
            path = QPainterPath()
            path.setFillRule(Qt.OddEvenFill)
            path.addEllipse(QPointF(d.actualOuterRadius, d.actualOuterRadius),
                            d.actualOuterRadius, d.actualOuterRadius)
            path.addEllipse(QPointF(d.actualOuterRadius, d.actualOuterRadius),
                            d.actualInnerRadius, d.actualInnerRadius)

            nActualDiameter = 2.0 * d.actualOuterRadius
            pm = QPixmap(nActualDiameter, nActualDiameter)
            pm.fill(Qt.transparent)
            p = QPainter(pm)

            # Draw the ring background
            p.setPen(Qt.NoPen)
            p.setBrush(d.backgroundColor)
            p.setRenderHint(QPainter.Antialiasing)
            p.drawPath(path)

            # Draw the ring foreground
            # TODO: Expose this gradient as Qml Property
            gradient = QConicalGradient(d.actualOuterRadius,
                                        d.actualOuterRadius, 0.0)
            gradient.setColorAt(0.0, Qt.transparent)
            gradient.setColorAt(0.05, d.foregroundColor)
            gradient.setColorAt(0.8, Qt.transparent)

            p.setBrush(gradient)
            p.drawPath(path)
            p.end()

            QPixmapCache.insert(key, pm)

        # Draw pixmap at center of item
        w, h = self.width(), self.height()
        sz = min(w, h)
        painter.drawPixmap(0.5 * (w - sz), 0.5 * (h - sz), pm)
示例#14
0
 def generateCursor(self, element):
     cursorPixmap = QPixmap(32,32)
     hotX = element.getAttribute('__hotX')
     if hotX == None:
         hotX = element.width()/2
     hotY = element.getAttribute('__hotY')
     if hotY == None:
         hotY = element.height()/2
     cursorPixmap.fill(Qt.transparent)
     element.moveTo(0,0)
     painter = QPainter()
     painter.begin(cursorPixmap)
     id = element.getAttribute('id')
     assert id != None and isinstance(id,str)
     self.render(painter,"#" + id)
     painter.end()
     return QCursor(cursorPixmap,hotX,hotY)
示例#15
0
    def createColors(self):
        for style in MOAIDebugDrawStyles:
            colorBtn = getattr(self.ui, style + "Color")
            colorBtn.color = QColor(255, 255, 255, 255)
            pixmap = QPixmap(16, 16)
            pixmap.fill(colorBtn.color)

            colorBtn.pixmap = pixmap
            colorBtn.setIcon(pixmap)
            colorBtn.setAutoFillBackground(False)
            colorBtn.setIconSize(QtCore.QSize(16, 16))
            def setColor(self, color):
                self.pixmap.fill(color)
                self.setIcon(self.pixmap)
                self.color = color

            colorBtn.setColor = types.MethodType(setColor, colorBtn)
示例#16
0
    def update_cursor(self, shape, size):
        self.cursor_size = size
        self.shape = shape

        cursor_pix = QPixmap(size, size)
        cursor_pix.fill(Qt.transparent)

        painter = QPainter(cursor_pix)
        painter.setPen(QColor(255, 0, 0))

        if shape == 'circle':
            painter.drawEllipse(0, 0, size - 1, size - 1)
        elif shape == 'square':
            painter.drawRect(0, 0, size - 1, size - 1)
        elif shape == "magic wand":
            magic_wand.render(painter, QRect(0, 0, 20, 20))

        cursor = QCursor(cursor_pix, 0, 0)
        self.setCursor(cursor)
        del painter
class QPixmapQDatastream(UsesQApplication):
    '''QDataStream <<>> QPixmap'''
    def setUp(self):
        super(QPixmapQDatastream, self).setUp()
        self.source_pixmap = QPixmap(100, 100)
        self.source_pixmap.fill(Qt.red)
        self.output_pixmap = QPixmap()
        self.buffer = QByteArray()
        self.read_stream = QDataStream(self.buffer, QIODevice.ReadOnly)
        self.write_stream = QDataStream(self.buffer, QIODevice.WriteOnly)

    def testStream(self):
        self.write_stream << self.source_pixmap

        self.read_stream >> self.output_pixmap

        image = self.output_pixmap.toImage()
        pixel = image.pixel(10, 10)
        self.assertEqual(pixel, QColor(Qt.red).rgba())
        self.assertEqual(self.source_pixmap.toImage(),
                         self.output_pixmap.toImage())
class QPixmapQDatastream(UsesQApplication):
    '''QDataStream <<>> QPixmap'''

    def setUp(self):
        super(QPixmapQDatastream, self).setUp()
        self.source_pixmap = QPixmap(100, 100)
        self.source_pixmap.fill(Qt.red)
        self.output_pixmap = QPixmap()
        self.buffer = QByteArray()
        self.read_stream = QDataStream(self.buffer, QIODevice.ReadOnly)
        self.write_stream = QDataStream(self.buffer, QIODevice.WriteOnly)

    def testStream(self):
        self.write_stream << self.source_pixmap

        self.read_stream >> self.output_pixmap

        image = self.output_pixmap.toImage()
        pixel = image.pixel(10,10)
        self.assertEqual(pixel, QColor(Qt.red).rgba())
        self.assertEqual(self.source_pixmap.toImage(), self.output_pixmap.toImage())
示例#19
0
    def addLayer(self, name, visible, frozen, zValue, color, lineType,
                 lineWeight, print_):
        """
        TOWRITE for :class:`LayerManager`.

        :param `name`: TOWRITE
        :type `name`: QString
        :param `visible`: TOWRITE
        :type `visible`: bool
        :param `frozen`: TOWRITE
        :type `frozen`: bool
        :param `zValue`: TOWRITE
        :type `zValue`: qreal
        :param `color`: TOWRITE
        :type `color`: QRgb
        :param `lineType`: TOWRITE
        :type `lineType`: QString
        :param `lineWeight`: TOWRITE
        :type `lineWeight`: QString
        :param `print_`: TOWRITE
        :type `print_`: bool
        """

        self.layerModel.insertRow(0)
        self.layerModel.setData(self.layerModel.index(0, 0), name)
        self.layerModel.setData(self.layerModel.index(0, 1), visible)
        self.layerModel.setData(self.layerModel.index(0, 2), frozen)
        self.layerModel.setData(self.layerModel.index(0, 3), zValue)

        colorPix = QPixmap(QSize(16, 16))
        colorPix.fill(QColor(color))
        self.layerModel.itemFromIndex(self.layerModel.index(0, 4)).setIcon(
            QIcon(colorPix))
        self.layerModel.setData(self.layerModel.index(0, 4), QColor(color))

        self.layerModel.setData(self.layerModel.index(0, 5), lineType)
        self.layerModel.setData(self.layerModel.index(0, 6), lineWeight)
        self.layerModel.setData(self.layerModel.index(0, 7), print_)
示例#20
0
文件: List.py 项目: ra2003/xindex
 def paintEvent(self, event):
     painter = QStylePainter(self)
     painter.setPen(self.palette().color(QPalette.Text))
     # Draw the combobox frame, focus rect, selected etc.
     opt = QStyleOptionComboBox()
     self.initStyleOption(opt)
     opt.currentText = ""  # Don't draw the raw HTML
     painter.drawComplexControl(QStyle.CC_ComboBox, opt)
     # Draw the icon and text
     painter.drawControl(QStyle.CE_ComboBoxLabel, opt)
     # Draw the HTML
     self.label.setText(self.currentText())
     self.label.adjustSize()
     pixmap = QPixmap(self.label.width(), self.label.height())
     pixmap.fill(Qt.transparent)
     self.label.render(pixmap, renderFlags=QWidget.RenderFlags(0))
     rect = QRect(opt.rect)
     y = (rect.height() - self.label.height()) / 2
     rect.setX(self.fontMetrics().width("n"))
     rect.setY(y)
     rect.setHeight(pixmap.height())
     rect.setWidth(pixmap.width())
     painter.drawPixmap(rect, pixmap, pixmap.rect())
示例#21
0
    def addLayer(self, name, visible, frozen, zValue, color, lineType, lineWeight, print_):
        """
        TOWRITE for :class:`LayerManager`.

        :param `name`: TOWRITE
        :type `name`: QString
        :param `visible`: TOWRITE
        :type `visible`: bool
        :param `frozen`: TOWRITE
        :type `frozen`: bool
        :param `zValue`: TOWRITE
        :type `zValue`: qreal
        :param `color`: TOWRITE
        :type `color`: QRgb
        :param `lineType`: TOWRITE
        :type `lineType`: QString
        :param `lineWeight`: TOWRITE
        :type `lineWeight`: QString
        :param `print_`: TOWRITE
        :type `print_`: bool
        """

        self.layerModel.insertRow(0)
        self.layerModel.setData(self.layerModel.index(0, 0), name)
        self.layerModel.setData(self.layerModel.index(0, 1), visible)
        self.layerModel.setData(self.layerModel.index(0, 2), frozen)
        self.layerModel.setData(self.layerModel.index(0, 3), zValue)

        colorPix = QPixmap(QSize(16, 16))
        colorPix.fill(QColor(color))
        self.layerModel.itemFromIndex(self.layerModel.index(0, 4)).setIcon(QIcon(colorPix))
        self.layerModel.setData(self.layerModel.index(0, 4), QColor(color))

        self.layerModel.setData(self.layerModel.index(0, 5), lineType)
        self.layerModel.setData(self.layerModel.index(0, 6), lineWeight)
        self.layerModel.setData(self.layerModel.index(0, 7), print_)
示例#22
0
class MainWindow(QMainWindow):
    """docstring for MainWindow"""
    def __init__(self, parent=None):
        super(MainWindow, self).__init__(parent)
        self.serviceProvider = 0
        self.popupMenu = None
        self.mapControlButtons = []
        self.mapControlTypes = []
        self.markerObjects = []
        self.setWindowTitle(self.tr('Map Viewer Demo'))

        self.routingManager = None
        self.mapManager = None
        self.mapWidget = None
        self.markerIcon = None
        self.slider = None

        manager = QNetworkConfigurationManager()

        canStartIAP = manager.capabilities() & QNetworkConfigurationManager.CanStartAndStopInterfaces

        configuration = manager.defaultConfiguration()

        if not configuration.isValid or (not canStartIAP and configuration.starte() != QNetworkConfiguration.Active):
            QMessageBox.information(self, self.tr('Map Viewer Demo'),
                                    self.tr('Available Access Points not found.'))
            return

        self.session = QNetworkSession(configuration, self)
        self.session.opened.connect(self.networkSessionOpened)
        self.session.error.connect(self.error)

        self.session.open()
        self.session.waitForOpened()

        self.setProvider('nokia')
        self.setupUi()

    def networkSessionOpened(self):
        pass

    def sliderValueChanged(self, value):
        self.mapWidget.setZoomLevel(value)

    def mapZoomLevelChanged(self, level):
        self.slider.setSliderPosition(int(level))

    def mapTypeChanged(self, newType):
        index = self.mapControlTypes.index(newType)
        if index != -1:
            self.mapControButtons[index].setChecked(True)

    def mapTypeToggled(self, checked):
        if checked:
            button = self.sender()
            index = self.mapControlButtons.index(button)
            if index != -1:
                print index, self.mapControlTypes[index]
                self.mapWidget.setMapType(self.mapControlTypes[index])

    def updateCoords(self, coords):
        if not coords.isValid():
            return

        self.latitudeEdit.setText('%f' % coords.latitude())
        self.longitudeEdit.setText('%f' % coords.longitude())

    def setCoordsClicked(self):
        lat = float(self.latitudeEdit.text())
        lon = float(self.longitudeEdit.text())
        self.mapWidget.setCenter(QGeoCoordinate(lat, lon))

    def setProvider(self, providerId):
        self.serviceProvider = QGeoServiceProvider(providerId)
        if self.serviceProvider.error() != QGeoServiceProvider.NoError:
            QMessageBox.information(self, self.tr('MapViewer Example'),
                                    self.tr('Unable to dinf the %s geoservices plugin.' % providerId))

            qApp.quit()
            return

        self.mapManager = self.serviceProvider.mappingManager()
        self.routingManager = self.serviceProvider.routingManager()

    def error(self, error):
        if error == QNetworkSession.UnknownSessionError:
            msgBox = QMessageBox(self.parent())
            msgBox.setText('This application requires network access to function.')
            msgBox.setInformativeText('Press Cancel to quit the application.')
            msgBox.setStandardButtons(QMessageBox.Retry | QMessageBox.Cancel)
            msgBox.setIcon(QMessageBox.Information)
            msgBox.setDefaultButton(QMessageBox.Retry)
            ret = msgBox.exec_()
            if ret == QMessageBox.Retry:
                QTimer.singleShot(0, self.session.open)
            elif ret == QMessageBox.Cancel:
                self.close()
        elif error == QNetworkSession.SessionAbortedError:
            msgBox = QMessageBox(self.parent())
            msgBox.setText('Out of range of network')
            msgBox.setInformativeText('Move back into range and press Retry, or press Cancel to quit the application')
            msgBox.setStandardButtons(QMessageBox.Retry | QMessageBox.Cancel)
            msgBox.setIcon(QMessageBox.Information)
            msgBox.setDefaultButton(QMessageBox.Retry)
            ret = msgBox.exec_()
            if ret == QMessageBox.Retry:
                QTimer.singleShot(0, self.session.open)
            elif ret == QMessageBox.Cancel:
                self.close()


    def setupUi(self):

        scene = QGraphicsScene(self)
        self.view = QGraphicsView(scene, self)
        self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.view.setVisible(True)
        self.view.setInteractive(True)

        self.createPixmapIcon()

        self.mapWidget = MapWidget(self.mapManager)
        scene.addItem(self.mapWidget)
        self.mapWidget.setCenter(QGeoCoordinate(-8.1, -34.95))
        self.mapWidget.setZoomLevel(5)

        #...
        self.slider = QSlider(Qt.Vertical, self)
        self.slider.setTickInterval(1)
        self.slider.setTickPosition(QSlider.TicksBothSides)
        self.slider.setMaximum(self.mapManager.maximumZoomLevel())
        self.slider.setMinimum(self.mapManager.minimumZoomLevel())

        self.slider.valueChanged[int].connect(self.sliderValueChanged)
        self.mapWidget.zoomLevelChanged[float].connect(self.mapZoomLevelChanged)

        mapControlLayout = QVBoxLayout()

        self.mapWidget.mapTypeChanged.connect(self.mapTypeChanged)

        for mapType in self.mapWidget.supportedMapTypes():
            radio = QRadioButton(self)
            if mapType == QGraphicsGeoMap.StreetMap:
                radio.setText('Street')
            elif mapType == QGraphicsGeoMap.SatelliteMapDay:
                radio.setText('Sattelite')
            elif mapType == QGraphicsGeoMap.SatelliteMapNight:
                radio.setText('Sattelite - Night')
            elif mapType == QGraphicsGeoMap.TerrainMap:
                radio.setText('Terrain')

            if mapType == self.mapWidget.mapType():
                radio.setChecked(True)

            radio.toggled[bool].connect(self.mapTypeToggled)

            self.mapControlButtons.append(radio)
            self.mapControlTypes.append(mapType)
            mapControlLayout.addWidget(radio)

        self.latitudeEdit = QLineEdit()
        self.longitudeEdit = QLineEdit()

        formLayout = QFormLayout()
        formLayout.addRow('Latitude', self.latitudeEdit)
        formLayout.addRow('Longitude', self.longitudeEdit)

        self.captureCoordsButton = QToolButton()
        self.captureCoordsButton.setText('Capture coordinates')
        self.captureCoordsButton.setCheckable(True)

        self.captureCoordsButton.toggled[bool].connect(
                self.mapWidget.setMouseClickCoordQuery)
        self.mapWidget.coordQueryResult.connect(self.updateCoords)

        self.setCoordsButton = QPushButton()
        self.setCoordsButton.setText('Set coordinates')
        self.setCoordsButton.clicked.connect(self.setCoordsClicked)

        buttonLayout = QHBoxLayout()

        buttonLayout.addWidget(self.captureCoordsButton)
        buttonLayout.addWidget(self.setCoordsButton)

        coordControlLayout = QVBoxLayout()
        coordControlLayout.addLayout(formLayout)
        coordControlLayout.addLayout(buttonLayout)

        widget = QWidget(self)
        layout = QGridLayout()
        layout.setRowStretch(0, 1)
        layout.setRowStretch(1, 0)

        topLayout = QGridLayout()
        bottomLayout = QGridLayout()

        topLayout.setColumnStretch(0, 0)
        topLayout.setColumnStretch(1, 1)

        bottomLayout.setColumnStretch(0, 0)
        bottomLayout.setColumnStretch(1, 1)

        topLayout.addWidget(self.slider, 0, 0)
        topLayout.addWidget(self.view, 0, 1)

        bottomLayout.addLayout(mapControlLayout, 0, 0)
        bottomLayout.addLayout(coordControlLayout, 0, 1)

        layout.addLayout(topLayout, 0, 0)
        layout.addLayout(bottomLayout, 1, 0)

        self.layout = layout
        widget.setLayout(layout)
        self.setCentralWidget(widget)

        self.view.setContextMenuPolicy(Qt.CustomContextMenu)

        self.view.customContextMenuRequested.connect(self.customContextMenuRequest)

    def createPixmapIcon(self):
        self.markerIcon = QPixmap(MARKER_WIDTH, MARKER_HEIGHT)
        self.markerIcon.fill(Qt.transparent)

        painter = QPainter(self.markerIcon)

        p1 = QPoint(MARKER_WIDTH / 2, MARKER_HEIGHT - 1)
        p2 = QPoint(MARKER_WIDTH / 2, MARKER_HEIGHT - 1 - MARKER_PIN_LEN)
        pen = QPen(Qt.black)
        pen.setWidth(2)
        pen.setCosmetic(True)
        painter.setPen(pen)
        painter.drawLine(p1, p2)
        ellipse = QRect(0, 0, MARKER_WIDTH - 1, MARKER_HEIGHT - 1)
        pen.setWidth(1)
        painter.setPen(pen)
        color = QColor(Qt.green)
        color.setAlpha(127)
        brush = QBrush(color)
        painter.setBrush(brush)
        painter.drawEllipse(ellipse)

    def resizeEvent(self, event):
        self.view.setSceneRect(QRectF(QPointF(0.0, 0.0), self.view.size()))
        self.mapWidget.resize(self.view.size())

    def showEvent(self, event):
        self.view.setSceneRect(QRectF(QPointF(0.0, 0.0), self.view.size()))
        self.mapWidget.resize(self.view.size())

    def createMenus(self):
        self.popupMenu = QMenu(self)

        # Markers
        subMenuItem = QMenu(self.tr('Marker'), self)
        self.popupMenu.addMenu(subMenuItem)

        menuItem = QAction(self.tr('Set marker'), self)
        subMenuItem.addAction(menuItem)
        menuItem.triggered[bool].connect(self.drawPixmap)

        menuItem = QAction(self.tr('Remove marker'), self)
        subMenuItem.addAction(menuItem)
        menuItem.triggered[bool].connect(self.removePixmaps)

        menuItem = QAction(self.tr('Select objects'), self)
        subMenuItem.addAction(menuItem)
        menuItem.triggered[bool].connect(self.selectObjects)

        # Draw
        subMenuItem = QMenu(self.tr('Draw'), self)
        self.popupMenu.addMenu(subMenuItem)

        menuItem = QAction(self.tr('Rectangle'), self)
        subMenuItem.addAction(menuItem)
        menuItem.triggered[bool].connect(self.drawRect)

        menuItem = QAction(self.tr('Polyline'), self)
        subMenuItem.addAction(menuItem)
        menuItem.triggered[bool].connect(self.drawPolyline)

        menuItem = QAction(self.tr('Polygon'), self)
        subMenuItem.addAction(menuItem)
        menuItem.triggered[bool].connect(self.drawPolygon)

        menuItem = QAction(self.tr('Circle'), self)
        subMenuItem.addAction(menuItem)
        menuItem.triggered[bool].connect(self.drawCircle)

        menuItem = QAction(self.tr('Text'), self)
        subMenuItem.addAction(menuItem)
        menuItem.triggered[bool].connect(self.drawText)

        # Routing
        subMenuItem = QMenu(self.tr('Route'), self)
        self.popupMenu.addMenu(subMenuItem)

        menuItem = QAction(self.tr('Calculate route'), self)
        subMenuItem.addAction(menuItem)
        menuItem.triggered[bool].connect(self.calculateRoute)

    def selectObjects(self):
        for obj in self.mapWidget.mapObjects():
            obj.setSelected(False)

        if len(self.markerObjects) < 2:
            return

        bottomRight = self.markerObjects.pop()
        topLeft = self.markerObjects.pop()

        self.mapWidget.removeMapObject(topLeft)
        self.mapWidget.removeMapObject(bottomRight)

        selectedObjects = self.mapWidget.mapObjectsInScreenRect(
                    QRectF(self.mapWidget.coordinateToScreenPosition(topLeft.coordinate()),
                           self.mapWidget.coordinateToScreenPosition(bottomRight.coordinate()))
                )

        for obj in selectedObjects:
            obj.setSelected(True)

    def drawRect(self):
        if len(self.markerObjects) < 2:
            return

        p1, p2 = self.markerObjects[:2]

        pen = QPen(Qt.white)
        pen.setWidth(2)
        pen.setCosmetic(True)
        fill = QColor(Qt.black)
        fill.setAlpha(65)
        rectangle = QGeoMapRectangleObject(p1.coordinate(), p2.coordinate())
        rectangle.setPen(pen)
        rectangle.setBrush(QBrush(fill))
        self.mapWidget.addMapObject(rectangle)

    def drawPolyline(self):
        path = [mark.coordinate() for mark in self.markerObjects]

        pen = QPen(Qt.white)
        pen.setWidth(2)
        pen.setCosmetic(True)
        polyline = QGeoMapPolylineObject()
        polyline.setPen(pen)
        polyline.setPath(path)

        self.mapWidget.addMapObject(polyline)

    def drawPolygon(self):
        path = [mark.coordinate() for mark in self.markerObjects]

        pen = QPen(Qt.white)
        pen.setWidth(2)
        pen.setCosmetic(True)
        polygon = QGeoMapPolygonObject()
        polygon.setPen(pen)
        fill = QColor(Qt.black)
        fill.setAlpha(65)
        polygon.setBrush(QBrush(fill))
        polygon.setPath(path)

        self.mapWidget.addMapObject(polygon)

    def drawCircle(self):

        if not len(self.markerObjects):
            return

        p1 = self.markerObjects[0]
        center = p1.coordinate()

        radius = 3000 # Meters

        if len(self.markerObjects) >= 2:
            radius = center.distanceTo(self.markerObjects[1].coordinate())

        pen = QPen(Qt.white)
        pen.setWidth(2)
        pen.setCosmetic(True)
        circle = QGeoMapCircleObject(center, radius)
        circle.setPen(pen)
        fill = QColor(Qt.black)
        fill.setAlpha(65)
        circle.setBrush(QBrush(fill))

        self.mapWidget.addMapObject(circle)

    def drawText(self):

        if not len(self.markerObjects):
            return

        start = self.markerObjects[0].coordinate()

        text = QGeoMapTextObject(start, 'Text')

        fill = QColor(Qt.black)
        text.setBrush(fill)
        self.mapWidget.addMapObject(text)

    def calculateRoute(self):
        if len(self.markerObjects) < 2:
            return

        waypoints = [x.coordinate() for x in self.markerObjects[:2]]

        request = QGeoRouteRequest(waypoints)
        self.routeReply = self.routingManager.calculateRoute(request)
        self.routeReply.finished.connect(self.routeFinished)

    def routeFinished(self):

        if not self.routeReply.routes():
            return

        route = QGeoMapRouteObject(self.routeReply.routes()[0])
        routeColor = QColor(Qt.blue)
        routeColor.setAlpha(127)
        pen = QPen(routeColor)
        pen.setWidth(7)
        pen.setCosmetic(True)
        pen.setCapStyle(Qt.RoundCap)
        route.setPen(pen)
        self.mapWidget.addMapObject(route)

    def drawPixmap(self):
        marker = QGeoMapPixmapObject(self.mapWidget.screenPositionToCoordinate(self.lastClicked),
                                    QPoint(-(MARKER_WIDTH / 2), -MARKER_HEIGHT), self.markerIcon)
        self.mapWidget.addMapObject(marker)
        self.markerObjects.append(marker)

    def removePixmaps(self):
        for i in range(len(self.markerObjects)):
            marker = self.markerObjects.pop()

            self.mapWidget.removeMapObject(marker)
            marker.deleteLater()

    def customContextMenuRequest(self, point):
        self.lastClicked = point
        if self.focusWidget() == self.view:
            if not self.popupMenu:
                self.createMenus()

            self.popupMenu.popup(self.view.mapToGlobal(self.lastClicked))
示例#23
0
    def drag ( self, data, type = None, request = 'copy', image = None ):
        """ Initiates a drag operation with the specified *data*. If *type* is
            **None**, the control will try to determine the kind of data being
            dragged from the data itself. Other than **None**, the legal values
            for *type* are: 'color', 'image', 'text', 'html', 'files', 'urls'
            and 'object'.

            *Request* specifies whether the data is to be copied ('copy'),
            moved ('move') or linked ('link'), with the default request being to
            copy the data.

            *Image* specifies an ImageResource image to be used while dragging
            to provide the user with some indication of what is being dragged.
            This may not be supported with all UI back-ends. If not supported,
            the *image* value is treated as *None*. A value of *None* indicates
            that the default drag image should be used.

            The result is a string indicating the action taken by the receiver
            (if any) of the data at the completion of the drag and drop
            operation. The possible values are: 'copy', 'move', 'link' and
            'ignore'.
        """
        if type is None:
            if isinstance( data, basestring ):
                type = 'text'
            elif isinstance( data, QColor ):
                type = 'color'
            elif isinstance( data, AnImageResource ):
                type = 'image'
                data = data.image
            elif isinstance( data, SequenceTypes ):
                type = 'urls'
                data = [ QUrl( item ) for item in data ]
            else:
                type = 'object'

        mime_data = getattr( self, '_drag_%s' % type,
                             self._drag_object )( data )
        drag      = QDrag( self.control )
        drag.setMimeData( mime_data )

        # Set up the drag image (if one was specified):
        if isinstance( image, AnImageResource ):
            bitmap   = image.bitmap
            idx, idy = image.width, image.height
            ratio    = max( idx, idy ) / 128.0
            if ratio > 1.0:
                # Create a scaled version of the image if it is larger than the
                # maximum nominal size:
                sdx = int( round( idx / ratio ) )
                sdy = int( round( idy / ratio ) )
                pm  = QPixmap( sdx, sdy )
                pm.fill( QColor( 0, 0, 0, 0 ) )
                painter = painter_for( pm )
                painter.drawPixmap( 0, 0, sdx, sdy, bitmap, 0, 0, idx, idy )
                painter.end()
                bitmap, idx, idy = pm, sdx, sdy

            drag.setPixmap( bitmap )
            drag.setHotSpot( QPoint( idx / 2, idy / 2 ) )

        return RequestAction[ drag.exec_() ]
示例#24
0
 def _set_icon(self, color):
     """Set the colored square icon."""
     colorpix = QPixmap(16, 16)
     colorpix.fill(color)
     self.setIcon(QIcon(colorpix))
示例#25
0
from PySide.QtGui import (QApplication, QGraphicsView, QGraphicsScene,
                          QMainWindow, QPixmap, QPainter)
from PySide.QtCore import Qt
import sys

if __name__ == '__main__':
    app = QApplication(sys.argv)
    scene = QGraphicsScene()
    view = QGraphicsView(scene)
    view.scale(15, 15)

    pix = QPixmap(200, 50)
    pix.fill(Qt.white)
    p = QPainter(pix)
    p.setPen(Qt.black)
    #p.setBrush(Qt.red)
    for i in range(1, 10):
        p.drawEllipse(0, 0, i, i)
        p.translate(i+5, 0)
    p.end()
    pixItem = scene.addPixmap(pix)

    win = QMainWindow()
    win.setCentralWidget(view)
    win.resize(700, 200)
    win.show()

    sys.exit(app.exec_())
示例#26
0
class Fourier(QWidget):
    """ Actual fourier display and drawing widget """

    fourier_updated = Signal(np.ndarray)
    image = None
    pressed = False
    scale_factor = None
    color = QColor(0, 0, 0)
    raw_fourier = None
    x_sym = False
    y_sym = False
    opp_sym = False

    # signal fourier updated

    def __init__(self, parent=None):
        super().__init__(parent)
        self.update_cursor('square', 20)
        self.overlay = Overlay(self)

    def update_image(self, fft_array, factor=None):

        scaled_values, sf = rescale_array(np.real(np.log2(fft_array)),
                                          self.scale_factor)
        self.scale_factor = sf
        self.image = array_to_image(scaled_values)
        self.setMinimumSize(self.image.size())
        self.overlay.resize(self.image.size())
        self.update()
        self.updateGeometry()
        # I have to deliver, and it's broken on windows.
        self.setMinimumSize(self.image.size())
        self.overlay.resize(self.image.size())
        self.update()
        self.updateGeometry()

    def update_fourier(self, image_array, flush=False):
        f = array_to_fft(image_array)
        if self.raw_fourier is None or flush:
            self.original = f.copy()

        self.raw_fourier = f.copy()

        self.update_image(self.raw_fourier)

    def update_cursor(self, shape, size):
        self.cursor_size = size
        self.shape = shape

        cursor_pix = QPixmap(size, size)
        cursor_pix.fill(Qt.transparent)

        painter = QPainter(cursor_pix)
        painter.setPen(QColor(255, 0, 0))

        if shape == 'circle':
            painter.drawEllipse(0, 0, size - 1, size - 1)
        elif shape == 'square':
            painter.drawRect(0, 0, size - 1, size - 1)
        elif shape == "magic wand":
            magic_wand.render(painter, QRect(0, 0, 20, 20))

        cursor = QCursor(cursor_pix, 0, 0)
        self.setCursor(cursor)
        del painter

    def on_size_change(self, size):
        """ Brush size changed """
        self.cursor_size = size
        self.update_cursor(self.shape, self.cursor_size)

    Slot(str)

    def on_shape_change(self, shape):
        """ Brush shape changed """
        self.shape = shape
        self.update_cursor(self.shape, self.cursor_size)

    def on_color_change(self, color):
        self.color = QColor(color, color, color)

    def emit_fourier(self):
        array = fft_to_array(self.raw_fourier)
        self.fourier_updated.emit(array)

    def on_restore(self):
        self.raw_fourier = self.original.copy()
        self.update_image(self.raw_fourier, self.scale_factor)
        #self.fourier_updated.emit(self.raw_fourier.copy())
        self.emit_fourier()

    def on_resize(self, factor):
        if factor == 1.0: return
        #even = lambda x: x if (x % 2 == 0) else x + 1
        array = self.raw_fourier

        reshape = lambda x_y: [int(factor * x_y[0]), int(factor * x_y[1])]
        diff = lambda x_y: [x_y[0] - array.shape[0], x_y[1] - array.shape[1]]
        nexteven = lambda x: x if (x % 2 == 0) else x + 1
        delta = map(nexteven, diff(reshape(array.shape)))
        newsize = tuple(x[0] + x[1] for x in zip(array.shape, delta))

        self.raw_fourier = zeropad(array, newsize)
        self.update_image(self.raw_fourier, self.scale_factor)
        #self.fourier_updated.emit(self.raw_fourier.copy())
        self.emit_fourier()

    def draw_mask_on_fourier(self, mask, value=0x00):
        self.raw_fourier[mask] = 2**value
        self.update_image(self.raw_fourier, self.scale_factor)
        self.emit_fourier()

    def regen_image(self):
        self.update_image(self.raw_fourier, self.scale_factor)

    def paintEvent(self, event):
        """ Paint widget as self.image content """
        if self.image is None:
            super().paintEvent(event)
            return

        painter = QPainter(self)
        rect = event.rect()
        painter.drawImage(rect.topLeft(), self.image, rect)

    def mousePressEvent(self, event):
        self.pressed = True
        self.draw_buffer = QPixmap(self.image.size())
        color = self.color.red() ^ 0xAA
        self.draw_buffer.fill(QColor(color, color, color))
        self.draw(event)

    def mouseReleaseEvent(self, event):
        self.pressed = False
        self.draw(event)
        self.fourier_draw()

    def mouseMoveEvent(self, event):
        if self.pressed:
            self.draw(event)

    def fourier_draw(self):

        arr = image_to_array(self.draw_buffer.toImage())

        values = arr[arr == self.color.red()] * (self.scale_factor / 255)
        self.raw_fourier[arr == self.color.red()] = np.abs(2**values)
        self.emit_fourier()

    def _paint(self, painter, x, y):
        size = self.cursor_size
        shape = self.shape

        painter.setBrush(self.color)
        painter.setPen(Qt.NoPen)

        if shape == 'circle':
            painter.drawEllipse(x, y, size - 1, size - 1)
        elif shape == 'square':
            painter.drawRect(x, y, size - 1, size - 1)
        elif shape == "magic wand":
            magic_wand.render(painter, QRect(0, 0, 20, 20))

    def draw(self, event):
        x, y = event.x(), event.y()
        max_y, max_x = self.raw_fourier.shape

        for painter in map(QPainter, [self.image, self.draw_buffer]):
            self._paint(painter, x, y)
            if self.x_sym:
                self._paint(painter, abs(max_x - x - self.cursor_size), y)
            if self.y_sym:
                self._paint(painter, x, abs(max_y - y - self.cursor_size))
            if (self.x_sym and self.y_sym) or self.opp_sym:
                self._paint(painter, abs(max_x - x - self.cursor_size),
                            abs(max_y - y - self.cursor_size))

            del painter

        self.update()

    def sizeHint(self):
        if not self.image:
            return super().minimumSizeHint()
        return self.image.size()

    def on_y_toggle(self, y_state):
        self.y_sym = y_state

    def on_x_toggle(self, x_state):
        self.x_sym = x_state

    def on_opp_toggle(self, opp_state):
        self.opp_sym = opp_state