def __draw(self, start_page, simulate=False): vpos = 0 vpos += self.printer.drawHCenteredTitle(tr('Table of contents'), vpos) vpos += 10 for row in self.table: if row['section']: vpos += 2 size = row['size'] fontmetrics = QFontMetrics(QFont(self.printer.FONT_NAME, size)) if vpos + fontmetrics.height() >= self.printer.height(): vpos = 10 if not simulate: self.printer.newPage() else: start_page += 1 if not simulate: page_num = row['page_num'] + start_page title = row['title'] num_w = fontmetrics.width(unicode(page_num)) self.printer.drawText(title + '.' * 300, vpos, halign=Qt.AlignLeft, size=size, width=self.printer.width() - num_w) self.printer.drawText(unicode(page_num), vpos, halign=Qt.AlignRight, size=size) vpos += fontmetrics.height() return start_page
def getMinimumWidth(self, items=None): fm = QFontMetrics(self.font()) opt = QStyleOptionComboBox() style = self.style() mw = self.maxWidth if items is not None: for str in items: opt.currentText = QString(str) sz = QSize(fm.width(opt.currentText), fm.height()) mw = max( mw, style.sizeFromContents(QStyle.CT_ComboBox, opt, sz, self).width()) elif mw == 0 and self.count() > 0: for i in range(0, self.count()): opt.currentText = self.itemText(i) sz = QSize(fm.width(opt.currentText), fm.height()) mw = max( mw, style.sizeFromContents(QStyle.CT_ComboBox, opt, sz, self).width()) elif mw == 0: opt.currentText = QString(' ') sz = QSize(fm.width(opt.currentText), fm.height()) mw = max( mw, style.sizeFromContents(QStyle.CT_ComboBox, opt, sz, self).width()) self.maxWidth = mw return mw
def __updateShape(self): fBBox = QFontMetrics(self.Font).boundingRect(self.Name) if self.__polygon.boundingRect().width() < fBBox.width(): self.__polygon = QPolygonF(QRectF(fBBox).normalized().adjusted(-fBBox.width() / 4, -fBBox.height() / 4, fBBox.height(), fBBox.height() / 2))
def adjustFont(self): # --- fetch current parameters ---- f = self.font() cr = self.contentsRect() if self.maxFont is not None: maximum = self.maxFont.pointSize() else: maximum = self.font().pointSize() # --- find the font size that fits the contentsRect --- fs = 1 while True: f.setPointSize(fs) br = QFontMetrics(f).boundingRect(self.text()) if br.height() <= cr.height() and br.width() <= cr.width(): fs += 1 else: if self.wordWrap() == False: wouldfit = (max(fs - 1, 1)) # if the length have to fit into the label if wouldfit > maximum: wouldfit = maximum f.setPointSize(wouldfit) # if wordwrap is wanted by the user... he expects wordwrap. else: wouldfit = max(fs - 1, 1)*1.5 if wouldfit > maximum: wouldfit = maximum f.setPointSize(wouldfit) # if wordwrap is wanted by the user... he expects wordwrap. #f.setPointSize(max(fs - 1, 1)*1.5) # if wordwrap is wanted by the user... he expects wordwrap. break # --- update font size --- self.setFont(f)
def create_scale_marker_values_text(self): painter = QPainter(self) # painter.setRenderHint(QPainter.HighQualityAntialiasing) painter.setRenderHint(QPainter.Antialiasing) # Koordinatenursprung in die Mitte der Flaeche legen painter.translate(self.width() / 2, self.height() / 2) # painter.save() font = QFont(self.scale_fontname, self.scale_fontsize) fm = QFontMetrics(font) pen_shadow = QPen() pen_shadow.setBrush(self.ScaleValueColor) painter.setPen(pen_shadow) text_radius_factor = 0.8 text_radius = self.widget_diameter/2 * text_radius_factor scale_per_div = int((self.value_max - self.value_min) / self.scala_main_count) angle_distance = (float(self.scale_angle_size) / float(self.scala_main_count)) for i in range(self.scala_main_count + 1): # text = str(int((self.value_max - self.value_min) / self.scala_main_count * i)) text = str(int(self.value_min + scale_per_div * i)) w = fm.width(text) + 1 h = fm.height() painter.setFont(QFont(self.scale_fontname, self.scale_fontsize)) angle = angle_distance * i + float(self.scale_angle_start_value - self.angle_offset) x = text_radius * math.cos(math.radians(angle)) y = text_radius * math.sin(math.radians(angle)) # print(w, h, x, y, text) text = [x - int(w/2), y - int(h/2), int(w), int(h), Qt.AlignCenter, text] painter.drawText(text[0], text[1], text[2], text[3], text[4], text[5])
def text_size ( self, text ): """ Returns the size (dx,dy) of the specified text using the current font. """ rect = QFontMetrics( self.font ).boundingRect( text ) return ( rect.width(), rect.height() )
def adjustFont(self): # --- fetch current parameters ---- f = self.font() cr = self.contentsRect() if self.maxFont is not None: maximum = self.maxFont.pointSize() else: maximum = self.font().pointSize() # --- find the font size that fits the contentsRect --- fs = 1 while True: f.setPointSize(fs) br = QFontMetrics(f).boundingRect(self.text()) if br.height() <= cr.height() and br.width() <= cr.width(): fs += 1 else: if self.wordWrap() == False: wouldfit = (max(fs - 1, 1) ) # if the length have to fit into the label if wouldfit > maximum: wouldfit = maximum f.setPointSize( wouldfit ) # if wordwrap is wanted by the user... he expects wordwrap. else: wouldfit = max(fs - 1, 1) * 1.5 if wouldfit > maximum: wouldfit = maximum f.setPointSize( wouldfit ) # if wordwrap is wanted by the user... he expects wordwrap. #f.setPointSize(max(fs - 1, 1)*1.5) # if wordwrap is wanted by the user... he expects wordwrap. break # --- update font size --- self.setFont(f)
def show_completions(self, completions, parent): self.last_completions = completions self.parent = parent self.clear() if not completions: self.hide() return maxcomp = max(map(len, completions)) total = sum(map(len, completions)) rowcol = math.ceil(math.sqrt(maxcomp)) log.debug("completions=%s max completion has len %d, total %d, rowcol=%d", completions, maxcomp, total, rowcol) the_completions = self.last_completions[:] if self.cur_position >= len(the_completions): self.cur_position = len(the_completions) - 1 if len(the_completions) > 0: the_completions[self.cur_position] = "<b>" + the_completions[self.cur_position] + "</b>" self.setText('<br>'.join(the_completions)) p = parent.mapToGlobal(QPoint(0,0)) self.show() ph = parent.height() pw = parent.width() mh = self.height() mw = self.width() self.move(QPoint(p.x() + (pw-mw)/2, p.y() + (ph-mh)/2)) font = self.font() metrics = QFontMetrics(font) log.debug("chwidth=%d h=%d", metrics.averageCharWidth(), metrics.height())
def __init__(self,parent, font_name, font_size, cols, rows, colorscheme): super().__init__(parent) self.callback_scrollbar= None # # determine font metrics and terminal window size in pixel # font= QFont(font_name) font.setPixelSize(font_size) metrics= QFontMetrics(font) font_width=metrics.width("A") font_height=metrics.height() width= font_width*cols height= int(font_height* rows) # # create terminal window and scrollbar # self.hbox= QHBoxLayout() self.terminalwidget= QTerminalWidget(self,font_name,font_size,font_height, width,height, colorscheme) self.hbox.addWidget(self.terminalwidget) self.hbox.setAlignment(self.terminalwidget,Qt.AlignLeft) self.scrollbar= QScrollBar() self.hbox.addWidget(self.scrollbar) self.hbox.setAlignment(self.scrollbar,Qt.AlignLeft) self.setLayout(self.hbox) # # initialize scrollbar # self.scrollbar.valueChanged.connect(self.do_scrollbar) self.scrollbar.setEnabled(False)
def _updateFontSize(self): from ..app import APP_INSTANCE font = self.view.font() font.setPointSize(APP_INSTANCE.prefs.tableFontSize) self.view.setFont(font) fm = QFontMetrics(font) self.view.verticalHeader().setDefaultSectionSize(fm.height()+2)
def rebuild( self ): """ Rebuilds the path for this connection based on the given connection \ style parameters that have been set. :return <QPainterPath> """ # create the path path = self.rebuildPath() self._polygons = self.rebuildPolygons(path) if ( self._textItem ): point = path.pointAtPercent(0.5) metrics = QFontMetrics(self._textItem.font()) point.setY(point.y() - metrics.height() / 2.0) self._textItem.setPos(point) # create the path for the item for poly in self._polygons: path.addPolygon(poly) # unmark as dirty self.setDirty(False) return path
def minimumLabelHeight(self): """ Returns the minimum height that will be required based on this font size and labels list. """ metrics = QFontMetrics(self.labelFont()) return max(self._minimumLabelHeight, metrics.height() + self.verticalLabelPadding())
def __init__(self, view: Amendment('view/', lambda v: hasattr(v, 'mode') and (v.mode.name == 'ipython') and (v.widget is None))): #, orig_editor=None): if view.widget is None: self.globals = {} self.globals['ddic'] = ddic for a in ddic['actions']: self.globals[a] = ddic['actions'][a] self.locals = {} # ddic.provide('interactive', -1) else: self.globals = view.widget.globals self.locals = view.widget.locals super().__init__(view) # Set the default font font = QFont() font.setFamily('DejaVu Sans Mono') font.setFixedPitch(True) font.setPointSize(10) self.setFont(font) # self.parser = Parser(self, 'python3') # self.ca = PyInterpretContentAssist() fontmetrics = QFontMetrics(font) # Brace matching: enable for a brace immediately before or after # the current position # self.setBraceMatching(QsciScintilla.SloppyBraceMatch) # Current line visible with special background color self.setCaretLineVisible(True) self.setCaretLineBackgroundColor(QColor("#ffe4e4")) # Set Python lexer # Set style for Python comments (style number 1) to a fixed-width # courier. # # self.SendScintilla(QsciScintilla.SCI_STYLESETFONT, 1, 'DejaVu Sans Mono'.encode()) # Don't want to see the horizontal scrollbar at all # Use raw message to Scintilla here (all messages are documented # here: http://www.scintilla.org/ScintillaDoc.html) self.SendScintilla(QsciScintilla.SCI_SETHSCROLLBAR, 0) self.SendScintilla(QsciScintilla.SCI_SETVSCROLLBAR, 0) self.setMinimumSize(fontmetrics.width("00000"), fontmetrics.height()+4) self.markerDefine(QsciScintilla.RightArrow, self.ARROW_MARKER_NUM) # self.setMarkerBackgroundColor(QColor("#ee1111"), # self.ARROW_MARKER_NUM) self.prompt_begin = 0 self.focus_view = None self.interactive = False
def setFont(self, f): # recalculate all of our metrics/offsets fm = QFontMetrics(f) self.font_width = fm.width('X') self.font_height = fm.height() self.updateScrollbars() # TODO: assert that we are using a fixed font & find out if we care? QAbstractScrollArea.setFont(self,f) return
def __calcMaxTextSize(self, font, hodnoty): fm = QFontMetrics(font); x = 0 y = fm.height() for hodnota in hodnoty: w = fm.width(hodnota) if w > x: x = w return (x, y)
def __init__(self, ds): rowFM = QFontMetrics(ds.rowFont()) self.splitFM = QFontMetrics(ds.splitFont()) headerFM = QFontMetrics(ds.headerFont()) self.rowHeight = rowFM.height() + CELL_MARGIN * 2 self.splitHeight = self.splitFM.height() + CELL_MARGIN * 2 self.headerHeight = headerFM.height() + CELL_MARGIN * 2 spannedRowIndexes = set() for rowIndex in range(ds.rowCount()): extraRole = nonone(ds.data(rowIndex, 0, EXTRA_ROLE), 0) if extraRole & EXTRA_SPAN_ALL_COLUMNS: spannedRowIndexes.add(rowIndex) self.columns = [] for colIndex in range(ds.columnCount()): col = ds.columnAtIndex(colIndex) sumWidth = 0 maxWidth = 0 # We need to have *at least* the width of the header. minWidth = headerFM.width(col.display) + CELL_MARGIN * 2 for rowIndex in range(ds.rowCount()): if rowIndex in spannedRowIndexes: continue data = ds.data(rowIndex, colIndex, Qt.DisplayRole) if data: font = ds.data(rowIndex, colIndex, Qt.FontRole) fm = QFontMetrics(font) if font is not None else rowFM width = fm.width(data) + CELL_MARGIN * 2 width += ds.indentation(rowIndex, colIndex) sumWidth += width maxWidth = max(maxWidth, width) pixmap = ds.data(rowIndex, colIndex, Qt.DecorationRole) if pixmap is not None: width = pixmap.width() + CELL_MARGIN * 2 maxWidth = max(maxWidth, width) avgWidth = sumWidth // ds.rowCount() maxWidth = max(maxWidth, minWidth) if col.cantTruncate: # if it's a "can't truncate" column, we make no concession minWidth = maxWidth cs = ColumnStats(colIndex, col, avgWidth, maxWidth, minWidth) self.columns.append(cs) self.maxWidth = sum(cs.maxWidth for cs in self.columns) self.minWidth = sum(cs.minWidth for cs in self.columns)
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 _updateFontSize(self, prefs): font = self.view.font() font.setPointSize(prefs.tableFontSize) self.view.setFont(font) fm = QFontMetrics(font) self.view.verticalHeader().setDefaultSectionSize(fm.height()+2) # (#14, #15) When a new font was selected in the preferences panel, # the column would redraw but not resize appropriately. A call # to resize(sizeHint()) was added on the update of the size info # in the custom drawing for the amount field. self.view.resize(self.view.sizeHint())
def setRect(self, fm=None): if fm is None: font = self.font() if font is None: return fm = QFontMetrics(font) lineHeight = fm.height() height = lineHeight * self._dataLen() * 1.1 width = max(fm.width(data) for data in self._iterData()) + 10 if height != self._rect.height() or width != self._rect.width(): self.prepareGeometryChange() self._rect.setBottomRight(QPointF(width, height))
def sizeHint(self): """QWidget.sizeHint implementation. Returns height of 1 line of text """ fm = QFontMetrics(self.font()) h = max(fm.height(), 14) + 4 w = fm.width('x') * 17 + 4 opt = QStyleOptionFrameV2() opt.initFrom(self); return self.style().sizeFromContents(QStyle.CT_LineEdit, opt, QSize(w, h).expandedTo(QApplication.globalStrut()), self)
def __init__(self, parent=None): super(HtmlLineEdit, self).__init__(parent) self.setLineWrapMode(QTextEdit.NoWrap) self.setTabChangesFocus(True) self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) fm = QFontMetrics(self.font()) h = int(fm.height() * (1.4 if platform.system() == "Windows" \ else 1.2)) self.setMinimumHeight(int(h*1.3)) self.setMaximumHeight(int(h * 1.6))
def setRect(self, fm = None): if fm is None: font = self.font() if font is None: return fm = QFontMetrics(font) lineHeight = fm.height() height = lineHeight * self._dataLen() * 1.1 width = max(fm.width(data) for data in self._iterData()) + 10 if height != self._rect.height() or width != self._rect.width(): self.prepareGeometryChange() self._rect.setBottomRight(QPointF(width, height))
def paint(self, painter, dummyOption, dummyWidget = None): painter.save() try: font = self.font() if font is None: font = painter.font() else: painter.setFont(font) fm = QFontMetrics(painter.font()) self.setRect(fm) lineHeight = fm.height() for index, data in enumerate(self._iterData()): painter.drawText(QPoint(5, (index + 1) * lineHeight), data) finally: painter.restore()
def paint(self, painter, dummyOption, dummyWidget=None): painter.save() try: font = self.font() if font is None: font = painter.font() else: painter.setFont(font) fm = QFontMetrics(painter.font()) self.setRect(fm) lineHeight = fm.height() for index, data in enumerate(self._iterData()): painter.drawText(QPoint(5, (index + 1) * lineHeight), data) finally: painter.restore()
def getMinimumWidth(self, items = None): fm = QFontMetrics(self.font()) opt = QStyleOptionComboBox() style = self.style() mw = self.maxWidth if items is not None: for str in items: opt.currentText = QString(str) sz = QSize(fm.width(opt.currentText), fm.height()) mw = max(mw, style.sizeFromContents(QStyle.CT_ComboBox, opt, sz, self).width()) elif mw == 0 and self.count() > 0: for i in range(0, self.count()): opt.currentText = self.itemText(i) sz = QSize(fm.width(opt.currentText), fm.height()) mw = max(mw, style.sizeFromContents(QStyle.CT_ComboBox, opt, sz, self).width()) elif mw == 0: opt.currentText = QString(' ') sz = QSize(fm.width(opt.currentText), fm.height()) mw = max(mw, style.sizeFromContents(QStyle.CT_ComboBox, opt, sz, self).width()) self.maxWidth = mw return mw
def populate(self, phrase, ts, process_space=True): phrase_pos = 0 processed = False matches = self.__class__.whitespace.finditer(phrase) font = QFont(ts.font) if self.valign is not None: font.setPixelSize(font.pixelSize() / 1.5) fm = QFontMetrics(font) single_space_width = fm.width(' ') height, descent = fm.height(), fm.descent() for match in matches: processed = True left, right = match.span() if not process_space: right = left space_width = single_space_width * (right - left) word = phrase[phrase_pos:left] width = fm.width(word) if self.current_width + width < self.line_length: self.commit(word, width, height, descent, ts, font) if space_width > 0 and self.current_width + space_width < self.line_length: self.add_space(space_width) phrase_pos = right continue # Word doesn't fit on line if self.hyphenate and len(word) > 3: tokens = hyphenate_word(word) for i in range(len(tokens) - 2, -1, -1): word = ''.join(tokens[0:i + 1]) + '-' width = fm.width(word) if self.current_width + width < self.line_length: self.commit(word, width, height, descent, ts, font) return phrase_pos + len(word) - 1, True if self.current_width < 5: # Force hyphenation as word is longer than line for i in range(len(word) - 5, 0, -5): part = word[:i] + '-' width = fm.width(part) if self.current_width + width < self.line_length: self.commit(part, width, height, descent, ts, font) return phrase_pos + len(part) - 1, True # Failed to add word. return phrase_pos, True if not processed: return self.populate(phrase + ' ', ts, False) return phrase_pos, False
def populate(self, phrase, ts, process_space=True): phrase_pos = 0 processed = False matches = self.__class__.whitespace.finditer(phrase) font = QFont(ts.font) if self.valign is not None: font.setPixelSize(font.pixelSize()/1.5) fm = QFontMetrics(font) single_space_width = fm.width(' ') height, descent = fm.height(), fm.descent() for match in matches: processed = True left, right = match.span() if not process_space: right = left space_width = single_space_width * (right-left) word = phrase[phrase_pos:left] width = fm.width(word) if self.current_width + width < self.line_length: self.commit(word, width, height, descent, ts, font) if space_width > 0 and self.current_width + space_width < self.line_length: self.add_space(space_width) phrase_pos = right continue # Word doesn't fit on line if self.hyphenate and len(word) > 3: tokens = hyphenate_word(word) for i in range(len(tokens)-2, -1, -1): word = ''.join(tokens[0:i+1])+'-' width = fm.width(word) if self.current_width + width < self.line_length: self.commit(word, width, height, descent, ts, font) return phrase_pos + len(word)-1, True if self.current_width < 5: # Force hyphenation as word is longer than line for i in range(len(word)-5, 0, -5): part = word[:i] + '-' width = fm.width(part) if self.current_width + width < self.line_length: self.commit(part, width, height, descent, ts, font) return phrase_pos + len(part)-1, True # Failed to add word. return phrase_pos, True if not processed: return self.populate(phrase+' ', ts, False) return phrase_pos, False
def __init__(self, parent=None): super(RichTextLineEdit, self).__init__(parent) self.monofamily = QString("courier") self.sansfamily = QString("helvetica") self.seriffamily = QString("times") self.setLineWrapMode(QTextEdit.NoWrap) self.setTabChangesFocus(True) self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) fm = QFontMetrics(self.font()) h = int(fm.height() * (1.4 if platform.system() == "Windows" else 1.2)) self.setMinimumHeight(h) self.setMaximumHeight(int(h * 1.2)) self.setToolTip("Press <b>Ctrl+M</b> for the text effects " "menu and <b>Ctrl+K</b> for the color menu")
def create_digital_indicator(self): """ Main value indicator inside the Gauge """ painter = QPainter(self) # painter.setRenderHint(QPainter.HighQualityAntialiasing) painter.setRenderHint(QPainter.Antialiasing) # Koordinatenursprung in die Mitte der Flaeche legen # Place the coordinate origin in the center painter.translate(*self.center_p()) # painter.save() # xShadow = 3.0 # yShadow = 3.0 font = QFont(self.value_fontname, self.value_fontsize) fm = QFontMetrics(font) pen_shadow = QPen() pen_shadow.setBrush(self.DisplayValueColor) painter.setPen(pen_shadow) text_radius = self.widget_diameter / 2 * self.text_radius_factor # angle_distance = (float(self.scale_angle_size) / float(self.scala_main_count)) # for i in range(self.scala_main_count + 1): text = str(int(self.value)) w = fm.width(text) + 1 h = fm.height() painter.setFont(QFont(self.value_fontname, self.value_fontsize)) # Mitte zwischen Skalenstart und Skalenende: # Skalenende = Skalenanfang - 360 + Skalenlaenge # Skalenmitte = (Skalenende - Skalenanfang) / 2 + Skalenanfang angle_end = float(self.scale_angle_start_value + self.scale_angle_size - 360) angle = (angle_end - self.scale_angle_start_value ) / 2 + self.scale_angle_start_value x = text_radius * math.cos(math.radians(angle)) y = text_radius * math.sin(math.radians(angle)) # print(w, h, x, y, text) text = [ x - int(w / 2), y - int(h / 2), int(w), int(h), Qt.AlignCenter, text ] painter.drawText(text[0], text[1], text[2], text[3], text[4], text[5])
def paint(self, painter, dummyOption, dummyWidget=None): painter.save() try: scheme = self._qScore.parent().colourScheme painter.setPen(QPen(scheme.text.borderColour)) font = self.font() if font is None: font = painter.font() else: painter.setFont(font) fm = QFontMetrics(painter.font()) self.setRect(fm) lineHeight = fm.height() for index, data in enumerate(self._iterData()): painter.drawText(QPoint(5, (index + 1) * lineHeight), data) finally: painter.restore()
def paint(self, painter, dummyOption, dummyWidget = None): painter.save() try: scheme = self._qScore.parent().colourScheme painter.setPen(QPen(scheme.text.borderColour)) font = self.font() if font is None: font = painter.font() else: painter.setFont(font) fm = QFontMetrics(painter.font()) self.setRect(fm) lineHeight = fm.height() for index, data in enumerate(self._iterData()): painter.drawText(QPoint(5, (index + 1) * lineHeight), data) finally: painter.restore()
def setupUi(self): super(MainWindow, self).setupUi(self) self.search_box.shortcut = QShortcut(self.search_box) self.search_box.shortcut.setKey('CTRL+F') self.output_devices_group = QActionGroup(self) self.input_devices_group = QActionGroup(self) self.alert_devices_group = QActionGroup(self) # adjust search box height depending on theme as the value set in designer isn't suited for all themes search_box = self.search_box option = QStyleOptionFrameV2() search_box.initStyleOption(option) frame_width = search_box.style().pixelMetric(QStyle.PM_DefaultFrameWidth, option, search_box) if frame_width < 4: search_box.setMinimumHeight(20 + 2*frame_width) # adjust status combo-box font size to fit the combo-box option = QStyleOptionComboBox() self.status.initStyleOption(option) frame_width = self.status.style().pixelMetric(QStyle.PM_DefaultFrameWidth, option, self.status) font = self.status.font() font.setFamily('Sans Serif') font.setPointSize(font.pointSize() - 1) # make it 1 point smaller then the default font size font_metrics = QFontMetrics(font) if font_metrics.height() > self.status.maximumHeight() - 2*frame_width: pixel_size = 11 - (frame_width - 2) # subtract 1 pixel for every frame pixel over 2 pixels font.setPixelSize(pixel_size) self.status.setFont(font) # adjust the combo boxes for themes with too much padding (like the default theme on Ubuntu 10.04) option = QStyleOptionComboBox() self.status.initStyleOption(option) font_metrics = self.status.fontMetrics() text_width = max(font_metrics.width(self.status.itemText(index)) for index in xrange(self.status.count())) frame_width = self.status.style().pixelMetric(QStyle.PM_ComboBoxFrameWidth, option, self.status) arrow_width = self.status.style().subControlRect(QStyle.CC_ComboBox, option, QStyle.SC_ComboBoxArrow, self.status).width() wide_padding = self.status.style().subControlRect(QStyle.CC_ComboBox, option, QStyle.SC_ComboBoxEditField, self.status).height() < 10 self.status.setFixedWidth(text_width + arrow_width + 2*frame_width + 30) # 30? Don't ask. self.status.setStyleSheet("""QComboBox { padding: 0px 3px 0px 3px; }""" if wide_padding else "") self.identity.setStyleSheet("""QComboBox { padding: 0px 4px 0px 4px; }""" if wide_padding else "")
def paintSection(self, painter, rect, logicalIndex): gradient = QLinearGradient(0, 0, 0, rect.height()) if self._mouse_over: gradient.setColorAt(0.0, QColor("#808080")) gradient.setColorAt(1.0, QColor("#474747")) else: gradient.setColorAt(0.0, QColor("#727272")) gradient.setColorAt(1.0, QColor("#363636")) painter.fillRect(rect, QBrush(gradient)) if self._is_current_project: painter.setPen(QColor(0, 204, 82)) else: painter.setPen(QColor(Qt.white)) font = painter.font() font.setBold(True) painter.setFont(font) font_metrics = QFontMetrics(painter.font()) ypos = (rect.height() / 2) + (font_metrics.height() / 3) painter.drawText(10, ypos, self.title)
def maxNotchSize( self, orientation ): """ Returns the maximum size for this ruler based on its notches and the given orientation. :param orientation | <Qt.Orientation> :return <int> """ metrics = QFontMetrics(QApplication.font()) if orientation == Qt.Vertical: notch = '' for n in self.notches(): if len(str(n)) > len(str(notch)): notch = str(n) return metrics.width(notch) else: return metrics.height()
def setText(self, text = ''): """ This function is used to update label text. :param text: New text to update label :type text: string """ # Store the text self.text = text # Create a qfont for system font # We will use the font to calculate metrics font = QFont(self.font, 10, QFont.Normal) fm = QFontMetrics(font) # Calculate base_width/height over system font self.font_base_width = fm.width(self.text) self.font_base_height = fm.height() # Re-paint the text self.update()
def create_values_text(self): painter = QPainter(self) # painter.setRenderHint(QPainter.HighQualityAntialiasing) painter.setRenderHint(QPainter.Antialiasing) # Koordinatenursprung in die Mitte der Flaeche legen painter.translate(self.width() / 2, self.height() / 2) # painter.save() # xShadow = 3.0 # yShadow = 3.0 font = QFont(self.value_fontname, self.value_fontsize) fm = QFontMetrics(font) pen_shadow = QPen() pen_shadow.setBrush(self.DisplayValueColor) painter.setPen(pen_shadow) text_radius = self.widget_diameter / 2 * self.text_radius_factor # angle_distance = (float(self.scale_angle_size) / float(self.scala_main_count)) # for i in range(self.scala_main_count + 1): frac, whole = math.modf(self.value) text = ("%0.1f" % (abs(frac)*10)) + 'E' + str(int(whole)) + ' ' + self.units w = fm.width(text) + 1 h = fm.height() painter.setFont(QFont(self.value_fontname, self.value_fontsize)) # Mitte zwischen Skalenstart und Skalenende: # Skalenende = Skalenanfang - 360 + Skalenlaenge # Skalenmitte = (Skalenende - Skalenanfang) / 2 + Skalenanfang angle_end = float(self.scale_angle_start_value + self.scale_angle_size - 360) angle = (angle_end - self.scale_angle_start_value) / 2 + self.scale_angle_start_value x = text_radius * math.cos(math.radians(angle)) y = text_radius * math.sin(math.radians(angle)) # print(w, h, x, y, text) text = [x - int(w/2), y - int(h/2), int(w), int(h), Qt.AlignCenter, text] painter.drawText(text[0], text[1], text[2], text[3], text[4], text[5])
def _calc_size(self): realSize = self.realsize canvaswidth = self.canvas.width() mapunitsperpixel = abs(self.canvas.mapUnitsPerPixel()) mapunits = self.canvas.mapUnits() prefered_units = roam.config.settings.get("prefer_units", "meters") newunits = QGis.fromLiteral(prefered_units, QGis.Meters) mapunitsperpixel *= QGis.fromUnitToUnitFactor(mapunits, newunits) mapunits = newunits # Convert the real distance into pixels barwidth = realSize / mapunitsperpixel if barwidth < 30: barwidth = canvaswidth / 4 while barwidth > canvaswidth / 3: barwidth /= 3 realSize = barwidth * mapunitsperpixel # Round powerof10 = math.floor(math.log10(realSize)) scaler = math.pow(10.0, powerof10) realSize = round(realSize / scaler) * scaler barwidth = realSize / mapunitsperpixel label, realSize = self._label_size(mapunits, realSize) metrics = QFontMetrics(self.font) fontwidth = metrics.width(label) fontheight = metrics.height() sizelabel = QLocale.system().toString(realSize) sizelabel = "{} {}".format(sizelabel, label) barwidth = self._adjust_bar_size(barwidth, mapunits) barwidth = barwidth + fontwidth return barwidth, realSize, sizelabel, (fontwidth, fontheight)
def paint_text(self, QPainter): """ Render the node text (branch name) :param QPainter: interface to the canvas """ # Set up font and text settings text_font = QFont() text_font.setPointSize(NODE_TEXT_FONT_SIZE) QPainter.setFont(text_font) QPainter.setPen(NODE_TEXT_COLOR) # Measure size of strings so they can be centered properly font_metrics = QFontMetrics(text_font) label_text_width = font_metrics.width(self.branch.name) label_text_height = font_metrics.height() # Position and render text label_margin_left = (NODE_WIDTH - label_text_width) / 2 label_margin_top = (NODE_HEIGHT - label_text_height) / 2 label_position = QPointF(label_margin_left, label_margin_top / 2 + label_text_height) QPainter.drawText(label_position, self.branch.name)
def paintEvent(self, event): # Initialize QPainter properties painter = QPainter() painter.begin(self) painter.setRenderHint(QPainter.Antialiasing) if self.height() <= self.width() / self.ref_aspect_ratio: v_scale = self.height() h_scale = v_scale * self.ref_aspect_ratio else: h_scale = self.width() v_scale = h_scale / self.ref_aspect_ratio # Scale all objects proportionate to window size painter.scale(h_scale / self.width_ref, v_scale / self.height_ref) painter.setClipPath(self.dial) # Don't allow objects or text to extend outside of main dial shape painter.save() # First draw main gauge background pen = QPen(painter.pen()) pen.setWidth(1) pen.setColor(Qt.black) painter.setPen(pen) painter.setBrush(QColor(100, 100, 100, 255)) # self.dial_bg) painter.drawPath(self.dial) # Add Minor and Major Alarm limit bars pen.setWidth(16) pen.setCapStyle(Qt.FlatCap) pen.setJoinStyle(Qt.BevelJoin) pen.setColor(Qt.yellow) painter.setPen(pen) painter.setBrush(Qt.NoBrush) painter.drawPath(self.low_arc) painter.drawPath(self.high_arc) pen.setColor(Qt.red) painter.setPen(pen) painter.drawPath(self.lolo_arc) painter.drawPath(self.hihi_arc) painter.restore() # Display PV current value painter.save() font = QFont() font.setPixelSize(45) painter.setFont(font) sevr = self.channel.sevr.lower() if sevr == 'major': color = Qt.red elif sevr == 'minor': color = Qt.yellow elif sevr == 'invalid': color = Qt.magenta else: color = Qt.green pen.setColor(color) painter.setPen(pen) font_metric = QFontMetrics(font) painter.translate(self.dial_width / 2, self.dial_height / 2) label = self.format_label(self.channel_value) painter.drawText(QPointF(0.0 - font_metric.width(label) / 2.0, font_metric.height() / 2.0), label) # Display PV name painter.setFont(self.pv_label_font) pen.setColor(Qt.black) # Qt.darkCyan) pen.setWidth(1) painter.setPen(pen) # brush = QBrush(Qt.darkCyan) # painter.setBrush(brush) font_metric = QFontMetrics(self.pv_label_font) pv_label = self.channel.egu # self.channel.name + ' (' + self.channel.egu + ')' painter.drawText(QPointF(0.0 - font_metric.width(pv_label) / 2.0, (self.dial_height / 2.0) + (font_metric.height() * 1.5)), pv_label) # painter.drawPath(self.pv_label_path) painter.restore() # Next add division markers painter.save() painter.translate(self.dial_width / 2, self.dial_height * 0.98) pen.setColor(Qt.black) # Qt.cyan) pen.setWidth(2) painter.setPen(pen) for i in range(0, 31): if (i % 5) != 0: painter.drawLine(-self.dial_width / 2.1, 0.0, -self.dial_width / 2.2, 0.0) else: painter.drawLine(-self.dial_width / 2.1, 0.0, -self.dial_width / 2.3, 0.0) painter.rotate(6.0) painter.restore() # Layout division text labels painter.save() painter.translate(self.dial_width / 2, self.dial_height * 0.98) pen.setColor(Qt.black) # Qt.cyan) painter.setPen(pen) font = QFont() font.setPixelSize(18) painter.setFont(font) font_metric = QFontMetrics(font) labels = linspace(self.lim_low, self.lim_hi, 7) painter.rotate(-90) for i in range(0, 7): label = self.format_label(labels[i]) painter.drawText(QPointF(0.0 - font_metric.width(label) / 2.0, -self.dial_height * 0.75), label) painter.rotate(30) painter.restore() # Draw needle at appropriate angle for data painter.save() painter.translate(self.dial_width / 2, self.dial_height * 0.98) painter.rotate(-180 * (1.0 - self.percentage)) pen.setColor(QColor(self.needle_color).darker(200)) pen.setWidth(1) painter.setPen(pen) painter.setBrush(self.needle_color) painter.drawPolygon(self.needle) painter.restore() # if self.percentage <= 0.5: # shadow = max(490 * self.percentage, 127) # needle_left_color = QColor(0, shadow, shadow) # Qt.darkCyan # QColor(80,80,80,255) # needle_right_color = Qt.cyan # QColor(230,230,230,255) # else: # shadow = max(125 / self.percentage, 127) # needle_left_color = Qt.cyan # QColor(230,230,230,255) # needle_right_color = QColor(0, shadow, shadow) # Qt.darkCyan # QColor(80,80,80,255) # # # Draw Highlight side of needle # pen.setWidth(1) # pen.setColor(Qt.gray) # needle_left_color) # painter.setPen(pen) # painter.setBrush(Qt.gray) # needle_left_color) # painter.drawPolygon(self.needle_left) # # # Draw shadow side of needle # pen.setColor(Qt.gray) # needle_right_color) # painter.setPen(pen) # painter.setBrush(Qt.gray) # needle_right_color) # painter.drawPolygon(self.needle_right) # painter.restore() # Draw needle axel pin painter.save() pen.setWidth(1) pen.setColor(Qt.black) painter.setPen(pen) painter.setBrush(QColor(50, 50, 50, 255)) # self.pin_bg) painter.translate(self.dial_width / 2, self.dial_height * 0.98) painter.drawEllipse(self.pin_rect) painter.restore() # Draw glass reflection and shadow effects # painter.save() # painter.translate(self.dial_width / 2.0, self.dial_height / 2.0) # painter.setPen(Qt.NoPen) # painter.setBrush(QColor(0, 0, 0, 20)) # painter.drawEllipse(self.shadow_rect) # painter.setBrush(self.gloss_gradient) # painter.drawEllipse(self.gloss_rect) # painter.restore() painter.end()
class asciiItem(QGraphicsTextItem): def __init__(self, whex): QGraphicsTextItem.__init__(self) self.initValues(whex) self.initPosition() self.initFont() self.initMetricsValues() # self.initCursor() def initPosition(self): self.setPos(485, 25) # self.setTextInteractionFlags(Qt.TextSelectableByMouse) 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 #Current Positions self.currentPos = 0 # def initCursor(self): # self.cursor = asciiCursor(self) # self.bdiff.scene.addItem(self.cursor) def initFont(self): self.setDefaultTextColor(QColor(Qt.darkCyan)) self.font = QFont("Gothic") self.font.setFixedPitch(1) self.font.setBold(False) self.font.setPixelSize(self.fontPixel) self.setFont(self.font) self.sfont = QFont("Gothic") self.sfont.setFixedPitch(1) self.sfont.setBold(False) self.sfont.setPixelSize(self.fontPixel) self.metric = QFontMetrics(self.font) self.metric = QFontMetrics(self.font) def initMetricsValues(self): #Calibrate calibrate = QString("A") self.charsByByte = 1 self.charW = self.metric.width(calibrate) self.charH = self.metric.height() self.byteW = self.charW * self.charsByByte self.byteH = self.charH def initStartBlank(self): self.lineW = self.boundingRect().width() self.startBlank = self.lineW - (self.byteW * 16) # print "start ASCII blank" # print self.startBlank #Print Operations def printBuffer(self, buff): del self.buffer self.buffer = buff count = 0 printer = QString() for char in buff: if char > "\x20" and char < "\x7e": printer.append(char) else: printer.append(".") if count < 15: count += 1 else: printer.append("\n") count = 0 #Clear and set cursor = self.textCursor() cursor.movePosition(QTextCursor.Start) cursor.movePosition(QTextCursor.End, QTextCursor.KeepAnchor) self.setPlainText(printer) cursor.movePosition(QTextCursor.Start) def colorizeDiff(self, diffinfos): cursor = self.textCursor() cursor.setPosition(QTextCursor.Start) text = self.toPlainText() keys = diffinfos.keys() keys.sort() for offset in keys: difflen = diffinfos[offset] pos = offset + (offset / 16) # count = offset / 16 # print "offset ", offset, " count ", count count = difflen + (((offset + difflen) / 16) - (offset / 16)) # count = difflen cursor.setPosition(pos, QTextCursor.MoveAnchor) # print "L", l, " len ", pos + difflen cursor.movePosition(QTextCursor.NextCharacter, QTextCursor.KeepAnchor, count) format = QTextCharFormat() format.setFont(self.sfont) format.setForeground(QBrush(QColor(Qt.red))) cursor.setCharFormat(format) cursor.setPosition(QTextCursor.Start, QTextCursor.MoveAnchor)
def imprimir(self, printer): leftMargin = 72 widthCol = 100 arialFont = QFont("Helvetica", 16, 3) fuente = QFontMetrics(arialFont) arialLineHeight = fuente.height() fondo = QPixmap(":/images/res/fondo.png") painter = QPainter(printer) pageRect = printer.pageRect() page = 1 painter.save() if self.vistaprevia: painter.drawPixmap(0, 0, 530, 830, fondo) painter.setFont(arialFont) y = 180 x = 35 painter.drawText(x, y, self.editmodel.fecha.toString("dd MM yy")) y = 210 x = 85 painter.drawText(x, y, self.editmodel.cliente) painter.setFont(arialFont) cajasFont = QFont("Helvetica", 10, 2) x = -5 y = 295 painter.setFont(cajasFont) painter.drawText(x, y - arialLineHeight - 1, "Cajas") for row in self.editmodel.lines: painter.setFont(cajasFont) x = 2 painter.drawText(x, y, row.cantidad()) painter.setFont(arialFont) total = moneyfmt(row.total, 2, "") x = 470 - fuente.width(total) painter.drawText(x, y, total) x = 310 painter.drawText(x, y, moneyfmt(row.itemPrice, 2, "")) x = 30 painter.drawText(x, y, row.unidades()) x = 80 painter.drawText(x, y, row.itemDescription) y += arialLineHeight total = moneyfmt(self.editmodel.total, 2, "") y = 690 x = 470 - fuente.width(total) painter.drawText(x, y, total) painter.setPen(Qt.black) # printer.newPage() painter.restore()
class hexItem(QGraphicsTextItem): def __init__(self, whex): QGraphicsTextItem.__init__(self) self.initValues(whex) self.initPosition() self.initFont() self.initMetricsValues() def initPosition(self): self.setPos(95, 25) def initValues(self, whex): self.whex = whex self.bdiff = self.whex.bdiff self.hexview = self.whex.view #Buffer self.buffer = [] self.fontPixel = 14 #Current Position self.bytesPerLine = self.bdiff.bytesPerLine self.groupBytes = self.bdiff.groupBytes #Selection self.select = False self.xsel = 0 self.ysel = 0 def initDocument(self): self.document = QTextDocument() self.setDocument(self.document) def initFont(self): self.setDefaultTextColor(QColor(Qt.black)) self.font = QFont("Gothic") self.font.setFixedPitch(1) self.font.setBold(False) self.font.setPixelSize(self.fontPixel) # self.setFont(self.font) self.setFont(self.font) #Search Highlight font self.sfont = QFont("Gothic") self.sfont.setFixedPitch(1) self.sfont.setBold(False) self.sfont.setPixelSize(self.fontPixel) self.metric = QFontMetrics(self.font) def initMetricsValues(self): #Calibrate calibrate = QString("A") self.charsByByte = 2 * self.groupBytes self.charW = self.metric.width(calibrate) self.charH = self.metric.height() self.byteW = self.charW * self.charsByByte self.byteH = self.charH def initStartBlank(self): self.lineW = self.boundingRect().width() self.startBlank = self.lineW - (self.byteW * self.bytesPerLine) - ( self.charW * (self.bytesPerLine - 1)) #Print Operations def dumpHexBuffer(self, buff): self.printFullBuffer(buff) def dumpEOF(self): cursor = self.textCursor() cursor.movePosition(QTextCursor.Start) cursor.movePosition(QTextCursor.End, QTextCursor.KeepAnchor) self.setPlainText("\t\tEnd of file") cursor.movePosition(QTextCursor.Start) def printFullBuffer(self, buff): del self.buffer pos = str(len(buff)) + 'B' self.buffer = struct.unpack(pos, buff) count = 0 fullBuff = QString() for byte in self.buffer: fullBuff.append("%.2x" % byte) if count < 15: fullBuff.append(" ") count += 1 else: fullBuff.append("\n") count = 0 cursor = self.textCursor() cursor.movePosition(QTextCursor.Start) cursor.movePosition(QTextCursor.End, QTextCursor.KeepAnchor) self.setPlainText(fullBuff) cursor.movePosition(QTextCursor.Start) def colorizeDiff(self, diffinfos): cursor = self.textCursor() cursor.setPosition(QTextCursor.Start) text = self.toPlainText() keys = diffinfos.keys() keys.sort() for offset in keys: difflen = diffinfos[offset] pos = (offset * 2) + offset count = difflen + (((offset + difflen) / 16) - (offset / 16)) cursor.setPosition(pos, QTextCursor.MoveAnchor) cursor.movePosition(QTextCursor.NextWord, QTextCursor.KeepAnchor, count) format = QTextCharFormat() format.setFont(self.sfont) format.setForeground(QBrush(QColor(Qt.red))) cursor.setCharFormat(format) cursor.setPosition(QTextCursor.Start, QTextCursor.MoveAnchor)
class hexItem(QGraphicsTextItem): def __init__(self, whex): QGraphicsTextItem.__init__(self) self.initValues(whex) self.initPosition() # self.initDocument() self.initFont() self.initMetricsValues() # self.initCursor() def initPosition(self): self.setPos(95, 25) def initValues(self, whex): self.whex = whex self.heditor = self.whex.heditor self.hexview = self.whex.view #Buffer self.buffer = [] self.fontPixel = 14 #Current Position self.bytesPerLine = self.heditor.bytesPerLine self.groupBytes = self.heditor.groupBytes #Selection self.select = False self.xsel = 0 self.ysel = 0 def initDocument(self): self.document = QTextDocument() self.setDocument(self.document) # def initSyntaxHighlighter(self): # self.search = self.heditor.right.search # self.highlighter = highlighter(self) # def initCursor(self): # self.cursor = hexCursor(self) # self.heditor.whex.view.scene.addItem(self.cursor) def initFont(self): self.setDefaultTextColor(QColor(Qt.black)) self.font = QFont("Gothic") self.font.setFixedPitch(1) self.font.setBold(False) self.font.setPixelSize(self.fontPixel) # self.setFont(self.font) self.setFont(self.font) #Search Highlight font self.sfont = QFont("Gothic") self.sfont.setFixedPitch(1) self.sfont.setBold(False) self.sfont.setPixelSize(self.fontPixel) self.metric = QFontMetrics(self.font) def initMetricsValues(self): #Calibrate calibrate = QString("A") self.charsByByte = 2 * self.groupBytes self.charW = self.metric.width(calibrate) self.charH = self.metric.height() self.byteW = self.charW * self.charsByByte self.byteH = self.charH def initStartBlank(self): self.lineW = self.boundingRect().width() self.startBlank = self.lineW - (self.byteW * self.bytesPerLine) - (self.charW * (self.bytesPerLine - 1)) # print "start blank" # print self.startBlank # def getPatternOffsets(self, buff): # plist = self.search.searchedPatterns # startoffset = self.heditor.currentOffset # offlist = {} # for pattern, offsetlist in plist.iteritems(): # for offset in offsetlist: # if offset >= startoffset and offset <= startoffset + self.heditor.readSize: # offlist[offset - self.heditor.currentOffset] = len(pattern) / 2 # return offlist #Print Operations def dumpHexBuffer(self, buff): self.printFullBuffer(buff) # searchofflist = self.getPatternOffsets(buff) # if len(searchofflist) > 0: # highoffsets = searchofflist.keys() # highoffsets.sort() # self.highlighter(searchofflist) def printFullBuffer(self, buff): del self.buffer pos = str(len(buff)) + 'B' self.buffer = struct.unpack(pos, buff) count = 0 fullBuff = QString() for byte in self.buffer: fullBuff.append("%.2x" % byte) if count < 15: fullBuff.append(" ") count += 1 else: fullBuff.append("\n") count = 0 cursor = self.textCursor() cursor.movePosition(QTextCursor.Start) cursor.movePosition(QTextCursor.End, QTextCursor.KeepAnchor) self.setPlainText(fullBuff) cursor.movePosition(QTextCursor.Start) # if len(self.search.searchedPatterns) > 0: # self.highlighter.highlightBlock(self.document.toPlainText()) def getXPos(self, x): count = 0 current = self.byteW + (self.charW / 2) + (self.startBlank / 2) while current < x: count += 1 current = current + self.byteW + self.charW return count def getYPos(self, y): count = 0 current = self.byteH while current < y: count += 1 current = current + self.byteH return count def highlighter(self, searchofflist): offsets = searchofflist.keys() cursor = self.textCursor() cursor.setPosition(QTextCursor.Start) for offset in offsets: len = searchofflist[offset] pos = (offset * 2) + offset cursor.setPosition(pos, QTextCursor.MoveAnchor) l = 0 while l < len: cursor.movePosition(QTextCursor.NextWord, QTextCursor.KeepAnchor) l += 1 format = QTextCharFormat() format.setFont(self.sfont) format.setForeground(QBrush(QColor(Qt.red))) cursor.setCharFormat(format) cursor.setPosition(QTextCursor.Start, QTextCursor.MoveAnchor) ############## # # MOUSE EVENTS # ########################### ############## # def mouseMoveEvent(self, event): pos = event.pos() x = pos.x() y = pos.y() xpos = self.getXPos(x) ypos = self.getYPos(y) self.heditor.selection.select(self.heditor.selection.xstart, self.heditor.selection.ystart, xpos, ypos) self.heditor.infos.update() self.heditor.right.decode.update() def mousePressEvent(self, event): button = event.button() pos = event.pos() if event.button() == 1: #Get CLicked coordonates x = pos.x() y = pos.y() xpos = self.getXPos(x) ypos = self.getYPos(y) #refresh cursors self.whex.hexcursor.draw(xpos, ypos) self.whex.asciicursor.draw(xpos, ypos) self.heditor.selection.select(xpos, ypos, xpos, ypos, True) self.heditor.right.decode.update() self.heditor.infos.update() def mouseReleaseEvent(self, event): pass
def sizeHint(self): fm = QFontMetrics(self.font()) width = fm.width('999-999') + 10 height = fm.height() + 8 return QSize(width, height)
class ScaleBarItem(QGraphicsItem): def __init__(self, canvas, parent=None): super(ScaleBarItem, self).__init__(parent) self.canvas = canvas self.realsize = 100 black = QColor(Qt.black) black.setAlpha(150) white = QColor(Qt.white) white.setAlpha(150) blackpen = QPen(black, 4) whitepen = QPen(white, 8) self.pens = [whitepen, blackpen] self.whitepen = QPen(white, 1) self.blackbrush = QBrush(black) self.ticksize = 10 self.fontsize = 15 self.font = QFont() self.font.setPointSize(self.fontsize) self.font.setStyleHint(QFont.Times, QFont.PreferAntialias) self.font.setBold(True) self.metrics = QFontMetrics(self.font) def boundingRect(self): try: width, realsize, label, fontsize = self._calc_size() halfheight = (self.ticksize + fontsize[1]) / 2 halfwidth = (width + fontsize[0]) / 2 return QRectF(-halfwidth, -halfheight, halfwidth, halfheight) except ZeroDivisionError: return QRectF() def paint(self, painter, styleoptions, widget=None): try: width, realsize, label, fontsize = self._calc_size() except ZeroDivisionError: return mapunits = self.canvas.mapUnits() # painter.drawRect(self.boundingRect()) array = QPolygon() canvasheight = self.canvas.height() canvaswidth = self.canvas.width() margin = 20 originy = 0 originx = 0 self.setPos(margin, canvasheight - margin) x1, y1 = originx, originy x2, y2 = originx, originy + self.ticksize x3, y3 = originx + width, originy + self.ticksize midx, midy = originx + width / 2, originy + self.ticksize / 2 x4, y4 = originx + width, originy for pen in self.pens: painter.setPen(pen) # Drwa the scale bar painter.drawLine(x1, y1, x2, y2) painter.drawLine(x2, y2, x3, y3) painter.drawLine(x3, y3, x4, y4) painter.drawLine(midx, midy, midx, y1) # Draw the text fontwidth = self.metrics.width("0") fontheight = self.metrics.height() fontheight /= 2 fontwidth /= 2 path = QPainterPath() point = QPointF(x1 - fontwidth, y1 - fontheight) path.addText(point, self.font, "0") painter.setPen(self.whitepen) painter.setBrush(self.blackbrush) painter.setRenderHints(QPainter.Antialiasing) painter.setFont(self.font) painter.drawPath(path) fontwidth = self.metrics.width(label) fontheight = self.metrics.height() fontheight /= 2 fontwidth /= 2 point = QPointF(x4 - fontwidth, y4 - fontheight) path.addText(point, self.font, label) painter.drawPath(path) def _calc_size(self): realSize = self.realsize canvaswidth = self.canvas.width() mapunitsperpixel = abs(self.canvas.mapUnitsPerPixel()) mapunits = self.canvas.mapUnits() prefered_units = roam.config.settings.get("prefer_units", "meters") newunits = QGis.fromLiteral(prefered_units, QGis.Meters) mapunitsperpixel *= QGis.fromUnitToUnitFactor(mapunits, newunits) mapunits = newunits # Convert the real distance into pixels barwidth = realSize / mapunitsperpixel if barwidth < 30: barwidth = canvaswidth / 4 while barwidth > canvaswidth / 3: barwidth /= 3 realSize = barwidth * mapunitsperpixel # Round powerof10 = math.floor(math.log10(realSize)) scaler = math.pow(10.0, powerof10) realSize = round(realSize / scaler) * scaler barwidth = realSize / mapunitsperpixel label, realSize = self._label_size(mapunits, realSize) metrics = QFontMetrics(self.font) fontwidth = metrics.width(label) fontheight = metrics.height() sizelabel = QLocale.system().toString(realSize) sizelabel = "{} {}".format(sizelabel, label) barwidth = self._adjust_bar_size(barwidth, mapunits) barwidth = barwidth + fontwidth return barwidth, realSize, sizelabel, (fontwidth, fontheight) def _label_size(self, unit, currentsize): if unit == QGis.Meters: if currentsize > 1000: return "km", currentsize / 1000 elif currentsize < 0.01: return "mm", currentsize * 1000 elif currentsize < 0.1: return "cm", currentsize * 100 else: return "m", currentsize elif unit == QGis.Feet: print currentsize if currentsize > 5280.0: return "miles", currentsize / 5000 elif currentsize == 5280.0: return "mile", currentsize / 5000 elif currentsize < 1: return "inches", currentsize * 10 elif currentsize == 1.0: return "foot", currentsize else: return "feet", currentsize elif unit == QGis.Degrees: if currentsize == 1.0: return "degree", currentsize else: return "degrees", currentsize else: return str(unit), currentsize def _adjust_bar_size(self, barsize, unit): if unit == QGis.Feet: if barsize > 5280.0 or barsize == 5280.0: return (barsize * 5290) / 5000 elif barsize < 1: return (barsize * 10) / 12 return barsize
def _setMinimumHeight(self): fnt = self.settings.value("pythonConsole/fontfamilytext", "Monospace") fntSize = self.settings.value("pythonConsole/fontsize", 10, type=int) fm = QFontMetrics(QFont(fnt, fntSize)) self.setMinimumHeight(fm.height() + 10)
class ZTextWidget(QWidget): upper_buf = [] upper_buf_height = 0 upper_win_cursor = [] # Upper win cursor x,y lower_win_cursor = 1 # Lower win cursor x (y cannot be changed!) fixed_font = None fixed_font_metrics = None fixed_font_width = 0 fixed_font_height = 0 buf = [] width = 80 height = 26 cur_win = 0 # Default win is the lower (1 is for upper win) cur_fg = 10 cur_bg = 2 cur_style = 0 max_char = 0 start_pos = 0 top_pos = 0 cur_pos = 0 input_buf = [] _cursor_visible = False _ostream = None returnPressed = pyqtSignal(QString) keyPressed = pyqtSignal(int) def __init__(self,parent = None,flags = Qt.Widget): super(ZTextWidget,self).__init__(parent,flags) sp = QSizePolicy() sp.setHorizontalPolicy(QSizePolicy.Fixed) sp.setVerticalPolicy(QSizePolicy.Fixed) self.set_fixed_font("DeJa Vu Sans Mono", 9) self.setSizePolicy(sp) self.setFocusPolicy(Qt.StrongFocus) self._ostream = [ZStream(), ZStream(), ZStream(), ZStream()] self._ostream[0].selected = True for i in xrange(self.width * self.height * 4): self.buf.append(0) def paintEvent(self,e): painter = QPainter(self) painter.fillRect(0, 0, self.width * self.fixed_font_width + 2, self.height * self.fixed_font_height, Qt.black) painter.setPen(Qt.gray) painter.setRenderHint(QPainter.TextAntialiasing) painter.setFont(self.fixed_font) painter.setBackgroundMode(Qt.OpaqueMode) # Print main window l = self.height while (l > 0): c = 1 while (c <= self.width): y = self.fixed_font_metrics.ascent() + (l - 1) * self.fixed_font_height x = 1 + ((c - 1) * self.fixed_font_width) #print "**",l,"**",c if self.buf[(((self.height - l) * self.width) + c - 1) * 4] == 0: painter.setPen(self.ztoq_color(self.cur_fg)) else: painter.setPen(self.ztoq_color(self.buf[(((self.height - l) * self.width) + c - 1) * 4])) if self.buf[((((self.height - l) * self.width) + c - 1) * 4) + 1] == 0: painter.setBackground(QBrush(self.ztoq_color(self.cur_bg))) else: painter.setBackground(QBrush(self.ztoq_color(self.buf[((((self.height - l) * self.width) + c - 1) * 4) + 1]))) # Set appropriate font style if self.buf[((((self.height - l) * self.width) + c - 1) * 4) + 2] == 0: f = painter.font() f.setBold(False) f.setItalic(False) painter.setFont(f) if self.buf[((((self.height - l) * self.width) + c - 1) * 4) + 2] & 1: # Reverse video painter.setPen(self.ztoq_color(self.buf[((((self.height - l) * self.width) + c - 1) * 4) + 1])) painter.setBackground(QBrush(self.ztoq_color(self.buf[(((self.height - l) * self.width) + c - 1) * 4]))) if self.buf[((((self.height - l) * self.width) + c - 1) * 4) + 2] & 2: # Bold f = painter.font() f.setBold(True) painter.setFont(f) if self.buf[((((self.height - l) * self.width) + c - 1) * 4) + 2] & 4: # Italic f = painter.font() f.setItalic(True) painter.setFont(f) if self.buf[((((self.height - l) * self.width) + c - 1) * 4) + 3] <> 0: painter.drawText(x,y,self.buf[((((self.height - l) * self.width) + c - 1) * 4) + 3]) c += 1 l -= 1 c = 1 # Print upper window if self.upper_buf <> []: l = 1 while (l <= self.upper_buf_height): c = 1 while (c <= self.width): y = self.fixed_font_metrics.ascent() + (l - 1) * self.fixed_font_height x = 1 + ((c - 1) * self.fixed_font_width) #print "**",l,"**",c if self.upper_buf[((((l - 1) * self.width) + c - 1) * 4) + 3] <> 0: painter.setPen(self.ztoq_color(self.upper_buf[(((l - 1) * self.width) + c - 1) * 4])) painter.setBackground(QBrush(self.ztoq_color(self.upper_buf[((((l - 1) * self.width) + c - 1) * 4) + 1]))) # Set appropriate font style if self.upper_buf[((((l - 1) * self.width) + c - 1) * 4) + 2] == 0: f = painter.font() f.setBold(False) f.setItalic(False) painter.setFont(f) if self.upper_buf[((((l - 1) * self.width) + c - 1) * 4) + 2] & 1: # Reverse video painter.setPen(self.ztoq_color(self.upper_buf[((((l - 1) * self.width) + c - 1) * 4) + 1])) painter.setBackground(QBrush(self.ztoq_color(self.upper_buf[(((l - 1) * self.width) + c - 1) * 4]))) if self.upper_buf[((((l - 1) * self.width) + c - 1) * 4) + 2] & 2: # Bold f = painter.font() f.setBold(True) painter.setFont(f) if self.upper_buf[((((l - 1) * self.width) + c - 1) * 4) + 2] & 4: # Italic f = painter.font() f.setItalic(True) painter.setFont(f) painter.drawText(x,y,self.upper_buf[((((l - 1) * self.width) + c - 1) * 4) + 3]) c += 1 l += 1 # Print cursor if visible if self._cursor_visible: self.display_cursor() def sizeHint(self): size = QSize() size.setWidth(self.width * self.fixed_font_width + 2) size.setHeight(self.height * self.fixed_font_height) return size def set_fixed_font(self,name,size): self.fixed_font = QFont(name, size) self.fixed_font.setFixedPitch(True) self.fixed_font.setKerning(False) self.fixed_font_metrics = QFontMetrics(self.fixed_font) self.fixed_font_width = self.fixed_font_metrics.averageCharWidth() self.fixed_font_height = self.fixed_font_metrics.height() #print self.fixed_font_width, self.fixed_font_height def ztoq_color(self,c): if c == 2: return Qt.black elif c == 3: return Qt.red elif c == 4: return Qt.green elif c == 5: return Qt.yellow elif c == 6: return Qt.blue elif c == 7: return Qt.magenta elif c == 8: return Qt.cyan elif c == 9: return Qt.white elif c == 10: return Qt.lightGray elif c == 11: return Qt.gray elif c == 12: return Qt.darkGray def set_cursor(self,x,y): self.upper_win_cursor = [x,y] def set_window(self,w): if w < 2: self.cur_win = w else: sys.exit("Unknown window {0}!?!".args(w)) def prints(self,txt): if self._ostream[0].selected: if self.cur_win == 0: # Lower win # TODO: Buffering c = self.lower_win_cursor i = 0 total = len(txt) #print "Total -", total while (i < total): s = "" while (i < total) and (txt[i] <> '\n') and (c <= self.width): s += txt[i] i += 1 c += 1 self.print_line(s) #print "--> [i, c, total]", i, c, total, " ++ ", s if c > self.width: self.insert_new_line() self.lower_win_cursor = 1 c = 1 elif (i < total) and (txt[i] == '\n'): self.insert_new_line() self.lower_win_cursor = 1 c = 1 i += 1 #elif (i == total) and (txt[i-1] <> '\n'): else: self.lower_win_cursor += len(s) else: i = self.upper_win_cursor[0] j = 0 l = self.upper_win_cursor[1] #print "-", i, l, "-", txt #print "len upperbuf=", len(self.upper_buf) while (i <= self.width) and (j < len(txt)): if txt[j] <> '\n': self.upper_buf[(((l - 1) * self.width) + (i - 1)) * 4] = self.cur_fg self.upper_buf[((((l - 1) * self.width) + (i - 1)) * 4) + 1] = self.cur_bg self.upper_buf[((((l - 1) * self.width) + (i - 1)) * 4) + 2] = self.cur_style self.upper_buf[((((l - 1) * self.width) + (i - 1)) * 4) + 3] = txt[j] i += 1 j += 1 else: self.upper_win_cursor = [1,l + 1] i = 1 l += 1 j += 1 self.upper_win_cursor[0] += j self.update() def print_line(self,txt): col = self.lower_win_cursor #print "Column:", col, txt if self.cur_win == 0: # Lower win for i in xrange(len(txt)): self.buf[(col - 1 + i) * 4] = self.cur_fg self.buf[((col - 1 + i) * 4) + 1] = self.cur_bg self.buf[((col - 1 + i) * 4) + 2] = self.cur_style self.buf[((col - 1 + i) * 4) + 3] = txt[i] def print_char(self,c): col = self.lower_win_cursor if self.cur_win == 0: # Lower win if c <> '\n': self.buf[(col - 1) * 4] = self.cur_fg self.buf[((col - 1) * 4) + 1] = self.cur_bg self.buf[((col - 1) * 4) + 2] = self.cur_style self.buf[((col - 1) * 4) + 3] = c self.lower_win_cursor += 1 if self.lower_win_cursor > self.width: # If we exceed screen width #print "I insert a newline" self.insert_new_line() self.lower_win_cursor = 1 elif c == '\n': self.insert_new_line() self.lower_win_cursor = 1 self.update() def set_max_input(self,m): self.max_char = m def show_cursor(self): self.cur_pos = self.lower_win_cursor self.top_pos = self.cur_pos self.start_pos = self.cur_pos self.input_buf = [] self._cursor_visible = True self.update() def hide_cursor(self): self._cursor_visible = False self.update() def display_cursor(self): painter = QPainter(self) col = self.cur_pos y = self.fixed_font_metrics.ascent() + ((self.height - 1) * self.fixed_font_height) x = 1 + ((col - 1) * self.fixed_font_width) painter.setPen(self.ztoq_color(self.cur_fg)) painter.setBackground(QBrush(self.ztoq_color(self.cur_bg))) painter.drawText(x,y,unichr(0x2581)) def keyPressEvent(self,e): if e.key() == Qt.Key_Left: if self.cur_pos > self.start_pos: self.cur_pos -= 1 self.update() e.accept() self.keyPressed.emit(131) elif e.key() == Qt.Key_Right: if self.cur_pos < self.top_pos: self.cur_pos += 1 self.update() e.accept() self.keyPressed.emit(132) elif e.key() == Qt.Key_Up: # TODO: Up in history e.accept() self.keyPressed.emit(129) pass elif e.key() == Qt.Key_Down: # TODO: Down in history e.accept() self.keyPressed.emit(130) pass elif e.key() == Qt.Key_Backspace: if self.cur_pos > self.start_pos: self.cur_pos -= 1 self.top_pos -= 1 col = self.cur_pos - 1 for i in xrange(4): self.buf[col * 4 + i] = 0 del self.input_buf[self.cur_pos - self.start_pos] #print self.input_buf self.lower_win_cursor -= 1 self.update() # self.keyPressed.emit() # No keycode available for zscii e.accept() elif e.key() == Qt.Key_Delete: # TODO: Fix it! if self.cur_pos < self.top_pos: self.top_pos -= 1 col = self.cur_pos - 1 for i in xrange(4): self.buf[col * 4 + i] = 0 del self.input_buf[self.cur_pos - self.start_pos] self.lower_win_cursor -= 1 self.update() e.accept() self.keyPressed.emit(8) elif (e.key() == Qt.Key_Return) or (e.key() == Qt.Key_Enter): # TODO: Learn how to properly convert a list of chars to a string. There MUST be another way! >:-S text = "" for i in xrange(len(self.input_buf)): text += self.input_buf[i] #print text self.print_char('\n') self.hide_cursor() self.keyPressed.emit(13) self.returnPressed.emit(text) e.accept() elif ((e.key() >= Qt.Key_F1) and (e.key() <= Qt.Key_F12)): e.accept() self.keyPressed.emit(133 + e.key() - Qt.Key_F1) elif e.key() == Qt.Key_Escape: e.accept() self.keyPressed.emit(27) elif e.text().isEmpty() == False: #print self.cur_pos, self.start_pos, self.max_char if (self.cur_pos - self.start_pos) < self.max_char: self.cur_pos += 1 self.top_pos += 1 if (self.cur_pos - self.start_pos) <= len(self.input_buf): self.input_buf.insert(self.cur_pos - self.start_pos - 1, unicode(e.text())) #print "CurPos:", self.cur_pos col = self.cur_pos - 2 self.buf[col * 4 + 3] = unicode(e.text()) self.buf[col * 4 + 2] = 0 self.buf[col * 4 + 1] = self.cur_bg self.buf[col * 4] = self.cur_fg self.lower_win_cursor += 1 else: self.input_buf.append(unicode(e.text())) self.print_char(e.text()) #print self.input_buf self.update() e.accept() t = ord(str(e.text())) if ((t > 31) and (t < 127)) or ((t > 154) and (t <252)): self.keyPressed.emit(t) else: e.ignore() def set_text_colour(self,fg): self.cur_fg = fg def set_text_background_colour(self,bg): self.cur_bg = bg def set_font_style(self,s): if s == 0: self.cur_style = 0 else: self.cur_style |= s def clear(self): for i in xrange(self.width * self.height * 4): self.buf[i] = 0 self.upper_buf = [] self.upper_buf_height = 0 self.upper_win_cursor = [] # Upper win cursor x,y self.lower_win_cursor = 1 # Lower win cursor x (y cannot be changed!) self.cur_win = 0 # Default win is the lower (1 is for upper win) def split_window(self,lines,ver): if self.upper_buf_height > lines: # New upper win is smaller. I should copy the rest of the buffer to main buffer #print "Copying..." l = lines + 1 while l <= self.upper_buf_height: for i in xrange(self.width * 4): self.buf[(((self.height - l + 1) * self.width) * 4) + i] = self.upper_buf[(((l - 1) * self.width) * 4) + i] l += 1 self.upper_buf_height = lines if (self.upper_buf == []) or (ver == 3): for i in xrange(self.upper_buf_height*self.width*4): # It isn't necessary to occupy that much memory but it helps to be prepared! :-P self.upper_buf.append(0) if (self.upper_win_cursor == []) or (self.upper_win_cursor[1] > lines): self.upper_win_cursor = [1,1] def select_ostream(self,n): if n <> 0: self._ostream[n - 1].selected = True def deselect_ostream(self,n): self._ostream[n - 1].selected = False def insert_new_line(self): #print "New line" # TODO: Not just insert new lines but also remove old unwanted ones for i in xrange(self.width * 4): self.buf.insert(0, 0) def read_line(self, callback): QObject.connect(self, SIGNAL("returnPressed(QString)"), callback) def disconnect_read_line(self, callback): QObject.disconnect(self, SIGNAL("returnPressed(QString)"), callback) def read_char(self, callback): QObject.connect(self, SIGNAL("keyPressed(int)"), callback) print 'Connect char' def disconnect_read_char(self, callback): QObject.disconnect(self, SIGNAL("keyPressed(int)"), callback) print 'Disconnect char' def selected_ostreams(self): s = [] for i in xrange(4): if self._ostream[i].selected == True: s.append(i+1) return s def new_line(self): if self._ostream[0].selected: if self.cur_win == 0: # Lower win self.insert_new_line() self.lower_win_cursor = 1 else: # Upper win l = self.upper_win_cursor[1] self.upper_win_cursor = [1,l + 1]
def appPrefsChanged(self, prefs): font = self.view.font() font.setPointSize(prefs.tableFontSize) self.view.setFont(font) fm = QFontMetrics(font) self.view.verticalHeader().setDefaultSectionSize(fm.height() + 2)
class asciiItem(QGraphicsTextItem): def __init__(self, whex): QGraphicsTextItem.__init__(self) self.initValues(whex) self.initPosition() self.initFont() self.initMetricsValues() # self.initCursor() def initPosition(self): self.setPos(485, 25) # self.setTextInteractionFlags(Qt.TextSelectableByMouse) def initValues(self, whex): self.whex = whex self.heditor = self.whex.heditor #Buffer self.buffer = [] self.bufferLines = 0 #Line self.currentLine = 0 #Offset self.startOffset = 0 self.fontPixel = 14 #Current Positions self.currentPos = 0 # def initCursor(self): # self.cursor = asciiCursor(self) # self.heditor.scene.addItem(self.cursor) def initFont(self): self.setDefaultTextColor(QColor(Qt.darkCyan)) self.font = QFont("Gothic") self.font.setFixedPitch(1) self.font.setBold(False) self.font.setPixelSize(self.fontPixel) self.setFont(self.font) self.metric = QFontMetrics(self.font) def initMetricsValues(self): #Calibrate calibrate = QString("A") self.charsByByte = 1 self.charW = self.metric.width(calibrate) self.charH = self.metric.height() self.byteW = self.charW * self.charsByByte self.byteH = self.charH def initStartBlank(self): self.lineW = self.boundingRect().width() self.startBlank = self.lineW - (self.byteW * 16) # print "start ASCII blank" # print self.startBlank #Print Operations def printBuffer(self, buff): del self.buffer self.buffer = buff count = 0 printer = QString() for char in buff: if char > "\x20" and char < "\x7e": printer.append(char) else: printer.append(".") if count < 15: count += 1 else: printer.append("\n") count = 0 #Clear and set cursor = self.textCursor() cursor.movePosition(QTextCursor.Start) cursor.movePosition(QTextCursor.End, QTextCursor.KeepAnchor) self.setPlainText(printer) cursor.movePosition(QTextCursor.Start) #Update pixel Informations def updateCurrentSelection(self, posx, posy): self.currentSelection = self.heditor.currentOffset + ( (posy * 16) + posx) def getXPos(self, x): count = 0 current = self.byteW + (self.startBlank / 2) while current < x: count += 1 current = current + self.byteW return count def getYPos(self, y): count = 0 current = self.byteH while current < y: count += 1 current = current + self.byteH return count def mouseMoveEvent(self, event): pos = event.pos() x = pos.x() y = pos.y() xpos = self.getXPos(x) ypos = self.getYPos(y) self.heditor.selection.select(self.heditor.selection.xstart, self.heditor.selection.ystart, xpos, ypos) if not self.heditor.preview: self.heditor.infos.update() self.heditor.right.decode.update() def mousePressEvent(self, event): button = event.button() pos = event.pos() if event.button() == 1: #Get Clicked coordonates x = pos.x() y = pos.y() #Transform pixel into cursor position xpos = self.getXPos(x) ypos = self.getYPos(y) self.whex.asciicursor.draw(xpos, ypos) self.whex.hexcursor.draw(xpos, ypos) #Refresh hexadecimal cursor self.heditor.selection.select(xpos, ypos, xpos, ypos, True) if not self.heditor.preview: self.heditor.right.decode.update() self.heditor.infos.update() def mouseReleaseEvent(self, event): pass
def sizeHint(self): fm = QFontMetrics(self.font()) h = fm.height() w = fm.width(self.displayText()) + (fm.width(' ') * 2) return QSize(w, h)
def setupTabs(self, elmerDefs, Section, ID): """Creates the tabs of the dynamic widget according to the elmerDefs Args: ----- elmerDefs: QDomDocument contents of the Elmder efs files in xml-format Section: str Type of base layout ID: int ID of the dynamiceditor-instance """ self.ID = ID self.qhash.clear() layout = self.layout() if (layout is not None): item = layout.takeAt(0) while (item != 0): item = None if (self.tabWidget is not None): self.tabWidget.clear() self.tabWidget = None item = layout.takeAt(0) self.layout = None # get root element self._root = elmerDefs.documentElement() self.tabWidget = QtGui.QTabWidget() self.tabWidget.setUsesScrollButtons(True) self.tabWidget.setElideMode(QtCore.Qt.ElideNone) self._all_stuff = self._root.firstChildElement("ALL") self._element = self._root.firstChildElement("PDE") self.tabs = 0 while (self._element.isNull() is False): self._name = self._element.firstChildElement("Name") grid = QtGui.QGridLayout() params = 0 for x in range(0, 2): if (x == 0): if (str(self._name.text()).strip() == "General"): continue self._section = self._all_stuff.firstChildElement(Section) else: self._section = self._element.firstChildElement(Section) self._param = self._section.firstChildElement("Parameter") while (self._param.isNull() is False): h = hash_entry_t() # label widget_type = self._param.attribute("Widget", "Edit") widget_enabled = self._param.attribute("Enabled", "True") widget_visible = self._param.attribute("Visible", "True") paramType = str( self._param.firstChildElement("Type").text()).strip() labelName = str( self._param.firstChildElement("Name").text()).strip() sifName = str( self._param.firstChildElement( "SifName").text()).strip() if (sifName == ""): sifName = labelName paramDefault = str( self._param.firstChildElement( "DefaultValue").text()).strip() whatis = str( self._param.firstChildElement( "Whatis").text()).strip() statusTip = str( self._param.firstChildElement( "StatusTip").text()).strip() fullName = "/" + str(self._name.text()).strip() + "/" fullName = fullName + Section + "/" + labelName + "/" + str( ID) h.widget = None if (widget_type == "Edit"): edit = DynLineEdit() h.widget = edit.lineEdit edit.lineEdit.setText(paramDefault) edit.name = fullName edit.lineEdit.returnPressed.connect(edit.editSlot) edit.lineEdit.textChanged.connect( self._textChangedSlot) elif (widget_type == "TextEdit"): textEdit = QtGui.QTextEdit() currentFont = textEdit.currentFont() fontMetrics = QFontMetrics(currentFont) fontHeight = fontMetrics.height() textEdit.setMinimumHeight(5 * fontHeight) textEdit.setMaximumHeight(8 * fontHeight) h.widget = textEdit elif (widget_type == "Combo"): combo = QtGui.QComboBox() h.widget = combo count = 0 active = 0 item = self._param.firstChildElement("Item") while (item.isNull() is False): itemType = item.attribute("Type", "") if (itemType == "Active"): active = count itemName = item.firstChildElement("Name") count += 1 combo.insertItem(count, str(itemName.text()).strip()) item = item.nextSiblingElement("Item") combo.setCurrentIndex(active) combo.currentIndexChanged.connect(self._comboSlot) elif (widget_type == "CheckBox"): l = QtGui.QCheckBox() h.widget = l l.setText("") l.setChecked(False) if (paramDefault == "True"): l.setChecked(True) l.stateChanged.connect(self._lSlot) elif (widget_type == "Label"): label = QtGui.QLabel() font = QFont() font.setBold(True) font.setUnderline(True) label.setFont(font) label.setText(labelName) h.widget = label if (h.widget): h.widget.setWhatsThis(whatis) h.widget.setStatusTip(statusTip) h.widget.setProperty("dom address", fullName) h.elem = self._param if (widget_enabled == "False"): h.widget.setEnabled(False) if (widget_type != "TextEdit"): h.widget.setFixedHeight(18) if (widget_type == "TextEdit"): textEditLabel = QtGui.QLabel() textEditLabel.setText(labelName) h.label = textEditLabel grid.addWidget(h.widget, params, 0, 1, 2) if (widget_visible == "False"): h.label.hide() h.widget.hide() elif (widget_type != "Label"): label = QtGui.QLabel() label.setText(labelName) h.label = label grid.addWidget(h.label, params, 0) grid.addWidget(h.widget, params, 1) if (widget_visible == "False"): h.label.hide() h.widget.hide() else: h.label = None grid.addWidget(h.widget, params, 0) self.qhash.update({fullName: h}) self._param = self._param.nextSiblingElement("Parameter") params += 1 dummyWidget = QtGui.QWidget() grid.addWidget(dummyWidget, params, 0) grid.setRowStretch(params, 1) frmWidget = QtGui.QWidget() frmWidget.setLayout(grid) src = QtGui.QScrollArea() src.setWidget(frmWidget) src.setMinimumHeight(300) src.setWidgetResizable(True) if (params > 0): self.tabWidget.addTab(src, str(self._name.text()).strip()) self.tabs += 1 self._element = self._element.nextSiblingElement("PDE") # Buttons: lbl = QtGui.QLabel() lbl.setText("Name:") self.nameEdit = QtGui.QLineEdit() self.nameEdit.setText(Section + " " + str(ID + 1)) self.applyButton = QtGui.QPushButton("&Apply") # applyButton.setIcon(addIcon) self.applyButton.clicked.connect(self._applyButtonClicked) self.discardButton = QtGui.QPushButton("&Remove") # discardButton.setIcon(removeIcon) self.discardButton.clicked.connect(self._discardButtonClicked) self.okButton = QtGui.QPushButton("&OK") # okButton.setIcon(okIcon) self.okButton.clicked.connect(self._okButtonClicked) self.newButton = QtGui.QPushButton("&New") # self.newButton.setIcon(newIcon) self.newButton.clicked.connect(self._newButtonClicked) nameLayout = QtGui.QHBoxLayout() nameLayout.addWidget(lbl) nameLayout.addWidget(self.nameEdit) buttonLayout = QtGui.QHBoxLayout() buttonLayout.addWidget(self.newButton) buttonLayout.addWidget(self.applyButton) buttonLayout.addWidget(self.okButton) buttonLayout.addWidget(self.discardButton) spareButtonLayout = QtGui.QHBoxLayout() self.spareButton = QtGui.QPushButton("SpareButton") self.spareButton.setVisible(False) spareButtonLayout.addWidget(self.spareButton) self.spareButton.clicked.connect(self._spareButtonClicked) self.spareScroll = QtGui.QScrollArea() self.spareScroll.hide() mainLayout = QtGui.QVBoxLayout() mainLayout.addWidget(self.tabWidget) mainLayout.addWidget(self.spareScroll) mainLayout.addLayout(spareButtonLayout) mainLayout.addLayout(nameLayout) mainLayout.addLayout(buttonLayout) self.setLayout(mainLayout) self.setWindowTitle(Section)