def pixmapSize(self, pixmap):
"""
Return the preferred pixmap size based on the current `zoom` value.
"""
scale = 2 * self.zoom / 100.0
size = QSizeF(pixmap.size()) * scale
return size.expandedTo(QSizeF(16, 16))
def _updatePixmapSize(self):
pixmap = self.pixmap()
if not pixmap.isNull() and self._size.isValid():
pixsize = QSizeF(self.pixmap().size())
pixsize.scale(self._size, Qt.KeepAspectRatio)
else:
pixsize = QSizeF()
self.pixmapWidget.setPixmapSize(pixsize)
def sizeHint(self, which, constraint=QSizeF()):
if which == Qt.PreferredSize:
size = self.item.boundingRect().size()
if self.orientation == Qt.Horizontal:
return size
else:
return QSizeF(size.height(), size.width())
else:
return QSizeF()
def __init__(self, parent, dlgType):
FlightPlanBaseDlg.__init__(self, parent)
# self.dlgType = dlgType
self.setObjectName("PaIlsDlg")
self.dlgType = dlgType
if self.dlgType == "NpaOnFix":
self.surfaceType = SurfaceTypes.NpaOnFix
else:
self.surfaceType = SurfaceTypes.NpaOverheadingNavaid
self.initParametersPan()
self.setWindowTitle(self.surfaceType)
self.resize(540, 600)
QgisHelper.matchingDialogSize(self, 650, 700)
self.surfaceList = None
self.manualPolygon = None
self.mapToolPan = None
self.toolSelectByPolygon = None
self.accepted.connect(self.closed)
self.rejected.connect(self.closed)
self.wptLayer = None
self.arpFeatureArray = []
self.currentLayer = define._canvas.currentLayer()
self.rwyFeatureArray = []
self.rwyEndPosition = None
self.initAerodromeAndRwyCmb()
self.socRubber = None
self.socAnnotation = QgsTextAnnotationItem(define._canvas)
self.socAnnotation.setDocument(QTextDocument(Captions.SOC))
self.socAnnotation.setFrameBackgroundColor(Qt.white)
self.socAnnotation.setFrameSize(QSizeF(30, 20))
self.socAnnotation.setFrameColor(Qt.magenta)
self.socAnnotation.hide()
self.socPoint3d = None
self.daRubber = None
self.daAnnotation = QgsTextAnnotationItem(define._canvas)
self.daAnnotation.setDocument(QTextDocument(Captions.DA))
self.daAnnotation.setFrameBackgroundColor(Qt.white)
self.daAnnotation.setFrameSize(QSizeF(30, 20))
self.daAnnotation.setFrameColor(Qt.magenta)
self.daAnnotation.hide()
self.daPoint3d = None
self.annotationFAWP = self.parametersPanel.pnlFafPosition.annotation
self.annotationMAPt = self.parametersPanel.pnlMaPtPosition.annotation
def paintEvent(self, event):
if self.__pixmap.isNull():
return
sourcerect = QRect(QPoint(0, 0), self.__pixmap.size())
pixsize = QSizeF(self.__pixmap.size())
rect = self.contentsRect()
pixsize.scale(QSizeF(rect.size()), Qt.KeepAspectRatio)
targetrect = QRectF(QPointF(0, 0), pixsize)
targetrect.moveCenter(QPointF(rect.center()))
painter = QPainter(self)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.drawPixmap(targetrect, self.__pixmap, QRectF(sourcerect))
painter.end()
def paintEvent(self, event):
pixmap = self._shadowPixmap
widget_rect = QRectF(QPointF(0.0, 0.0), QSizeF(self.size()))
frame_rect = QRectF(self.contentsRect())
left, top, right, bottom = self.getContentsMargins()
pixmap_rect = QRectF(QPointF(0, 0), QSizeF(pixmap.size()))
# Shadow casting rectangle.
pixmap_shadow_rect = pixmap_rect.adjusted(left, top, -right, -bottom)
source_rects = self._shadowPixmapFragments(pixmap_rect,
pixmap_shadow_rect)
target_rects = self._shadowPixmapFragments(widget_rect, frame_rect)
painter = QPainter(self)
for source, target in zip(source_rects, target_rects):
painter.drawPixmap(target, pixmap, source)
painter.end()
def __init__(self, pixmap, title="", parentItem=None, **kwargs):
super().__init__(parentItem, **kwargs)
self.setFocusPolicy(Qt.StrongFocus)
self._title = None
self._size = QSizeF()
layout = QGraphicsLinearLayout(Qt.Vertical, self)
layout.setSpacing(2)
layout.setContentsMargins(5, 5, 5, 5)
self.setContentsMargins(0, 0, 0, 0)
self.pixmapWidget = GraphicsPixmapWidget(pixmap, self)
self.labelWidget = GraphicsTextWidget(title, self)
layout.addItem(self.pixmapWidget)
layout.addItem(self.labelWidget)
layout.addStretch()
layout.setAlignment(self.pixmapWidget, Qt.AlignCenter)
layout.setAlignment(self.labelWidget, Qt.AlignHCenter | Qt.AlignBottom)
self.setLayout(layout)
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.setFlag(QGraphicsItem.ItemIsSelectable, True)
self.setTitle(title)
self.setTitleWidth(100)
def paint(self, painter, option, widget):
painter.save()
dirtyColor = QColor(255,0,0)
painter.setOpacity(0.5)
painter.setBrush(QBrush(dirtyColor, Qt.SolidPattern))
painter.setPen(dirtyColor)
intersected = self._tiling.intersected(option.exposedRect)
#print "pies are painting at ", option.exposedRect
progress = 0.0
for i in intersected:
progress += self._indicate[i]
if not(self._indicate[i] < 1.0): # only paint for less than 100% progress
continue
# Don't show unless a delay time has passed since the tile progress was reset.
delta = datetime.datetime.now() - self._zeroProgressTimestamp[i]
if delta < self.delay:
t = QTimer.singleShot(int(delta.total_seconds()*1000.0), self.update)
continue
p = self._tiling.tileRectFs[i]
w,h = p.width(), p.height()
r = min(w,h)
rectangle = QRectF(p.center()-QPointF(r/4,r/4), QSizeF(r/2, r/2));
startAngle = 0 * 16
spanAngle = min(360*16, int((1.0-self._indicate[i])*360.0) * 16)
painter.drawPie(rectangle, startAngle, spanAngle)
painter.restore()
def __init__(self, pixmap, title="", parent=None):
QGraphicsWidget.__init__(self, parent)
self._title = None
self._size = QSizeF()
layout = QGraphicsLinearLayout(Qt.Vertical, self)
layout.setSpacing(2)
layout.setContentsMargins(5, 5, 5, 5)
self.setContentsMargins(0, 0, 0, 0)
self.pixmapWidget = GraphicsPixmapWidget(pixmap, self)
self.labelWidget = GraphicsTextWidget(title, self)
layout.addItem(self.pixmapWidget)
layout.addItem(self.labelWidget)
layout.setAlignment(self.pixmapWidget, Qt.AlignCenter)
layout.setAlignment(self.labelWidget, Qt.AlignHCenter | Qt.AlignBottom)
self.setLayout(layout)
self.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.setFlag(QGraphicsItem.ItemIsSelectable, True)
self.setTitle(title)
self.setTitleWidth(100)
def __naturalsh(self):
fm = QtGui.QFontMetrics(self.font())
spacing = self.__spacing
N = len(self.__items)
width = max((fm.width(text) for text in self.__items), default=0)
height = N * fm.height() + (N - 1) * spacing
return QSizeF(width, height)
def mousePressEvent(self, event):
pos = event.scenePos()
any_item = self.scene.item_at(pos)
if not any_item and event.button() & Qt.LeftButton:
self.modifiers = event.modifiers()
self.selection_rect = QRectF(pos, QSizeF(0, 0))
self.rect_item = QGraphicsRectItem(
self.selection_rect.normalized())
self.rect_item.setPen(
QPen(QBrush(QColor(51, 153, 255, 192)), 0.4, Qt.SolidLine,
Qt.RoundCap))
self.rect_item.setBrush(QBrush(QColor(168, 202, 236, 192)))
self.rect_item.setZValue(-100)
# Clear the focus if necessary.
if not self.scene.stickyFocus():
self.scene.clearFocus()
if not self.modifiers & Qt.ControlModifier:
self.scene.clearSelection()
event.accept()
return True
else:
self.cancel(self.ErrorReason)
return False
def __init__(self, char, score, color, safe=False):
''' Construct a new visual representation of a tile '''
super().__init__()
self.owner = None
self.char = char.upper()
self.score = str(score)
self.is_safe = safe
self.color_border = QColor(color).lighter(100)
self.color_bg = QColor(color).lighter(150)
self.normal_pen = QPen(self.color_border, 1, Qt.SolidLine)
self.safe_pen = QPen(self.color_border, 2, Qt.SolidLine)
self.selected_pen = QPen(self.color_border, 3, Qt.DashLine)
self.normal_brush = self.color_bg.lighter(110)
self.safe_brush = self.color_bg
self.hovers = set()
self.selected = False
self.view = None
self.animation = None
self.deleted = False
self.size = QSizeF(self.LETTER_SIZE, self.LETTER_SIZE)
self.setFlag(self.ItemIsMovable, not safe)
self.setFlag(self.ItemSendsGeometryChanges, not safe)
self.setCursor(Qt.ArrowCursor if safe else Qt.OpenHandCursor)
self.setZValue(1)
self.setOpacity(0)
def createItem(self, e):
mapCoord = self.toMapCoordinates(e.pos())
textItem = QgsTextAnnotationItem(self.mCanvas)
textItem.setMapPosition(self.toMapCoordinates(e.pos()))
textItem.setFrameSize(QSizeF(200, 100))
textItem.setSelected(True)
return textItem
def _rescale(self):
if self._root is None:
return
crect = self.contentsRect()
leaf_count = len(list(leaves(self._root)))
if self.orientation in [Left, Right]:
drect = QSizeF(self._root.value.height, leaf_count - 1)
else:
drect = QSizeF(self._root.value.last - 1, self._root.value.height)
transform = QTransform().scale(crect.width() / drect.width(),
crect.height() / drect.height())
self._itemgroup.setPos(crect.topLeft())
self._itemgroup.setTransform(transform)
self._selection_items = None
self._update_selection_items()
def boundingRect(self):
extra = (self.pen().width() * 64) / 2
return QRectF(
self.__line.p1(),
QSizeF(self.__line.p2().x() - self.__line.p1().x(),
self.__line.p2().y() -
self.__line.p1().y())).normalized().adjusted(
-extra, -extra, extra, extra)
def boundingRect(self):
if hasattr(self, "attr"):
attr_rect = QRectF(QPointF(0, -self.attr_text_h),
QSizeF(self.attr_text_w, self.attr_text_h))
else:
attr_rect = QRectF(0, 0, 1, 1)
rect = self.rect().adjusted(-5, -5, 5, 5)
return rect | attr_rect
def sizeHint(self, which, constraint=QSizeF()):
if which == Qt.PreferredSize:
sh = self.__naturalsh()
if 0 < constraint.height() < sh.height():
sh = scaled(sh, constraint, Qt.KeepAspectRatioByExpanding)
return sh
return super().sizeHint(which, constraint)
def sizeHint(self, which, constraint=QSizeF()):
# TODO: More sensible size hints.
# If the text is a plain text or html
# Check how QLabel.sizeHint works.
if which == Qt.PreferredSize:
return self.__textItem.boundingRect().size()
else:
return QGraphicsWidget.sizeHint(self, which, constraint)
def adjustSize(self):
"""Resize to a reasonable size.
"""
self.__textItem.setTextWidth(-1)
self.__textItem.adjustSize()
size = self.__textItem.boundingRect().size()
left, top, right, bottom = self.textMargins()
geom = QRectF(self.pos(), size + QSizeF(left + right, top + bottom))
self.setGeometry(geom)
def sizeHint(self, which, constraint=QSizeF()):
fm = QFontMetrics(self.font())
spacing = fm.lineSpacing()
mleft, mtop, mright, mbottom = self.getContentsMargins()
if self._root and which == Qt.PreferredSize:
nleaves = len(
[node for node in self._items.keys() if not node.branches])
if self.orientation in [self.Left, self.Right]:
return QSizeF(250, spacing * nleaves + mleft + mright)
else:
return QSizeF(spacing * nleaves + mtop + mbottom, 250)
elif which == Qt.MinimumSize:
return QSizeF(mleft + mright + 10, mtop + mbottom + 10)
else:
return QSizeF()
def boundingRect(self):
# For now, do not take the highlight pen into account
#pw = self.pen().widthF()/2
pw = 0
children = self.childrenBoundingRect()
m = self.margin
return QRectF(
children.topLeft() - QPointF(pw + m, pw + m),
QSizeF(children.width() + pw + m + m,
children.height() + pw + m + m))
def paint(self, painter, option, widget=0):
if self._pixmap.isNull():
return
rect = self.contentsRect()
pixsize = QSizeF(self._pixmap.size())
aspectmode = (Qt.KeepAspectRatio if self._keepAspect
else Qt.IgnoreAspectRatio)
pixsize.scale(rect.size(), aspectmode)
pixrect = QRectF(QPointF(0, 0), pixsize)
pixrect.moveCenter(rect.center())
painter.save()
painter.setPen(QPen(QColor(0, 0, 0, 50), 3))
painter.drawRoundedRect(pixrect, 2, 2)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
source = QRectF(QPointF(0, 0), QSizeF(self._pixmap.size()))
painter.drawPixmap(pixrect, self._pixmap, source)
painter.restore()
def load_window_geometry(self):
"""Load from QSettings the window size of de Ninja IDE"""
qsettings = QSettings()
if qsettings.value("window/maximized", True, type=bool):
self.setWindowState(Qt.WindowMaximized)
else:
self.resize(qsettings.value("window/size",
QSizeF(800, 600).toSize(), type='QSize'))
self.move(qsettings.value("window/pos",
QPointF(100, 100).toPoint(), type='QPoint'))
def paint(self, painter, options, widget):
pw = self.pen().widthF() / 2
children = self.childrenBoundingRect()
m = self.margin
painter.setPen(self.pen())
painter.setBrush(self.brush())
painter.drawRect(
QRectF(
children.topLeft() - QPointF(pw + m, pw + m),
QSizeF(children.width() + pw + m + m,
children.height() + pw + m + m)))
def setSize(self, width, height):
"""Set the size of the visible area in pixels.
Update the scene rect.
Args:
width(int): Width of the visible area.
height(int): Height of the visible area.
"""
rect = QRectF(self.sceneRect().topLeft(), QSizeF(width, height))
self.setSceneRect(rect)
def load_window_geometry(self):
"""Load from QSettings the window size of de Ninja IDE"""
qsettings = QSettings()
if qsettings.value("window/maximized", 'true') == 'true':
self.setWindowState(Qt.WindowMaximized)
else:
print dir(QSizeF)
self.resize(
qsettings.value("window/size", QSizeF(800, 600)).toSize())
self.move(
qsettings.value("window/pos", QPointF(100, 100)).toPoint())
def handlePrintPdf(self):
printer = QPrinter()
pdffile = 'test.pdf'
printer.setResolution(96)
printer.setPageSize(QPrinter.Letter)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(pdffile)
printer.setPageMargins(5, 5, 5, 10, QPrinter.Millimeter)
document = self.makeTableDocument()
document.setPageSize(QSizeF(printer.pageRect().size()))
document.print_(printer)
def exportPDF(self, view, file_name, width, height):
pdf = QPrinter()
pdf.setOutputFormat(QPrinter.PdfFormat)
pdf.setPrintRange(QPrinter.AllPages)
pdf.setOrientation(QPrinter.Portrait)
pdf.setResolution(QPrinter.HighResolution)
pdf.setPaperSize(QSizeF(width, height), QPrinter.Point)
pdf.setFullPage(True)
pdf.setOutputFileName(file_name)
view.mainFrame().print_(pdf)
QApplication.restoreOverrideCursor()
def boundingRect(self):
if not self.source or not self.dest:
return QRectF()
penWidth = 1.0
extra = (penWidth + self.arrowSize) / 2.0 + 100
return QRectF(
self.sourcePoint,
QSizeF(self.destPoint.x() - self.sourcePoint.x(),
self.destPoint.y() -
self.sourcePoint.y())).normalized().adjusted(
-extra, -extra, extra, extra)
def __saveAsPDF(self, fileName):
" Saves the flowchart as an PDF file "
printer = QPrinter()
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setPaperSize(QSizeF(self.scene.width(), self.scene.height()),
QPrinter.Point)
printer.setFullPage(True)
printer.setOutputFileName(fileName)
painter = QPainter(printer)
self.scene.render(painter)
painter.end()
return
