def strokeMouseFromCenter(self,
imgView,
start,
end,
modifier=Qt.NoModifier,
numSteps=10):
"""
Drag the mouse between two coordinates.
A modifier can be specified that will be keep pressed
default no modifier
"""
centerPoint = imgView.rect().bottomRight() / 2
startPoint = QPoint(*start) + centerPoint
endPoint = QPoint(*end) + centerPoint
# Note: Due to the implementation of volumina.EventSwitch.eventFilter(),
# mouse events intended for the ImageView MUST go through the viewport.
# Move to start
move = QMouseEvent(QEvent.MouseMove, startPoint, Qt.NoButton,
Qt.NoButton, modifier)
QApplication.sendEvent(imgView.viewport(), move)
# Press left button
press = QMouseEvent(QEvent.MouseButtonPress, startPoint, Qt.LeftButton,
Qt.NoButton, modifier)
QApplication.sendEvent(imgView.viewport(), press)
# Move to end in several steps
#numSteps = numSteps
for i in range(numSteps):
nextPoint = startPoint + (endPoint - startPoint) * (float(i) /
numSteps)
move = QMouseEvent(QEvent.MouseMove, nextPoint, Qt.NoButton,
Qt.NoButton, modifier)
QApplication.sendEvent(imgView.viewport(), move)
# Move to end
move = QMouseEvent(QEvent.MouseMove, endPoint, Qt.NoButton,
Qt.NoButton, modifier)
QApplication.sendEvent(imgView.viewport(), move)
# Release left button
release = QMouseEvent(QEvent.MouseButtonRelease, endPoint,
Qt.LeftButton, Qt.NoButton, modifier)
QApplication.sendEvent(imgView.viewport(), release)
# Wait for the gui to catch up
QApplication.processEvents()
self.waitForViews([imgView])
def readSettings(self):
settings = QSettings()
settings.beginGroup("MainWindow")
self.resize(settings.value("Size", QVariant(QSize(965, 655))).toSize())
self.move(settings.value("Pos", QVariant(QPoint(0, 0))).toPoint())
settings.endGroup()
settings.beginGroup("BrowsePanel")
self.browsePanel.setVisible(settings.value("Visible", QVariant(True)).toBool())
self.browsePanel.setFloating(settings.value("Floating", QVariant(False)).toBool())
self.browsePanel.resize(settings.value("Size", QVariant(QSize(250, 655))).toSize())
self.browsePanel.move(settings.value("Pos", QVariant(QPoint(0, 0))).toPoint())
settings.endGroup()
settings.beginGroup("FilterPanel")
self.filterPanel.setVisible(settings.value("Visible", QVariant(True)).toBool())
self.filterPanel.setFloating(settings.value("Floating", QVariant(False)).toBool())
self.filterPanel.resize(settings.value("Size", QVariant(QSize(270, 655))).toSize())
self.filterPanel.move(settings.value("Pos", QVariant(QPoint(0, 0))).toPoint())
settings.endGroup()
settings.beginGroup("DataView")
self.dataView.setFixedWidthFont(settings.value("FixedWidthFont", QVariant(False)).toBool())
settings.endGroup()
settings.beginGroup("FindDialog")
d = self.dataView.findDialog
d.setVisible(settings.value("Visible", QVariant(False)).toBool())
d.move(settings.value("Pos", QVariant(QPoint(0, 0))).toPoint())
# Note: QVariant.toInt returns a tuple with the result of the conversion
# and a boolean for the successful conversion
d.setFindFlags(settings.value("Flags", QVariant(0)).toInt()[0])
d.setWrappedSearch(settings.value("WrappedSearch", QVariant(True)).toBool())
settings.endGroup()
self.iovUTCCheckBox.setChecked(settings.value("IOVs/UTC", QVariant(True)).toBool())
size = settings.beginReadArray("Recent")
for i in range(size):
settings.setArrayIndex(i)
conn = settings.value("ConnString").toString()
action = QAction(self)
action.setText(conn)
QObject.connect(action, SIGNAL("triggered()"), self.openRecentDatabase)
self.menuRecent.addAction(action)
settings.endArray()
settings.beginGroup("Misc")
self._showWelcome = settings.value("ShowWelcome", QVariant(True)).toBool()
self._externalEditor = str(settings.value("ExternalEditor", QVariant("emacs")).toString())
settings.endGroup()
def titleOptionRect(self, fw, mw):
if self.checkStateButton:
return QRect(
QPoint(fw + mw + self.checkStateButton.size().width(), fw),
QSize(
self.geometry().width() - (fw * 2) - mw -
self.checkStateButton.size().width(),
self.geometry().height() - (fw * 2)))
else:
return QRect(
QPoint(fw + mw, fw),
QSize(self.geometry().width() - (fw * 2) - mw,
self.geometry().height() - (fw * 2)))
def paintEvent(self, event):
"""
Paint the interpolated pixmap image.
"""
p = QPainter(self)
p.setClipRect(event.rect())
factor = self.blendingFactor_ ** 2
if self.pixmap1 and 1. - factor:
p.setOpacity(1. - factor)
p.drawPixmap(QPoint(0, 0), self.pixmap1)
if self.pixmap2 and factor:
p.setOpacity(factor)
p.drawPixmap(QPoint(0, 0), self.pixmap2)
def mouseMoveEvent(self, e):
this = self.mw
try:
if ((self._last2.x() == -1) or
(self._last2.x() >= 0 and self._last2.x() <= this.width() and
(self._last2.y() >= self.MOVE_HANDLE_HEIGHT) and
(self._last2.y() <= this.height()))):
return
newpos = QPoint(e.globalPos())
upleft = QPoint(self._pos0 + newpos - self._last)
this.move(upleft)
except AttributeError:
pass
def draw_line_to(self, end_point):
painter = QPainter(self.image)
painter.setPen(
QPen(self.draw_color if self.scribbling == 1 else Qt.black,
self.pen_width, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
painter.drawLine(
QPoint(self.last_point.x() // self.image_pen_width,
self.last_point.y() // self.image_pen_width),
QPoint(end_point.x() // self.image_pen_width,
end_point.y() // self.image_pen_width))
self.update()
self.last_point = QPoint(end_point)
def dropEvent(tree_view, e):
try:
_index = tree_view.indexAt(QPoint(e.pos().x(), e.pos().y()))
_i = self.groupTreeModel.itemFromIndex(_index)
if _i and _i.parent() is None and self.__dragged_dut:
_index = tree_view.indexAt(QPoint(e.pos().x(), e.pos().y()))
_g = self.groupTreeModel.itemFromIndex(_index)
_group_id = str(_g.data().toPyObject())
_group = self.server.group(_group_id)
self.__dragged_dut.exchangeGroup(_group)
QTreeView.dropEvent(tree_view, e)
except Exception, e:
logger.LOGGER.error(str(e))
def drawBackground(self, painter, rect):
QGraphicsView.drawBackground(self, painter, rect)
if not self.__backgroundIcon.isNull():
painter.setClipRect(rect)
vrect = QRect(QPoint(0, 0), self.viewport().size())
vrect = self.mapToScene(vrect).boundingRect()
pm = self.__backgroundIcon.pixmap(vrect.size().toSize().boundedTo(
QSize(200, 200)))
pmrect = QRect(QPoint(0, 0), pm.size())
pmrect.moveCenter(vrect.center().toPoint())
if rect.toRect().intersects(pmrect):
painter.drawPixmap(pmrect, pm)
def __init__(self):
self.d = FlickablePrivate()
self.d.state = FlickablePrivate.Steady
self.d.threshold = 10
self.d.ticker = FlickableTicker(self)
self.d.timeStamp = QTime.currentTime()
self.d.target = 0
self.d.pressPos = QPoint()
self.d.offset = QPoint()
self.d.delta = QPoint()
self.d.speed = QPoint()
self.d.ignoreList = []
def mouseReleaseEvent(self, event):
if event.button() == Qt.LeftButton:
x = (QPoint(event.pos())).x()
y = (QPoint(event.pos())).y()
posDictionary2.append(x)
posDictionary2.append(y)
self.rubberBand.hide()
self.close()
Capture(posDictionary1[0], posDictionary1[1], posDictionary2[0],
posDictionary2[1])
Result_Window()
def startBounce(self):
"""
Button starts to bounce requiring attention.
"""
if self.__bouncing:
return
self.__startPos = QPoint(self.pos().x(), self.pos().y())
self.__animationUp.setStartValue(
QPoint(self.__startPos.x(), self.__startPos.y()))
self.__animationUp.setEndValue(
QPoint(self.__startPos.x(),
self.__startPos.y() - self.geometry().height()))
self.__animationUp.start()
self.__bouncing = True
def moveTo(self, x, y):
""" Move itself to a given point with the given animation in the given duration.
@param x: X point coordinate
@type x: int
@param y: Y point coordinate
@type y: int
"""
self.__starting_position = QPoint(self.pos())
self.__moveAnimation = QPropertyAnimation(self, "pos", self)
self.__moveAnimation.setDuration(self.__move_time)
self.__moveAnimation.setEasingCurve(self.__move_animation_type)
self.__moveAnimation.setStartValue(self.__starting_position)
self.__moveAnimation.setEndValue(QPoint(x, y))
self.__moveAnimation.start()
def update_connected(self, env_view, rel_1, rel_2, selected_env):
env_view.scene().clear()
if not self.store_first:
self.store_first = rel_1
self.store_second = rel_2
try:
DragSelection().connected[selected_env]
except:
return
for con in DragSelection().connected[selected_env]:
pt_from = con.pt_from.pos() - self.store_first - self.store_second - QPoint(442, 250)
for pt in con.pts_to:
pt_to = pt.pos() - self.store_first - self.store_second - QPoint(442, 250)
env_view.draw_line(pt_from, pt_to)
def calcCanvasTolerance(pixPoint, layer, mapTool, distance):
"""
To transform the tolerance from screen coordinates to layer coordinates
:param pixPoint: a screen position
:param layer: the layer in which we are working
:param mapTool: a QgsMapTool instance
:param distance: the tolerance in map coordinates
:return: the tolerance in layer coordinates
"""
pt1 = QPoint(pixPoint.x(), pixPoint.y())
pt2 = QPoint(pixPoint.x() + distance, pixPoint.y())
layerPt1 = mapTool.toLayerCoordinates(layer, pt1)
layerPt2 = mapTool.toLayerCoordinates(layer, pt2)
tolerance = layerPt2.x() - layerPt1.x()
return tolerance
def updatePixmap(self, alpha):
""" Update the pixmap for the current transition.
This method first clears the output pixmap. It then draws the
starting pixmap followed by the ending pixmap. Each pixmap is
drawn with complementary alpha values.
"""
out = self.outPixmap()
painter = QPainter(out)
painter.eraseRect(0, 0, out.width(), out.height())
painter.setOpacity(1.0 - alpha)
painter.drawPixmap(QPoint(0, 0), self.startPixmap())
painter.setOpacity(alpha)
painter.drawPixmap(QPoint(0, 0), self.endPixmap())
def __updatePixmap(self):
"""
Update the cached shadow pixmap.
"""
rect_size = QSize(50, 50)
left = top = right = bottom = self.radius_
# Size of the pixmap.
pixmap_size = QSize(rect_size.width() + left + right,
rect_size.height() + top + bottom)
shadow_rect = QRect(QPoint(left, top), rect_size)
pixmap = QPixmap(pixmap_size)
pixmap.fill(QColor(0, 0, 0, 0))
rect_fill_color = self.palette().color(QPalette.Window)
pixmap = render_drop_shadow_frame(
pixmap,
QRectF(shadow_rect),
shadow_color=self.color_,
offset=QPointF(0, 0),
radius=self.radius_,
rect_fill_color=rect_fill_color
)
self.__shadowPixmap = pixmap
self.update()
def paintEvent(self, ev):
"""Called when paint is needed, finds out which page to magnify."""
layout = self.parent().pageLayout()
pos = self.geometry().center()
page = layout.pageAt(pos)
if not page:
return
pagePos = pos - page.pos()
newPage = Page(page, self._scale)
if newPage != self._page:
if self._page:
self._page.magnifier = None
self._page = newPage
self._page.magnifier = self
relx = pagePos.x() / float(page.width())
rely = pagePos.y() / float(page.height())
image = cache.image(self._page)
img_rect = QRect(self.rect())
if not image:
cache.generate(self._page)
image = cache.image(self._page, False)
if image:
img_rect.setWidth(self.width() * image.width() /
self._page.width())
img_rect.setHeight(self.height() * image.height() /
self._page.height())
if image:
img_rect.moveCenter(
QPoint(relx * image.width(), rely * image.height()))
QPainter(self).drawImage(self.rect(), image, img_rect)
def splash_screen():
"""
"""
pm = QPixmap(
pkg_resources.resource_filename(
__name__, "icons/orange-splash-screen.png")
)
version = QCoreApplication.applicationVersion()
size = 21 if len(version) < 5 else 16
font = QFont("Helvetica")
font.setPixelSize(size)
font.setBold(True)
font.setItalic(True)
font.setLetterSpacing(QFont.AbsoluteSpacing, 2)
metrics = QFontMetrics(font)
br = metrics.boundingRect(version).adjusted(-5, 0, 5, 0)
br.moveCenter(QPoint(436, 224))
p = QPainter(pm)
p.setRenderHint(QPainter.Antialiasing)
p.setRenderHint(QPainter.TextAntialiasing)
p.setFont(font)
p.setPen(QColor("#231F20"))
p.drawText(br, Qt.AlignCenter, version)
p.end()
return pm, QRect(88, 193, 200, 20)
def action_rotation_mouse_move(self, point):
""" Slot function when mouse is moved in the canvas.
Add marker if any feature is snapped
"""
# Hide marker and get coordinates
self.vertex_marker.hide()
map_point = self.canvas.getCoordinateTransform().transform(point)
x = map_point.x()
y = map_point.y()
event_point = QPoint(x, y)
# Snapping
(retval, result) = self.snapper.snapToBackgroundLayers(
event_point) # @UnusedVariable
if not result:
return
# Check snapped features
for snapped_point in result:
point = QgsPoint(snapped_point.snappedVertex)
self.vertex_marker.setCenter(point)
self.vertex_marker.show()
break
def __init__(self, parent, ancestor):
QTabBar.__init__(self, parent)
self.ancestor = ancestor
# Dragging tabs
self.__drag_start_pos = QPoint()
self.setAcceptDrops(True)
def openDocument(path):
try:
f = open(path)
line = f.readline()
width, height = map(int, line.strip().split("x"))
image = QImage(800, 600, QImage.Format_RGB16)
image.fill(QColor(255, 255, 255))
painter = QPainter()
painter.begin(image)
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(QPen(QColor(0, 0, 0), 4))
n = int(f.readline())
while n > 0:
line = f.readline().strip()
if not line:
break
obj = []
for point in line.split():
x, y = map(int, point.split(","))
obj.append(QPoint(x, y))
painter.drawPolyline(*obj)
n -= 1
except (IOError, ValueError):
return
painter.end()
return image
def reLayout(self):
pages = list(self.pages())
cols = self._npages
if len(pages) > cols:
## prepend empty places if the first row should display less pages
pages[0:0] = [None] * ((cols - self._npages_first) % cols)
else:
cols = len(pages)
col_widths = []
col_offsets = []
offset = self._margin
for col in range(cols):
width = max(p.width() for p in pages[col::cols] if p)
col_widths.append(width)
col_offsets.append(offset)
offset += width + self._spacing
top = self._margin
for row in (pages[i:i + cols]
for i in range(0, len(pages), cols or 1)):
height = max(p.height() for p in row if p)
for n, page in enumerate(row):
if page:
x = col_offsets[n] + (col_widths[n] - page.width()) // 2
y = top + (height - page.height()) // 2
page.setPos(QPoint(x, y))
top += height + self._spacing
total_height = top + self._margin - self._spacing
total_width = self._margin * 2 + self._spacing * (cols -
1) + sum(col_widths)
self.setSize(QSize(total_width, total_height))
def moveMouseFromCenter(self, imgView, coords):
centerPoint = imgView.rect().bottomRight() / 2
point = QPoint(*coords) + centerPoint
move = QMouseEvent(QEvent.MouseMove, point, Qt.NoButton, Qt.NoButton,
Qt.NoModifier)
QApplication.postEvent(imgView, move)
QApplication.processEvents()
def draw_filled_polygon(self, outline_pen_with=0):
if not self.scale_polygon_colors == None:
painter_filled_polygon = QPainter(self)
painter_filled_polygon.setRenderHint(QPainter.Antialiasing)
# Koordinatenursprung in die Mitte der Flaeche legen
painter_filled_polygon.translate(self.width() / 2, self.height() / 2)
painter_filled_polygon.setPen(Qt.NoPen)
self.pen.setWidth(outline_pen_with)
if outline_pen_with > 0:
painter_filled_polygon.setPen(self.pen)
colored_scale_polygon = self.create_polygon_pie(
((self.widget_diameter / 2) - (self.pen.width() / 2)) * self.gauge_color_outer_radius_factor,
(((self.widget_diameter / 2) - (self.pen.width() / 2)) * self.gauge_color_inner_radius_factor),
self.scale_angle_start_value, self.scale_angle_size)
gauge_rect = QRect(QPoint(0, 0), QSize(self.widget_diameter / 2 - 1, self.widget_diameter - 1))
grad = QConicalGradient(QPointF(0, 0), - self.scale_angle_size - self.scale_angle_start_value +
self.angle_offset - 1)
# todo definition scale color as array here
for eachcolor in self.scale_polygon_colors:
grad.setColorAt(eachcolor[0], eachcolor[1])
# grad.setColorAt(.00, Qt.red)
# grad.setColorAt(.1, Qt.yellow)
# grad.setColorAt(.15, Qt.green)
# grad.setColorAt(1, Qt.transparent)
painter_filled_polygon.setBrush(grad)
# self.brush = QBrush(QColor(255, 0, 255, 255))
# painter_filled_polygon.setBrush(self.brush)
painter_filled_polygon.drawPolygon(colored_scale_polygon)
def mousePressEvent(self, mouseEvent):
pos = mouseEvent.pos()
if self.pointInScroller(pos, QtCore.Qt.Vertical) or self.pointInScroller(pos, QtCore.Qt.Horizontal):
self.clickedInScrollBar = True
else:
if self.ignored.count(mouseEvent):
self.ignored.remove(mouseEvent)
return QWebView.mousePressEvent(self, mouseEvent)
if not self.pressed and not self.scrolling and mouseEvent.modifiers() == QtCore.Qt.NoModifier:
if mouseEvent.buttons() == QtCore.Qt.LeftButton:
self.pressed = True
self.scrolling = False
self.handIsClosed = False
QApplication.setOverrideCursor(QtCore.Qt.OpenHandCursor)
self.position = mouseEvent.pos()
frame = self.page().mainFrame()
xTuple = frame.evaluateJavaScript("window.scrollX").toInt()
yTuple = frame.evaluateJavaScript("window.scrollY").toInt()
self.offset = QPoint(xTuple[0], yTuple[0])
return
return QWebView.mousePressEvent(self, mouseEvent)
def paintEvent(self, ev):
"""Called when paint is needed, finds out which page to magnify."""
layout = self.parent().surface().pageLayout()
pos = self.geometry().center() - self.parent().surface().pos()
page = layout.pageAt(pos)
if not page:
return
pagePos = pos - page.pos()
newPage = Page(page, self._scale)
if not newPage.same_page(self._page):
if self._page:
self._page.magnifier = None
self._page = newPage
self._page.magnifier = self
relx = pagePos.x() / float(page.width())
rely = pagePos.y() / float(page.height())
image = cache.image(self._page)
img_rect = QRect(self.rect())
if not image:
cache.generate(self._page)
image = cache.image(self._page, False)
if image:
img_rect.setWidth(self.width() * image.width() / self._page.width())
img_rect.setHeight(self.height() * image.height() / self._page.height())
if image:
img_rect.moveCenter(QPoint(relx * image.width(), rely * image.height()))
p = QPainter(self)
p.drawImage(self.rect(), image, img_rect)
p.setRenderHint(QPainter.Antialiasing, True)
p.setPen(QPen(QColor(192, 192, 192, 128), 6))
p.drawEllipse(self.rect().adjusted(2, 2, -2, -2))
def mousePressEvent(self, ev):
"""Handle mouse press for dragging start/stop."""
if ev.button() == Qt.LeftButton:
self._dragPos = ev.globalPos()
if self._kineticScrollingEnabled:
# kinetic scrolling
if self._kineticData.ignoreEvent(ev):
return
if self._kineticData._state == KineticData.Steady or self._kineticData._state == KineticData.Stop:
self._dragging = True
self._kineticData._state = KineticData.Pressed
self._kineticData._pressPos = copy.copy(ev.pos())
self._kineticData._offset = self.scrollOffset()
self._kineticData._maxSpeed = 64 #limit speed.
elif self._kineticData._state == KineticData.AutoScroll:
self._dragging = True
self._kineticData._state = KineticData.Stop
self._kineticData._speed = QPoint(0, 0)
else:
self._dragging = True
super(KineticScrollArea, self).mousePressEvent(ev)
def canvasMoveEvent(self, event):
# Hide highlight
self.vertex_marker.hide()
# Get the click
x = event.pos().x()
y = event.pos().y()
try:
event_point = QPoint(x, y)
except (TypeError, KeyError):
self.iface.actionPan().trigger()
return
# Snapping
if self.snap_to_selected_layer:
(retval, result) = self.snapper.snapToCurrentLayer(event_point, 2)
else:
(retval, result) = self.snapper.snapToBackgroundLayers(event_point)
# That's the snapped features
if result:
# Get the point and add marker on it
point = QgsPoint(result[0].snappedVertex)
self.vertex_marker.setCenter(point)
self.vertex_marker.show()
def mousePressEvent(self, event):
if (not self.__readOnly):
# Den ursprÜnglichen Wert speichern
oldValue = self.__value
# Die Position des Mauszeigers beim Klicken wird errechnet. Dabei soll die Mitte der linken Seite der Position (0, 0) entsprechen.
mousePoint = event.pos() - self.rect().bottomLeft() - QPoint(
0,
self.rect().height() / 2)
# Welche Breite haben die Punkte? Das bestimme ich je nachdem, ob das Fenster zu breit ist, sie alle aufzunehmen, oder zu hoch, aus Höhe bzw. Breite.
windowWidth = self.width() / self.__maximum
windowHeight = self.height()
dotDiameter = min(windowWidth, windowHeight)
# Hierdurch entspricht der neue Wert dem Punkt, auf den geklickt wurde
newValue = int(mousePoint.x() / dotDiameter) + 1
# Dadurch kann ich aber den Wert 0 nicht erreichen.
# Also Abfrage einbauen, damit der Wert 0 wird, wenn der Wert bereits 1 war und wieder auf 1 geklickt wird,
if (oldValue == 1 and newValue == 1):
self.setValue(0)
else:
self.setValue(newValue)
# Signal senden, wenn der neue Wert sich vom alten unterscheidet.
# Dieses Signal soll nur ausgesendet werden, wenn der User den Wert ändert, nicht wenn programmtechnisch der Wert verändert wird. DafÜr existiert das signal valueChanged( int ).
if (self.__value != oldValue):
self.valueClicked.emit(oldValue)
def canvasReleaseEvent(self, event):
self.node_id = None
# With left click the digitizing is finished
if event.button() == Qt.RightButton:
self.cancel_map_tool()
return
# Get the click
x = event.pos().x()
y = event.pos().y()
event_point = QPoint(x, y)
snapped_feat = None
# Snapping
(retval, result) = self.snapper.snapToCurrentLayer(event_point, 2) #@UnusedVariable
if result:
# Get the point
point = QgsPoint(result[0].snappedVertex) #@UnusedVariable
snapped_feat = next(result[0].layer.getFeatures(QgsFeatureRequest().setFilterFid(result[0].snappedAtGeometry)))
self.node_id = snapped_feat.attribute('node_id')
# Change node type
self.change_elem_type(snapped_feat)
# Refresh map canvas
self.refresh_map_canvas()
