def initUi(self):
self.setWindowTitle('BLABLABLA')
self.setMouseTracking(True)
# self.setGeometry(50, 50, 1024, 768)
# self.setMaximumSize(1024, 768)
# self.setMinimumSize(800, 600)
self.setLayout(self.hbox)
self.hbox.addStretch(1)
self.hbox.addLayout(self.vbox)
self.hbox.addStretch(1)
self.hbox.addWidget(self.grid)
self.grid.show()
self.vbox.addStretch(1)
font = QFont()
font.setBold(True)
font.setPixelSize(30*variables.SCALE)
label = QLabel("PUNTAJE")
label.setFont(font)
label.setAlignment(Qt.AlignCenter)
self.vbox.addWidget(label)
font2 = QFont()
font2.setPixelSize(30*variables.SCALE)
self.label_puntaje.setFont(font2)
self.label_puntaje.setAlignment(Qt.AlignCenter)
self.vbox.addWidget(self.label_puntaje)
self.vbox.addWidget(self.button)
self.vbox.addWidget(self.orientation)
self.orientation.setAlignment(Qt.AlignCenter)
self.orientation.setPixmap(self.__clockwise_pm)
self.vbox.addStretch(1)
self.button.clicked.connect(self.invertirPressed)
self.grid.initUI()
def setNameAndBrush(self, sigma, color=Qt.black):
self.sigma = sigma
self.setText(
decode_to_qstring("σ=%.1fpx" % self.sigma, "utf-8")
) # This file is encoded as utf-8, so this string should be decoded as such.
total_window = 1 + 2 * int(self.sigma * self.window_size + 0.5)
self.setToolTip("sigma = {:.1f} pixels, window diameter = {:.1f}".format(self.sigma, total_window))
font = QFont()
font.setPointSize(10)
font.setBold(True)
self.setFont(font)
self.setForeground(color)
pixmap = QPixmap(self.pixmapSize)
pixmap.fill(Qt.transparent)
painter = QPainter()
painter.begin(pixmap)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setPen(color)
brush = QBrush(color)
painter.setBrush(brush)
painter.drawEllipse(
QRect(
self.pixmapSize.width() / 2 - self.brushSize / 2,
self.pixmapSize.height() / 2 - self.brushSize / 2,
self.brushSize,
self.brushSize,
)
)
painter.end()
self.setIcon(QIcon(pixmap))
self.setTextAlignment(Qt.AlignVCenter)
def __init__(self, parent, canvasLayer):
QTreeWidgetItem.__init__(self)
self.legend = parent
self.canvasLayer = canvasLayer
self.canvasLayer.layer().setLayerName( self.legend.normalizeLayerName( unicode( self.canvasLayer.layer().name() ) ) )
self.setText(0, self.canvasLayer.layer().name())
self.isVect = (self.canvasLayer.layer().type() == 0) # 0: Vector, 1: Raster
self.layerId = self.canvasLayer.layer().id()
self.setSizeHint(0, QSize(24, 24))
self.setCheckState(0, Qt.Checked)
pm = QPixmap(22, 22)
icon = QIcon()
if self.isVect:
renderer = self.canvasLayer.layer().rendererV2()
sym = renderer.symbols()[0]
img = QImage(sym.asImage(QSize(22, 22)))
pix = pm.fromImage(img)
icon.addPixmap(pix, QIcon.Normal, QIcon.On)
self.vectorLayerSymbology(self.canvasLayer.layer())
else:
pm = self.canvasLayer.layer().previewAsPixmap(QSize(22, 22))
icon.addPixmap(pm)
self.rasterLayerSymbology(self.canvasLayer.layer())
self.setIcon(0, icon)
self.setToolTip(0, self.canvasLayer.layer().attribution())
layerFont = QFont()
layerFont.setBold(True)
self.setFont(0, layerFont)
def __init__(self):
TreeItem.__init__(self, 'shogun-logo-50x50px-round-blue.png',
'Shogun Connections')
self.actiontype = 'topitem'
font = QFont('Arial', 14)
font.setBold(True)
self.setFont(0, font)
def data(self, idx, role=Qt.DisplayRole):
if not idx.isValid() or \
idx.row() < 0 or \
idx.row() >= self.rowCount() or \
idx.column() < 0 or \
idx.column() >= self.columnCount() or \
self._feed is None:
return None
if role != Qt.DisplayRole and role != Qt.FontRole:
return None
entry = list(self._feed.entries)[idx.row()]
if role == Qt.DisplayRole:
if idx.column() == 0:
if entry.important:
return "!"
return ""
elif idx.column() == 1:
return entry.title
elif idx.column() == 2:
return entry.author
elif idx.column() == 3:
return qDateTimeFromTimeStruct(entry.updated)
elif role == Qt.FontRole:
fnt = QFont()
if not entry.read:
fnt.setBold(True)
if entry.important:
fnt.setItalic(True)
return fnt
return None
def font(self, text_style):
device_font = text_style.fontfacename in LIBERATION_FONT_MAP
try:
if device_font:
face = self.font_map[text_style.fontfacename]
else:
face = self.face_map[text_style.fontfacename]
except KeyError: # Bad fontfacename field in LRF
face = self.font_map['Dutch801 Rm BT Roman']
sz = text_style.fontsize
wt = text_style.fontweight
style = text_style.fontstyle
font = (face, wt, style, sz,)
if font in self.cache:
rfont = self.cache[font]
else:
italic = font[2] == QFont.StyleItalic
rfont = QFont(font[0], font[3], font[1], italic)
rfont.setPixelSize(font[3])
rfont.setBold(wt>=69)
self.cache[font] = rfont
qfont = rfont
if text_style.emplinetype != 'none':
qfont = QFont(rfont)
qfont.setOverline(text_style.emplineposition == 'before')
qfont.setUnderline(text_style.emplineposition == 'after')
return qfont
def __init__(self, base):
QWidget.__init__(self)
self.base = base
self.showed = False
self.setFixedSize(500, 120)
self.text_edit = CompletionTextEdit()
self.upload_button = ImageButton(base, 'action-upload.png',
i18n.get('upload_image'))
self.short_button = ImageButton(base, 'action-shorten.png',
i18n.get('short_urls'))
font = QFont()
font.setPointSize(18)
font.setBold(True)
self.char_count = QLabel('140')
self.char_count.setFont(font)
self.update_button = QPushButton(i18n.get('update'))
self.update_button.setToolTip(self.base.get_shortcut_string('Enter'))
self.queue_button = QPushButton(i18n.get('add_to_queue'))
self.queue_button.setToolTip(self.base.get_shortcut_string('P'))
self.accounts_combo = QComboBox()
buttons = QHBoxLayout()
buttons.setSpacing(4)
buttons.addWidget(self.accounts_combo)
buttons.addWidget(self.upload_button)
buttons.addWidget(self.short_button)
buttons.addStretch(0)
buttons.addWidget(self.char_count)
buttons.addWidget(self.queue_button)
buttons.addWidget(self.update_button)
self.loader = BarLoadIndicator()
self.error_message = ErrorLabel()
self.update_button.clicked.connect(self.__update_status)
self.queue_button.clicked.connect(self.__queue_status)
self.short_button.clicked.connect(self.__short_urls)
self.upload_button.clicked.connect(self.__upload_image)
self.text_edit.textChanged.connect(self.__update_count)
self.text_edit.quit.connect(self.closeEvent)
self.text_edit.activated.connect(self.__update_status)
self.text_edit.enqueued.connect(self.__queue_status)
layout = QVBoxLayout()
layout.setSpacing(0)
layout.addWidget(self.text_edit)
layout.addWidget(self.loader)
layout.addSpacing(5)
layout.addWidget(self.error_message)
layout.addLayout(buttons)
layout.setContentsMargins(5, 5, 5, 5)
self.setLayout(layout)
self.__clear()
def __init__(self, pixmap):
super(SplashScreen, self).__init__(pixmap)
self._title = QLabel(self)
self._title.setGeometry(50 * self.width() / 100,
20 * self.height() / 100,
50 * self.width() / 100,
11 * self.height() / 100)
self._title.setStyleSheet('QLabel { color : rgb(191,180,110); }')
font = QFont('Exo 2')
font.setPixelSize(36)
font.setBold(True)
font.setItalic(True)
self._title.setFont(font)
font = QFont('Exo 2')
font.setPixelSize(16)
font.setBold(False)
font.setItalic(True)
self.setFont(font)
self.progressBar = QProgressBar(self)
self.progressBar.setGeometry(self.width() / 10, 8 * self.height() / 10,
8 * self.width() / 10,
self.height() / 30)
def font(self, text_style):
device_font = text_style.fontfacename in LIBERATION_FONT_MAP
try:
if device_font:
face = self.font_map[text_style.fontfacename]
else:
face = self.face_map[text_style.fontfacename]
except KeyError: # Bad fontfacename field in LRF
face = self.font_map['Dutch801 Rm BT Roman']
sz = text_style.fontsize
wt = text_style.fontweight
style = text_style.fontstyle
font = (
face,
wt,
style,
sz,
)
if font in self.cache:
rfont = self.cache[font]
else:
italic = font[2] == QFont.StyleItalic
rfont = QFont(font[0], font[3], font[1], italic)
rfont.setPixelSize(font[3])
rfont.setBold(wt >= 69)
self.cache[font] = rfont
qfont = rfont
if text_style.emplinetype != 'none':
qfont = QFont(rfont)
qfont.setOverline(text_style.emplineposition == 'before')
qfont.setUnderline(text_style.emplineposition == 'after')
return qfont
def __init__(self, parent, canvasLayer):
QTreeWidgetItem.__init__(self)
self.legend = parent
self.canvasLayer = canvasLayer
self.canvasLayer.layer().setLayerName(
self.legend.normalizeLayerName(
unicode(self.canvasLayer.layer().name())))
self.setText(0, self.canvasLayer.layer().name())
self.isVect = (self.canvasLayer.layer().type() == 0
) # 0: Vector, 1: Raster
self.layerId = self.canvasLayer.layer().id()
if self.isVect:
geom = self.canvasLayer.layer().dataProvider().geometryType()
self.setCheckState(0, Qt.Checked)
if self.isVect:
pm = QPixmap(20, 20)
icon = QIcon()
if geom == 1 or geom == 4 or geom == 8 or geom == 11: # Point
icon.addPixmap(QPixmap(imgs_dir + "mIconPointLayer.png"),
QIcon.Normal, QIcon.On)
elif geom == 2 or geom == 5 or geom == 9 or geom == 12: # Polyline
icon.addPixmap(QPixmap(imgs_dir + "mIconLineLayer.png"),
QIcon.Normal, QIcon.On)
elif geom == 3 or geom == 6 or geom == 10 or geom == 13: # Polygon
icon.addPixmap(QPixmap(imgs_dir + "mIconPolygonLayer.png"),
QIcon.Normal, QIcon.On)
else: # Not a valid WKT Geometry
geom = self.canvasLayer.layer().geometryType() # QGis Geometry
if geom == 0: # Point
icon.addPixmap(QPixmap(imgs_dir + "mIconPointLayer.png"),
QIcon.Normal, QIcon.On)
elif geom == 1: # Line
icon.addPixmap(QPixmap(imgs_dir + "mIconLineLayer.png"),
QIcon.Normal, QIcon.On)
elif geom == 2: # Polygon
icon.addPixmap(QPixmap(imgs_dir + "mIconPolygonLayer.png"),
QIcon.Normal, QIcon.On)
else:
raise RuntimeError, 'Unknown geometry: ' + str(geom)
else:
qimg = self.canvasLayer.layer().previewAsImage(QSize(20, 20))
icon = QIcon(QBitmap().fromImage(qimg))
self.setIcon(0, icon)
#self.setToolTip( 0, self.canvasLayer.layer().publicSource() )
layerFont = QFont()
layerFont.setBold(True)
self.setFont(0, layerFont)
# Display layer properties
self.properties = self.legend.pyQGisApp.getLayerProperties(
self.canvasLayer.layer())
self.child = QTreeWidgetItem(self)
self.child.setFlags(Qt.NoItemFlags) # Avoid the item to be selected
self.displayLayerProperties()
def initUi(self):
self.setWindowTitle('BLABLABLA')
self.setMouseTracking(True)
# self.setGeometry(50, 50, 1024, 768)
# self.setMaximumSize(1024, 768)
# self.setMinimumSize(800, 600)
self.setLayout(self.hbox)
self.hbox.addStretch(1)
self.hbox.addLayout(self.vbox)
self.hbox.addStretch(1)
self.hbox.addWidget(self.grid)
self.grid.show()
self.vbox.addStretch(1)
font = QFont()
font.setBold(True)
font.setPixelSize(30 * variables.SCALE)
label = QLabel("PUNTAJE")
label.setFont(font)
label.setAlignment(Qt.AlignCenter)
self.vbox.addWidget(label)
font2 = QFont()
font2.setPixelSize(30 * variables.SCALE)
self.label_puntaje.setFont(font2)
self.label_puntaje.setAlignment(Qt.AlignCenter)
self.vbox.addWidget(self.label_puntaje)
self.vbox.addWidget(self.button)
self.vbox.addWidget(self.orientation)
self.orientation.setAlignment(Qt.AlignCenter)
self.orientation.setPixmap(self.__clockwise_pm)
self.vbox.addStretch(1)
self.button.clicked.connect(self.invertirPressed)
self.grid.initUI()
def paint(self, painter, option, index):
r = option.rect
if option.state & QStyle.State_Selected:
painter.fillRect(r, self.parent().palette().highlight())
fontPen = QPen(self.parent().palette().highlightedText(), 1, Qt.SolidLine)
else:
painter.fillRect(r, self.parent().palette().base())
fontPen = QPen(self.parent().palette().text(), 1, Qt.SolidLine)
painter.setPen(fontPen)
name = index.data(Qt.DisplayRole)
path = index.data(Qt.UserRole)
imageSpace = 10
# notebook name
r = option.rect.adjusted(imageSpace, 0, -10, -20)
name_font = QFont(self.parent().font())
name_font.setPointSize(10)
name_font.setBold(True)
painter.setFont(name_font)
painter.drawText(r.left(), r.top(), r.width(), r.height(),
Qt.AlignBottom|Qt.AlignLeft, name)
# notebook path
path_font = QFont(self.parent().font())
path_font.setPointSize(8)
r = option.rect.adjusted(imageSpace, 20, -10, 0)
painter.setFont(path_font)
painter.drawText(r.left(), r.top(), r.width(), r.height(),
Qt.AlignLeft, path)
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 _create_components(self):
font = QFont()
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.title = QLabel(u"Job Crawler\nA propos")
self.title.setAlignment(Qt.AlignCenter)
self.title.setFont(font)
self.description = QLabel(u"<p>Ce programme parcours différent job boards pour trouver de nouvelles annonces, à partir de listes de critères ou de domaines, avec choix des jobs board à utiliser et de la région.</p>" \
u"<p>La recherche faite, l\'utilisateur peut ouvrir toutes les annonces dans son navigateur Internet et/ou se les faire envoyer par e-mail.</p>" \
u"<p>Le programme exploite une base CSV pour stoquer les annonces parcourues.</p>")
self.description.setAlignment(Qt.AlignJustify)
self.description.setTextFormat(Qt.RichText)
self.description.setScaledContents(False)
self.description.setWordWrap(True)
font = QFont()
font.setPointSize(10)
self.creator = QLabel(u"Créé par RIVES Yann et DELAMARE Guillaume")
self.creator.setAlignment(Qt.AlignCenter)
self.creator.setFont(font)
self.ok_button = QPushButton("OK")
def paint(self, painter, option, widget):
""" Draws a filled rectangle and then adds a title """
# Hide the dotted outline for clickable system modules
itemOption = QStyleOptionGraphicsItem(option)
if itemOption.state & QStyle.State_Selected != 0:
itemOption.state = itemOption.state & ~QStyle.State_Selected
# Draw the rectangle
QGraphicsRectItem.paint(self, painter, itemOption, widget)
# Draw text over the rectangle
font = QFont("Arial", 10)
font.setBold(True)
painter.setFont(font)
painter.drawText(self.__node.posX - self.__node.width / 2.0,
self.__node.posY - self.__node.height / 2.0,
self.__node.width, self.__node.height, Qt.AlignCenter,
self.__node.label)
pixmap = PixmapCache().getPixmap("systemmod.png")
pixmapPosX = self.__node.posX + self.__node.width / 2.0 - \
pixmap.width() / 2.0
pixmapPosY = self.__node.posY - self.__node.height / 2.0 - \
pixmap.height() / 2.0
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.drawPixmap(pixmapPosX, pixmapPosY, pixmap)
return
def __init__(self, manager):
''' See XmlController for documentation '''
XmlController.__init__(self, manager)
# Create popup menu actions
p = ('add', "Create model from template", self._show_dialog_for_template_node)
self.action_create_model_from_template = self.create_action(*p)
p = ('estimation', "Run Estimation", self.run_estimation_for_selected)
self.action_run_estimation = self.create_action(*p)
p = ('', "Right click the individual groups (specification/<group>) to estimate", lambda: ())
self.action_show_how_to_estimate_groups = self.create_action(*p)
p = ('estimation', "Run Estimation Group", self.run_estimation_for_selected_group)
self.action_run_estimation_group = self.create_action(*p)
p = ('submodel', "Edit Submodel", self._open_submodel_editor_for_selected)
self.action_edit_submodel = self.create_action(*p)
font = QFont()
font.setBold(True)
self.action_edit_submodel.setFont(font)
# Create a list of available template nodes
self.create_from_template_actions = []
template_nodes = self.project.findall('model_manager/templates/model_template')
templates = dict((node.get('name'), node) for node in template_nodes)
for template_name, template_node in templates.items():
callback = lambda x = template_node: self._show_dialog_for_template_node(x)
action = self.create_action('clone', template_name, callback)
self.create_from_template_actions.append(action)
self.editor = None
self.view.connect(self.view, SIGNAL('doubleClicked(const QModelIndex&)'), self._on_double_click)
def generate_tree_model(self, data_dict):
"""Generate a tree model for specified dictionary
:param data_dict: A dictionary
:type data_dict: dict
:return: list of QTreeWidgetItem
:rtype list:
"""
widget_items = []
font = QFont()
font.setBold(True)
for key in data_dict.keys():
entry = data_dict[key]
key_item = QTreeWidgetItem()
key_item.setText(0, str(key))
key_item.setFont(0, font)
if isinstance(entry, dict):
items = self.generate_tree_model(entry)
key_item.addChildren(items)
else:
# value_item = QTreeWidgetItem()
key_item.setText(1, str(entry))
key_item.setFlags(key_item.flags() | Qt.ItemIsEditable)
# key_item.addChild(key_item)
widget_items.append(key_item)
return widget_items
def generate_tree_model(self, data_dict):
"""Generate a tree model for specified dictionary
:param data_dict: A dictionary
:type data_dict: dict
:return: list of QTreeWidgetItem
:rtype list:
"""
widget_items = []
font = QFont()
font.setBold(True)
for key in data_dict.keys():
entry = data_dict[key]
key_item = QTreeWidgetItem()
key_item.setText(0, str(key))
key_item.setFont(0, font)
if isinstance(entry, dict):
items = self.generate_tree_model(entry)
key_item.addChildren(items)
else:
# value_item = QTreeWidgetItem()
key_item.setText(1, str(entry))
key_item.setFlags(key_item.flags() | Qt.ItemIsEditable)
# key_item.addChild(key_item)
widget_items.append(key_item)
return widget_items
def paint( self, painter, option, widget ):
""" Draws a filled rectangle and then adds a title """
# Hide the dotted outline for clickable system modules
itemOption = QStyleOptionGraphicsItem( option )
if itemOption.state & QStyle.State_Selected != 0:
itemOption.state = itemOption.state & ~QStyle.State_Selected
# Draw the rectangle
QGraphicsRectItem.paint( self, painter, itemOption, widget )
# Draw text over the rectangle
font = QFont( "Arial", 10 )
font.setBold( True )
painter.setFont( font )
painter.drawText( self.__node.posX - self.__node.width / 2.0,
self.__node.posY - self.__node.height / 2.0,
self.__node.width, self.__node.height,
Qt.AlignCenter, self.__node.label )
pixmap = PixmapCache().getPixmap( "systemmod.png" )
pixmapPosX = self.__node.posX + self.__node.width / 2.0 - \
pixmap.width() / 2.0
pixmapPosY = self.__node.posY - self.__node.height / 2.0 - \
pixmap.height() / 2.0
painter.setRenderHint( QPainter.SmoothPixmapTransform )
painter.drawPixmap( pixmapPosX, pixmapPosY, pixmap )
return
def __init__(self, data=None):
"""Constructor."""
super(ProfileWidget, self).__init__()
# Attributes
self.widget_items = []
# Set data
if data:
self.data = data
# Set header
self.header_tree_widget = QTreeWidgetItem(
[tr('Classification'),
tr('Affected'),
tr('Displacement Rate')])
header_font = QFont()
header_font.setBold(True)
header_font.setPointSize(14)
self.header_tree_widget.setFont(0, header_font)
self.header_tree_widget.setFont(1, header_font)
self.header_tree_widget.setFont(2, header_font)
self.setHeaderItem(self.header_tree_widget)
self.header().setResizeMode(0, QHeaderView.Stretch)
self.header().setResizeMode(1, QHeaderView.Fixed)
self.header().setResizeMode(2, QHeaderView.ResizeToContents)
self.header().setMovable(False)
def createWidgets(self):
"""
QtWidgets creation
"""
self.dockToolbar = QToolBar(self)
self.dockToolbar.setStyleSheet(
"QToolBar { border: 0px }") # remove 3D border
self.imageLabel = QLabel(self)
self.imageLabel.setBackgroundRole(QPalette.Base)
self.imageLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.imageLabel.setScaledContents(True)
self.scrollArea = QScrollArea()
self.scrollArea.setBackgroundRole(QPalette.Dark)
self.scrollArea.setWidget(self.imageLabel)
title = QLabel("Image:")
title.setStyleSheet("QLabel { padding-left: 2px; padding-top: 2px }")
font = QFont()
font.setBold(True)
title.setFont(font)
layout = QVBoxLayout()
layout.addWidget(title)
layout.addWidget(self.dockToolbar)
layout.addWidget(self.scrollArea)
layout.setContentsMargins(2, 2, 2, 2)
self.setLayout(layout)
def getFontFromCmnd(self, fontinfo):
'''
Returns a QFont based on the information in the dictionary
fontinfo.
Recognized keys in the font dictionary are:
"family": font family name (string)
"size": text size in points (1/72 inches)
"italic": italicize? (False/True)
"bold": make bold? (False/True)
"underline": underline? (False/True)
'''
try:
myfont = QFont(fontinfo["family"])
except KeyError:
myfont = self.__viewer.font()
try:
myfont.setPointSizeF(fontinfo["size"])
except KeyError:
pass
try:
myfont.setItalic(fontinfo["italic"])
except KeyError:
pass
try:
myfont.setBold(fontinfo["bold"])
except KeyError:
pass
try:
myfont.setUnderline(fontinfo["underline"])
except KeyError:
pass
return myfont
def setNameAndBrush(self, sigma, color=Qt.black):
self.sigma = sigma
self.setText(str(self.brushSize))
font = QFont()
font.setPointSize(10)
font.setBold(True)
self.setFont(font)
self.setForeground(color)
pixmap = QPixmap(self.pixmapSize)
pixmap.fill(Qt.transparent)
painter = QPainter()
painter.begin(pixmap)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setPen(color)
brush = QBrush(color)
painter.setBrush(brush)
painter.drawEllipse(
QRect(
self.pixmapSize.width() / 2 - self.brushSize / 2,
self.pixmapSize.height() / 2 - self.brushSize / 2,
self.brushSize,
self.brushSize,
)
)
painter.end()
self.setIcon(QIcon(pixmap))
self.setTextAlignment(Qt.AlignVCenter)
def paint(self, painter, option, index):
r = option.rect
if option.state & QStyle.State_Selected:
painter.fillRect(r, self.parent().palette().highlight())
fontPen = QPen(self.parent().palette().highlightedText(), 1,
Qt.SolidLine)
else:
painter.fillRect(r, self.parent().palette().base())
fontPen = QPen(self.parent().palette().text(), 1, Qt.SolidLine)
painter.setPen(fontPen)
name = index.data(Qt.DisplayRole)
path = index.data(Qt.UserRole)
imageSpace = 10
# notebook name
r = option.rect.adjusted(imageSpace, 0, -10, -20)
name_font = QFont(self.parent().font())
name_font.setPointSize(10)
name_font.setBold(True)
painter.setFont(name_font)
painter.drawText(r.left(), r.top(), r.width(), r.height(),
Qt.AlignBottom | Qt.AlignLeft, name)
# notebook path
path_font = QFont(self.parent().font())
path_font.setPointSize(8)
r = option.rect.adjusted(imageSpace, 20, -10, 0)
painter.setFont(path_font)
painter.drawText(r.left(), r.top(), r.width(), r.height(),
Qt.AlignLeft, path)
class EditableComboBox(QComboBox):
"""
Editable QComboBox
"""
def __init__(self, parent):
super(EditableComboBox, self).__init__(parent)
self.font = QFont()
self.setEditable(True)
self.connect(self, SIGNAL("editTextChanged(QString)"), self.validate)
self.connect(self, SIGNAL("activated(QString)"),
lambda qstr: self.validate(qstr, editing=False))
self.set_default_style()
self.tips = {True: self.tr("Press enter to validate this entry"),
False: self.tr('This entry is incorrect')}
def show_tip(self, tip=""):
"""Show tip"""
QToolTip.showText(self.mapToGlobal(self.pos()), tip, self)
def set_default_style(self):
"""Set widget style to default"""
self.font.setBold(False)
self.setFont(self.font)
self.setStyleSheet("")
self.show_tip()
def is_valid(self, qstr):
"""
Return True if string is valid
Return None if validation can't be done
"""
pass
def selected(self):
"""Action to be executed when a valid item has been selected"""
self.set_default_style()
self.emit(SIGNAL('valid(bool)'), True)
def validate(self, qstr, editing=True):
"""Validate entered path"""
valid = self.is_valid(qstr)
if self.hasFocus() and valid is not None:
self.font.setBold(True)
self.setFont(self.font)
if valid:
self.setStyleSheet("color:rgb(50, 155, 50);")
else:
self.setStyleSheet("color:rgb(200, 50, 50);")
if editing:
# Combo box text is being modified: invalidate the entry
self.show_tip(self.tips[valid])
self.emit(SIGNAL('valid(bool)'), False)
else:
# A new item has just been selected
if valid:
self.selected()
else:
self.emit(SIGNAL('valid(bool)'), False)
else:
self.set_default_style()
def _drawButtons(self, logoFnam):
gbox = QGroupBox()
spol = QSizePolicy()
spol.horizontalPolicy = QSizePolicy.Maximum
gbox.setSizePolicy(spol)
vbox = QVBoxLayout()
if os.path.isfile(logoFnam):
img = QPixmap(logoFnam) #.scaled(64, 64)
lblLogo = QLabel()
lblLogo.setPixmap(img)
lblLogo.setAlignment(Qt.AlignTop | Qt.AlignRight)
vbox.addWidget(lblLogo)
#vbox.addSpacing(3)
self.butSave = self._drawButton(vbox, "M&odify", 'closeSave')
font = QFont()
font.setBold(True)
self.butSave.setFont(font)
self.butCancel = self._drawButton(vbox, "Cancel", 'closeCancel', True)
vbox.addSpacing(36)
self.butAddRule = self._drawButton(vbox, "Add Rule", 'addRule', True)
self.butCopyRule = self._drawButton(vbox, "Copy Rule", 'copyRule')
self.butDelRule = self._drawButton(vbox, "Delete Rule", 'delRule')
self.butMoveRuleUp = self._drawButton(vbox, "Move Rule Up", 'moveRuleUp')
self.butMoveRuleDn = self._drawButton(vbox, "Move Rule Down", 'moveRuleDown')
vbox.addSpacing(24)
self.butAddCond = self._drawButton(vbox, "Add Condition", 'addCond')
self.butDelCond = self._drawButton(vbox, "Delete Condition", 'delCond')
vbox.addSpacing(15)
self.butAddAction = self._drawButton(vbox, "Add Action", 'addAction')
self.butDelAction = self._drawButton(vbox, "Delete Action", 'delAction')
gbox.setLayout(vbox)
self.mainHSplit.addWidget(gbox)
def __init__(self):
super(StatusTable, self).__init__()
font = QFont('Times New Roman', 16)
font.setBold(True)
header = QListWidgetItem('Status')
header.setFont(font)
self.addItem(header)
self.hide()
def fontForID(self, fontId):
result = QFont(QApplication.font())
if fontId == FontID.Title:
result.setPointSize(self.TITLE_FONT_SIZE)
result.setBold(True)
else:
result.setPointSize(self.LEGEND_FONT_SIZE)
return result
def _getData(self, row, column, role):
if role == Qt.FontRole:
font = QFont(self.view.font())
font.setBold(row.is_bold)
return font
if column.name == 'status':
return self._getStatusData(row, role)
else:
return Table._getData(self, row, column, role)
class MainWindow(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
self.__timer = QTimer(self)
self.background = QLabel(self)
self.background.setPixmap(QPixmap(get_asset_path(["background.png"])))
self.__entities = []
self.__team_1_label = QLabel("Gold Team 1: 0", self)
self.__team_1_label.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
# self.__team_1_label.setFixedWidth(600)
self.__font = QFont("", 20)
self.__font.setBold(True)
self.__team_1_label.setStyleSheet("color: yellow;")
self.__team_1_label.setFont(self.__font)
self.__team_2_label = QLabel("Gold Team 2: 0", self)
self.__team_2_label.setStyleSheet("color: yellow;")
self.__team_2_label.setFont(self.__font)
# self.__team_2_label.setFixedWidth(600)
self.__team_2_label.move(self.width() - self.__team_2_label.sizeHint().width(), 0)
self.__objective_label = QLabel("Objective: None", self)
self.__font_objective = QFont("", 15)
self.__font_objective.setBold(True)
self.__objective_label.setFont(self.__font_objective)
self.__objective_label.move(self.width()//2 - self.__objective_label.sizeHint().width()//2, 0)
def startMain(self, main, delay=25):
self.__timer.timeout.connect(main)
self.__timer.start(delay)
def add_entity(self, entity):
entity.setParent(self)
entity.show()
self.__entities.append(entity)
def set_gold_t1(self, gold):
self.__team_1_label.setText("Gold Team 1: {}".format(gold))
self.__team_1_label.setFixedWidth(self.__team_1_label.sizeHint().width())
def set_gold_t2(self, gold):
self.__team_2_label.setText("Gold Team 2: {}".format(gold))
self.__team_2_label.setFixedWidth(self.__team_2_label.sizeHint().width())
self.__team_2_label.move(self.width() - self.__team_2_label.sizeHint().width(), 0)
def set_objective(self, objective):
self.__objective_label.setText("Objective: {}".format(objective))
self.__objective_label.move(self.width() // 2 - self.__objective_label.sizeHint().width() // 2, 0)
def keyPressEvent(self, e):
if e.key() == Qt.Key_Space:
print(len(self.__entities))
print("Testing")
def setFixedSize(self, *__args):
super().setFixedSize(*__args)
self.__team_2_label.move(self.width() - self.__team_2_label.sizeHint().width(), 0)
self.__objective_label.move(self.width() // 2 - self.__objective_label.sizeHint().width() // 2, 0)
def _createTitleLabel(text, size=sectionFontSize):
label = QLabel(text)
font = QFont(label.font())
font.setPointSize(size)
font.setWeight(75)
font.setBold(True)
label.setFont(font)
label.setWordWrap(True)
return label
def createDialog(self):
"""
Create qt dialog
"""
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setStyleSheet("""QDialogButtonBox {
dialogbuttonbox-buttons-have-icons: 1;
dialog-ok-icon: url(:/ok.png);
dialog-cancel-icon: url(:/test-close-black.png);
}""")
if self.noCancel:
self.buttonBox.setStandardButtons(QDialogButtonBox.Ok)
else:
self.buttonBox.setStandardButtons(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.argsWidget = BasicWidget(self.actionData,
self.owner,
self.variables,
parent=self,
testParams=self.testParams,
adapterMode=self.adapterMode)
# input
mainLayout = QVBoxLayout()
inputText = ""
if "action-descr" in self.actionData['data']:
inputText = self.actionData['data']["action-descr"]
finalTitle = "%s" % self.actionData['data']['function']
if len(inputText):
finalTitle += " - %s" % inputText.lower()
titleLabel = QLabel(finalTitle)
font = QFont()
font.setBold(True)
titleLabel.setFont(font)
# output
outputText = "nothing"
if self.actionData['data']['return-value'] == 'True':
outputText = self.actionData['data']['return-descr']
outputLabel = QLabel("Output: %s" % outputText)
font = QFont()
font.setItalic(True)
outputLabel.setFont(font)
mainLayout.addWidget(titleLabel)
mainLayout.addWidget(outputLabel)
mainLayout.addWidget(self.argsWidget)
mainLayout.addWidget(self.buttonBox)
self.setLayout(mainLayout)
self.setWindowTitle(self.tr("Configuration action"))
self.resize(self.minimumSizeHint())
self.resize(750, self.height())
self.center()
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.resize(100, 70)
self.setWindowTitle("User Input Panel")
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
self.setSizePolicy(sizePolicy)
verticalLayoutDlg = QVBoxLayout(self)
verticalLayoutDlg.setObjectName(("verticalLayoutDlg"))
self.groupBox1 = GroupBox(self)
self.groupBox1.Caption = ""
verticalLayoutDlg.addWidget(self.groupBox1)
self.frameBoxPanel = QFrame(self)
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.frameBoxPanel.sizePolicy().hasHeightForWidth())
self.frameBoxPanel.setSizePolicy(sizePolicy)
self.frameBoxPanel.setFrameShape(QFrame.NoFrame)
self.frameBoxPanel.setFrameShadow(QFrame.Raised)
self.frameBoxPanel.setObjectName(("frameBoxPanel"))
self.hLayoutframeBoxPanel = QHBoxLayout(self.frameBoxPanel)
self.hLayoutframeBoxPanel.setSpacing(0)
self.hLayoutframeBoxPanel.setMargin(0)
self.hLayoutframeBoxPanel.setObjectName(("hLayoutframeBoxPanel"))
self.captionLabel = QLabel(self.frameBoxPanel)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.captionLabel.sizePolicy().hasHeightForWidth())
self.captionLabel.setSizePolicy(sizePolicy)
self.captionLabel.setMinimumSize(QSize(60, 0))
self.captionLabel.setMaximumSize(QSize(60, 16777215))
self.captionLabel.setText("Radius:")
font = QFont()
font.setBold(False)
font.setWeight(50)
self.captionLabel.setFont(font)
self.captionLabel.setObjectName(("captionLabel"))
self.hLayoutframeBoxPanel.addWidget(self.captionLabel)
self.spinBox = QLineEdit(self.frameBoxPanel)
# self.spinBox.setMaximum(1000000000)
# self.spinBox.setMinimum(-1000000000)
self.spinBox.setText("0")
self.spinBox.setMinimumSize(QSize(150, 0))
self.hLayoutframeBoxPanel.addWidget(self.spinBox)
self.groupBox1.Add = self.frameBoxPanel
def createWidgets(self):
"""
QtWidgets creation
"""
self.dockToolbar = QToolBar(self)
self.dockToolbar.setStyleSheet(
"QToolBar { border: 0px }") # remove 3D border
self.dockToolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self.dockToolbarClipboard = QToolBar(self)
self.dockToolbarClipboard.setStyleSheet(
"QToolBar { border: 0px }") # remove 3D border
self.dockToolbarClipboard.setToolButtonStyle(
Qt.ToolButtonTextUnderIcon)
self.clipBox = QGroupBox("Clipboard")
self.clipBox.setStyleSheet("""
QGroupBox { font: normal; border: 1px solid silver; border-radius: 2px; }
QGroupBox { padding-bottom: 10px; background-color: #FAFAFA; }
QGroupBox::title { subcontrol-position: bottom center;}
""")
layoutClipBox = QHBoxLayout()
layoutClipBox.addWidget(self.dockToolbarClipboard)
layoutClipBox.setContentsMargins(0, 0, 0, 0)
self.clipBox.setLayout(layoutClipBox)
self.paramsBox = QGroupBox("Parameters")
self.paramsBox.setStyleSheet("""
QGroupBox { font: normal; border: 1px solid silver; border-radius: 2px; }
QGroupBox { padding-bottom: 10px; background-color: #FAFAFA; }
QGroupBox::title { subcontrol-position: bottom center;}
""")
layoutParamBox = QHBoxLayout()
layoutParamBox.addWidget(self.dockToolbar)
layoutParamBox.setContentsMargins(0, 0, 0, 0)
self.paramsBox.setLayout(layoutParamBox)
layoutToolbars = QHBoxLayout()
layoutToolbars.addWidget(self.paramsBox)
layoutToolbars.addWidget(self.clipBox)
layoutToolbars.addStretch(1)
layoutToolbars.setContentsMargins(5, 0, 0, 0)
title = QLabel("Test Config:")
title.setStyleSheet("QLabel { padding-left: 2px; padding-top: 2px }")
font = QFont()
font.setBold(True)
title.setFont(font)
layout = QVBoxLayout()
layout.addWidget(title)
layout.addLayout(layoutToolbars)
layout.addWidget(self.tc)
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
def __init__(self, shogunRessource):
self.ressource = shogunRessource
self.name = shogunRessource.name
TreeItem.__init__(self, 'shogun-logo-25x-25px.png', self.name)
self.isConnected = False
self.actiontype = 'connection'
font = QFont('Arial', 12)
font.setBold(True)
self.setFont(0, font)
self.populateTree(shogunRessource)
def __init__(self, ressource):
TreeItem.__init__(self, 'applications-logo.png', 'Applications')
self.ressource = ressource
self.applications = self.ressource.getApplicationIdsAndNames()
self.applicationlist = []
self.actiontype = 'applicationsItem'
font = QFont('Arial', 10)
font.setBold(True)
self.setFont(0, font)
self.populate()
def init_text(self):
try:
self.setText(self.owner.username)
except AttributeError:
font = QFont()
font.setBold(True)
self.setFont(font)
self.setTextAlignment(
Qt.AlignHCenter | Qt.AlignVCenter | Qt.AlignCenter)
self.setText(u"Utilisateurs")
def init_text(self):
try:
self.setText(
"{}, {}".format(self.provid_clt.name, self.provid_clt.phone))
except AttributeError:
font = QFont()
font.setBold(True)
self.setFont(font)
self.setTextAlignment(Qt.AlignCenter)
self.setText(u"Tous")
def setup_widget(self):
font = QFont()
font.setBold(True)
self.groupBox2.setFont(font)
self.groupBox2.setTitle(self.title)
self.lineedit_list = self.setup_dynamically()
self.setup_combo()
self.setup_values()
self.comboBox.currentIndexChanged.connect(lambda: self.setup_values())
self.setup_signals()
def __init__(self, ressource):
TreeItem.__init__(self, 'layers-logo.png', 'Layers')
self.ressource = ressource
self.layers = self.ressource.getLayerIdsAndNames()
self.layerlist = []
self.actiontype = 'layersItem'
font = QFont('Arial', 10)
font.setBold(True)
self.setFont(0, font)
self.populate()
def init_text(self):
try:
self.setText("{}, {}".format(self.provid_clt.name,
self.provid_clt.phone))
except AttributeError:
font = QFont()
font.setBold(True)
self.setFont(font)
self.setTextAlignment(Qt.AlignCenter)
self.setText(u"Tous")
def init_text(self):
try:
self.setText(self.group.name)
except AttributeError:
font = QFont()
font.setBold(True)
self.setFont(font)
self.setTextAlignment(
Qt.AlignHCenter | Qt.AlignVCenter | Qt.AlignCenter)
self.setText(u"Tous")
def finalizeUpdate(self):
"""
Finalize update
"""
self.addAction.setText( "&Add Action" )
buttonFont = QFont()
buttonFont.setBold(False)
self.addAction.setFont(buttonFont)
self.cancelAction.setEnabled(False)
def _month_title_widget(self):
font = QFont("Arial")
font.setPointSize(18)
font.setBold(True)
title = self.date2string(self.date)
self.month_title = QLabel(title)
self.month_title.setFont(font)
self.month_title.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
return self.month_title
def _update(self):
# Update the displayed confusion matrix
if self.results is not None and self.selected_learner:
index = self.selected_learner[0]
cmatrix = confusion_matrix(self.results, index)
colsum = cmatrix.sum(axis=0)
rowsum = cmatrix.sum(axis=1)
total = rowsum.sum()
if self.selected_quantity == 0:
value = lambda i, j: int(cmatrix[i, j])
elif self.selected_quantity == 1:
priors = numpy.outer(rowsum, colsum) / total
value = lambda i, j: \
"{} / {:5.3f}".format(cmatrix[i, j], priors[i, j])
elif self.selected_quantity == 2:
value = lambda i, j: \
("{:2.1f} %".format(100 * cmatrix[i, j] / colsum[i])
if colsum[i] else "N/A")
elif self.selected_quantity == 3:
value = lambda i, j: \
("{:2.1f} %".format(100 * cmatrix[i, j] / rowsum[i])
if colsum[i] else "N/A")
else:
assert False
model = self.tablemodel
for i, row in enumerate(cmatrix):
for j, _ in enumerate(row):
item = model.item(i, j)
if item is None:
item = QStandardItem()
item.setData(value(i, j), Qt.DisplayRole)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
model.setItem(i, j, item)
font = model.invisibleRootItem().font()
bold_font = QFont(font)
bold_font.setBold(True)
def sum_item(value):
item = QStandardItem()
item.setData(value, Qt.DisplayRole)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
item.setFont(bold_font)
return item
N = len(colsum)
for i in range(N):
model.setItem(N, i, sum_item(int(colsum[i])))
model.setItem(i, N, sum_item(int(rowsum[i])))
model.setItem(N, N, sum_item(int(total)))
def _update(self):
# Update the displayed confusion matrix
if self.results is not None and self.selected_learner:
index = self.selected_learner[0]
cmatrix = confusion_matrix(self.results, index)
colsum = cmatrix.sum(axis=0)
rowsum = cmatrix.sum(axis=1)
total = rowsum.sum()
if self.selected_quantity == 0:
value = lambda i, j: int(cmatrix[i, j])
elif self.selected_quantity == 1:
priors = numpy.outer(rowsum, colsum) / total
value = lambda i, j: \
"{} / {:5.3f}".format(cmatrix[i, j], priors[i, j])
elif self.selected_quantity == 2:
value = lambda i, j: \
("{:2.1f} %".format(100 * cmatrix[i, j] / colsum[i])
if colsum[i] else "N/A")
elif self.selected_quantity == 3:
value = lambda i, j: \
("{:2.1f} %".format(100 * cmatrix[i, j] / rowsum[i])
if colsum[i] else "N/A")
else:
assert False
model = self.tablemodel
for i, row in enumerate(cmatrix):
for j, _ in enumerate(row):
item = model.item(i, j)
if item is None:
item = QStandardItem()
item.setData(value(i, j), Qt.DisplayRole)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
model.setItem(i, j, item)
font = model.invisibleRootItem().font()
bold_font = QFont(font)
bold_font.setBold(True)
def sum_item(value):
item = QStandardItem()
item.setData(value, Qt.DisplayRole)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
item.setFont(bold_font)
return item
N = len(colsum)
for i in range(N):
model.setItem(N, i, sum_item(int(colsum[i])))
model.setItem(i, N, sum_item(int(rowsum[i])))
model.setItem(N, N, sum_item(int(total)))
class EditableComboBox(BaseComboBox):
"""
Editable combo box + Validate
"""
def __init__(self, parent):
BaseComboBox.__init__(self, parent)
self.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLength)
self.font = QFont()
self.connect(self, SIGNAL("editTextChanged(QString)"), self.validate)
self.connect(self, SIGNAL("activated(QString)"),
lambda qstr: self.validate(qstr, editing=False))
self.set_default_style()
self.tips = {
True: _("Press enter to validate this entry"),
False: _('This entry is incorrect')
}
def show_tip(self, tip=""):
"""Show tip"""
QToolTip.showText(self.mapToGlobal(self.pos()), tip, self)
def set_default_style(self):
"""Set widget style to default"""
self.font.setBold(False)
self.setFont(self.font)
self.setStyleSheet("")
self.show_tip()
def selected(self):
"""Action to be executed when a valid item has been selected"""
BaseComboBox.selected(self)
self.set_default_style()
def validate(self, qstr, editing=True):
"""Validate entered path"""
valid = self.is_valid(qstr)
if self.hasFocus() and valid is not None:
self.font.setBold(True)
self.setFont(self.font)
if valid:
self.setStyleSheet("color:rgb(50, 155, 50);")
else:
self.setStyleSheet("color:rgb(200, 50, 50);")
if editing:
# Combo box text is being modified: invalidate the entry
self.show_tip(self.tips[valid])
self.emit(SIGNAL('valid(bool)'), False)
else:
# A new item has just been selected
if valid:
self.selected()
else:
self.emit(SIGNAL('valid(bool)'), False)
else:
self.set_default_style()
def __init__(self, page):
font = QFont(QApplication.font())
font.setBold(True)
fm = QFontMetrics(font)
titleBase = page.viewPrinter.title
titleLineCount = len(titleBase.split('\n'))
titleHeight = fm.height() * titleLineCount
rect = QRect(page.pageRect.topLeft(), QSize(page.pageRect.width(), titleHeight))
LayoutElement.__init__(self, rect)
self.page = page
self.font = font
def data(self, index, role=Qt.DisplayRole):
# Only valid for the first column
row = index.row()
if role == Qt.DisplayRole or role == Qt.EditRole:
return self.variables[row].name
if role == Qt.FontRole:
font = QFont()
font.setBold(True)
return font
if role == Qt.TextAlignmentRole:
return Qt.AlignRight | Qt.AlignVCenter
def data(self, index, role=Qt.DisplayRole):
# Only valid for the first column
row = index.row()
if role == Qt.DisplayRole or role == Qt.EditRole:
return self.variables[row].name
if role == Qt.FontRole:
font = QFont()
font.setBold(True)
return font
if role == Qt.TextAlignmentRole:
return Qt.AlignRight | Qt.AlignVCenter
def method_8(self, treeNode_0, bool_0):
if (treeNode_0 != None):
text = treeNode_0.Text
treeNode_0.Text = " "
if (not bool_0):
treeNode_0.NodeFont = QFont()
else:
font = QFont()
font.setBold(True)
treeNode_0.NodeFont = font
treeNode_0.Text = text
def __init__(self, *args, **kwargs):
super(FLabel, self).__init__(*args, **kwargs)
# self.setFont(QFont("Times New Roman", 50))
css = """
color: gry;
"""
# self.setStyleSheet(css)
font = QFont()
font.setBold(True)
font.setWeight(75)
self.setFont(font)
self.setAlignment(Qt.AlignVCenter | Qt.AlignLeft)
def __init__(self, piece_type, number=5, parent=None):
super().__init__(piece_type, parent)
self._number = number
self._number_label = QLabel(self)
self._number_label.setText(str(self._number))
self._number_label.move(40, 38)
font = QFont()
font.setBold(True)
font.setPixelSize(30)
self._number_label.setFont(font)
self._number_label.setStyleSheet("color: white;")
self._number_label.show()
def __init__(self, *args, **kwargs):
super(TotalsWidget, self).__init__(*args, **kwargs)
self.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
font = QFont()
font.setBold(True)
# font.setWeight(90)
self.setFont(font)
self.setFlags(Qt.ItemIsEnabled |
Qt.ItemIsSelectable | Qt.ItemIsEditable)
def cancelStep(self):
"""
Cancel step
"""
self.addAction.setText( "&Add" )
buttonFont = QFont()
buttonFont.setBold(False)
self.addAction.setFont(buttonFont)
self.cancelAction.setEnabled(False)
self.CancelEdit.emit()
class offsetItem(QGraphicsTextItem):
def __init__(self, whex):
QGraphicsTextItem.__init__(self)
self.initValues(whex)
# self.initShape()
self.initPosition()
self.initFont()
def initPosition(self):
self.setPos(0, 25)
def initValues(self, whex):
self.whex = whex
self.bdiff = self.whex.bdiff
#Buffer
self.buffer = []
self.bufferLines = 0
#Line
self.currentLine = 0
#Offset
self.startOffset = 0
self.fontPixel = 14
def initFont(self):
self.setDefaultTextColor(QColor(Qt.red))
self.font = QFont("Gothic")
self.font.setFixedPitch(1)
self.font.setBold(False)
self.font.setPixelSize(self.fontPixel)
self.setFont(self.font)
#Print Operations
def printFullOffset(self, start, len):
count = 0
fullBuff = QString()
while count <= len:
if self.bdiff.opt_offsetBase == 1:
fullBuff.append("%.10d" % start)
elif self.bdiff.opt_offsetBase == 0:
fullBuff.append("%.10X" % start)
fullBuff.append("\n")
start += 16
count += 1
#Clear and set
cursor = self.textCursor()
cursor.movePosition(QTextCursor.Start)
cursor.movePosition(QTextCursor.End, QTextCursor.KeepAnchor)
self.setPlainText(fullBuff)
cursor.movePosition(QTextCursor.Start)
