def __init__( self, cornerWidget=None, **kw ) : GafferUI.ContainerWidget.__init__( self, _TabWidget(), **kw ) # Tab bar # ------- self.__tabBar = GafferUI.Widget( QtWidgets.QTabBar() ) self.__tabBar._qtWidget().setDrawBase( False ) self.__tabBar._qtWidget().tabMoved.connect( Gaffer.WeakMethod( self.__moveWidget ) ) self.__tabBar.dragEnterSignal().connect( Gaffer.WeakMethod( self.__tabBarDragEnter ), scoped = False ) self.__tabBar.dragMoveSignal().connect( Gaffer.WeakMethod( self.__tabBarDragMove ), scoped = False ) self.__tabBar.dragLeaveSignal().connect( Gaffer.WeakMethod( self.__tabBarDragLeave ), scoped = False ) self.__tabBarDragState = self.__DragState.None_ # See comments in Button.py if TabbedContainer.__palette is None : TabbedContainer.__palette = QtGui.QPalette( QtWidgets.QApplication.instance().palette( self.__tabBar._qtWidget() ) ) TabbedContainer.__palette.setColor( QtGui.QPalette.Disabled, QtGui.QPalette.Light, QtGui.QColor( 0, 0, 0, 0 ) ) self.__tabBar._qtWidget().setPalette( TabbedContainer.__palette ) self._qtWidget().setTabBar( self.__tabBar._qtWidget() ) self._qtWidget().setElideMode( QtCore.Qt.ElideNone ) # Corner widget and scrolling # --------------------------- # # QTabBar does provide scroll buttons for use when there is not enough # horizontal space to show all tabs. But these are really awkward to use # : you may not know which way to scroll, it may take several clicks to # find the thing you want, and it's hard to track the jumpy movement of # the tabs. Instead we provide a dropdown menu which provides an # overview of all tabs and allows you to jump to the right one with a # single click. This is stored in `self.__cornerContainer[0]`, alongside # an optional user-provided corner widget which is stored in # `self.__cornerContainer[1]`. self.__cornerContainer = GafferUI.ListContainer( GafferUI.ListContainer.Orientation.Horizontal ) with self.__cornerContainer : GafferUI.MenuButton( image = "tabScrollMenu.png", hasFrame = False, menu = GafferUI.Menu( Gaffer.WeakMethod( self.__scrollMenuDefinition ) ) ) self._qtWidget().setCornerWidget( self.__cornerContainer._qtWidget() ) self.setCornerWidget( cornerWidget ) # When there's not enough horizontal space, we need QTabWidget to scroll # to show the current tab. But `QTabBarPrivate::makeVisible()` refuses # to do this unless the scroll buttons are visible. So we have to # pretend to be using them and then use the stylesheet to set their size to # 0. One benefit of this hack is that we can track the show/hide events # for the buttons so that we only show our menu button when scrolling # is necessary. This is a bit more reliable than trying to do it ourselves # using resize events and size queries. self._qtWidget().setUsesScrollButtons( True ) assert( len( self._qtWidget().tabBar().children() ) == 2 ) # We expect a left and a right button _VisibilityLink( self._qtWidget().tabBar().children()[0], self.__cornerContainer[0]._qtWidget() ) # Child storage and signals # ------------------------- self.__widgets = [] self.__currentChangedSignal = GafferUI.WidgetEventSignal() self._qtWidget().currentChanged.connect( Gaffer.WeakMethod( self.__currentChanged ) )
return str(self.saveState()) def matrix(self): return np.array([[self.m11(), self.m12(), self.m13()], [self.m21(), self.m22(), self.m23()], [self.m31(), self.m32(), self.m33()]]) if __name__ == '__main__': import widgets import GraphicsView from functions import * app = QtGui.QApplication([]) win = QtGui.QMainWindow() win.show() cw = GraphicsView.GraphicsView() #cw.enableMouse() win.setCentralWidget(cw) s = QtGui.QGraphicsScene() cw.setScene(s) win.resize(600, 600) cw.enableMouse() cw.setRange(QtCore.QRectF(-100., -100., 200., 200.)) class Item(QtGui.QGraphicsItem): def __init__(self): QtGui.QGraphicsItem.__init__(self) self.b = QtGui.QGraphicsRectItem(20, 20, 20, 20, self)
def paint(self, painter, option, index): """Paint checkbox and text. _ |_| My label > """ body_rect = QtCore.QRectF(option.rect) check_rect = QtCore.QRectF(body_rect) check_rect.setWidth(check_rect.height()) offset = (check_rect.height() / 4) + 1 check_rect.adjust(offset, offset, -(offset), -(offset)) check_color = colors["idle"] perspective_icon = icons["angle-right"] perspective_rect = QtCore.QRectF(body_rect) perspective_rect.setWidth(perspective_rect.height()) perspective_rect.adjust(0, 3, 0, 0) perspective_rect.translate( body_rect.width() - (perspective_rect.width() / 2 + 2), 0) publish_states = index.data(Roles.PublishFlagsRole) if publish_states & InstanceStates.InProgress: check_color = colors["active"] elif publish_states & InstanceStates.HasError: check_color = colors["error"] elif publish_states & InstanceStates.HasWarning: check_color = colors["warning"] elif publish_states & InstanceStates.HasFinished: check_color = colors["ok"] elif not index.data(Roles.IsEnabledRole): check_color = colors["inactive"] offset = (body_rect.height() - font_metrics["h4"].height()) / 2 label_rect = QtCore.QRectF( body_rect.adjusted(check_rect.width() + 12, offset - 1, 0, 0)) assert label_rect.width() > 0 label = index.data(QtCore.Qt.DisplayRole) label = font_metrics["h4"].elidedText(label, QtCore.Qt.ElideRight, label_rect.width() - 20) font_color = colors["idle"] if not index.data(QtCore.Qt.CheckStateRole): font_color = colors["inactive"] # Maintain reference to state, so we can restore it once we're done painter.save() # Draw perspective icon painter.setFont(fonts["awesome10"]) painter.setPen(QtGui.QPen(font_color)) painter.drawText(perspective_rect, perspective_icon) # Draw label painter.setFont(fonts["h4"]) painter.setPen(QtGui.QPen(font_color)) painter.drawText(label_rect, label) # Draw checkbox pen = QtGui.QPen(check_color, 1) painter.setPen(pen) if index.data(Roles.IsOptionalRole): painter.drawRect(check_rect) if index.data(QtCore.Qt.CheckStateRole): optional_check_rect = QtCore.QRectF(check_rect) optional_check_rect.adjust(2, 2, -1, -1) painter.fillRect(optional_check_rect, check_color) else: painter.fillRect(check_rect, check_color) if option.state & QtWidgets.QStyle.State_MouseOver: painter.fillRect(body_rect, colors["hover"]) if option.state & QtWidgets.QStyle.State_Selected: painter.fillRect(body_rect, colors["selected"]) # Ok, we're done, tidy up. painter.restore()
def change_background_color(self, color): pal = self.palette() pal.setColor(QtGui.QPalette.Button, QtGui.QColor(color).darker(200)) self.setPalette(pal)
def clear(self): self.pFilterModel.setSourceModel( QtGui.QStandardItemModel() ) super(ExtendedCombo,self).clear()
def modify(self): # self.mIconPixmap = QtGui.QPixmap(os.path.join(self.manager.getIconsDir(), "iconMax.png")) self.mIconPixmap = QtGui.QPixmap(":/icons/CSS/rc/iconMax.png") self.managerIcon_label.setPixmap(self.mIconPixmap)
def shape(self): qp = QtGui.QPainterPathStroker() qp.setWidth(10.0) qp.setCapStyle(QtCore.Qt.SquareCap) return qp.createStroke(self.path())
def __init__(self, parent=None): QtWidgets.QSystemTrayIcon.__init__(self, parent) # self.activated.connect(self.showMainWidget) self.setIcon(QtGui.QIcon(libData.get_img_path('software/default'))) self.parent = parent Tank().init_os() self.data = Tank().data self.user = Tank().user self.project_data = Tank().data['project'] menu = QtWidgets.QMenu() menu.setStyleSheet(self.data['script'][TITLE]['style']) # ADMIN UI if True: # self.user.is_admin: adminMenu = QtWidgets.QMenu('Admin') adminMenu.setStyleSheet(self.data['script'][TITLE]['style']) menu.addMenu(adminMenu) menuItem = adminMenu.addAction( QtGui.QIcon(libData.get_img_path('btn/btnFolder48')), 'Open Project Data') menuItem.triggered.connect(self.press_btnOpenProjectLog) menuItem = adminMenu.addAction( QtGui.QIcon(libData.get_img_path('btn/btnFolder48')), 'Open User Data') menuItem.triggered.connect(self.press_btnOpenLocalLog) menu.addSeparator() menuItem = menu.addAction( QtGui.QIcon(libData.get_img_path('user/' + self.user.id)), self.user.id) menuItem.triggered.connect(self.press_btnShowUserData) menuItem = menu.addAction( QtGui.QIcon(libData.get_img_path('project/default')), self.data['project']['name']) menuItem.triggered.connect(self.press_btnOpenProjectPath) menu.addSeparator() subMenu = QtWidgets.QMenu('Software') subMenu.setStyleSheet(self.data['script'][TITLE]['style']) menu.addMenu(subMenu) for soft, soft_func in self.data['script'][TITLE]['SOFTWARE'].items(): menuItem = subMenu.addAction( QtGui.QIcon(libData.get_img_path('software/' + soft)), soft.title()) menuItem.triggered.connect(eval(soft_func)) menu.addSeparator() menuItem = menu.addAction( QtGui.QIcon(libData.get_img_path('btn/btnFolderSearchGet48')), 'Load') menuItem.triggered.connect(self.press_btnLoad) menu.addSeparator() menuItem = menu.addAction( QtGui.QIcon(libData.get_img_path('btn/btnReport48')), 'Report') menuItem.triggered.connect(self.press_btnReport) menuItem = menu.addAction( QtGui.QIcon(libData.get_img_path('btn/btnHelp48')), 'Help') menuItem.triggered.connect(self.press_btnHelp) menu.addSeparator() menuItem = menu.addAction( QtGui.QIcon(libData.get_img_path('btn/btnDenial48')), 'Quit') menuItem.triggered.connect(self.press_closeStartup) self.setContextMenu(menu)
def iconColor(self): setIconPath = '/dexter/Cache_DATA/CRT/riggingTeamShelf/bumbleBee/icon/' self.ui.zeroOut_BTN.setIcon(QtGui.QIcon('%szeroOut.jpg' % setIconPath)) self.ui.mirrorJoints_BTN.setIcon( QtGui.QIcon('%smirrorJoints.jpg' % setIconPath)) self.ui.biped_build_BTN.setIcon( QtGui.QIcon('%sbuild2.jpg' % setIconPath)) self.ui.biped_temp_BTN.setIcon( QtGui.QIcon('%simportBipedTemp.jpg' % setIconPath)) self.ui.biped_ex_build_BTN.setIcon( QtGui.QIcon('%sbuild3.jpg' % setIconPath)) self.ui.biped_ex_neck_BTN.setIcon( QtGui.QIcon('%sex_neck.jpg' % setIconPath)) self.ui.biped_ex_finger_BTN.setIcon( QtGui.QIcon('%sex_finger.jpg' % setIconPath)) self.ui.biped_ex_leg_BTN.setIcon( QtGui.QIcon('%sex_leg.jpg' % setIconPath)) self.ui.biped_ex_arm_BTN.setIcon( QtGui.QIcon('%sex_arm.jpg' % setIconPath)) self.ui.biped_ex_shoulder_BTN.setIcon( QtGui.QIcon('%sex_shoulder.jpg' % setIconPath)) self.ui.quad_temp_BTN.setIcon( QtGui.QIcon('%squad_importTemp.jpg' % setIconPath)) self.ui.quad_neck_BTN.setIcon( QtGui.QIcon('%squad_neck.jpg' % setIconPath)) self.ui.quad_spine_BTN.setIcon( QtGui.QIcon('%squad_spine.jpg' % setIconPath)) self.ui.quad_forelegL_BTN.setIcon( QtGui.QIcon('%squad_foreLeg_L.jpg' % setIconPath)) self.ui.quad_forelegR_BTN.setIcon( QtGui.QIcon('%squad_foreLeg_L.jpg' % setIconPath)) self.ui.quad_hindlegL_BTN.setIcon( QtGui.QIcon('%squad_hindLeg_L.jpg' % setIconPath)) self.ui.quad_hindlegR_BTN.setIcon( QtGui.QIcon('%squad_hindLeg_L.jpg' % setIconPath)) self.ui.quad_tail_BTN.setIcon( QtGui.QIcon('%squad_tail.jpg' % setIconPath)) self.ui.quad_setup_BTN.setIcon( QtGui.QIcon('%squad_setup.jpg' % setIconPath)) self.ui.interacteFoot_BTN.setIcon( QtGui.QIcon('%sinteracteFoot.jpg' % setIconPath)) self.ui.createPathTempJoints_BTN.setIcon( QtGui.QIcon('%screatePathTempJoints.jpg' % setIconPath)) self.ui.setBodyDivJoints_BTN.setIcon( QtGui.QIcon('%ssetBodyDivJoints.jpg' % setIconPath)) self.ui.setRig_BTN.setIcon(QtGui.QIcon('%ssetRig.jpg' % setIconPath)) self.ui.pathCurveSet_BTN.setIcon( QtGui.QIcon('%spathCurveSet.jpg' % setIconPath)) self.ui.makeLocOnCurve_BTN.setIcon( QtGui.QIcon('%smakeLocOnCurve.jpg' % setIconPath))
def shape(self): path = QtGui.QPainterPath() path.addRegion(self.widget().childrenRegion()) return path
def populateUi(self): config = get_config() self._file_info = None w, h = lib.get_default_image_resolution() self.imageRes_label.setEnabled(False) self.imageResWidth_label.setEnabled(False) self.imageResWidth_spinBox.setValue(w) self.imageResWidth_spinBox.setEnabled(False) self.imageResHeight_label.setEnabled(False) self.imageResHeight_spinBox.setValue(h) self.imageResHeight_spinBox.setEnabled(False) self.fileInfo_plainTextEdit.setReadOnly(True) value = get_config_value( config, 'data/load_bundle_position', const.LOAD_BUNDLE_POS_DEFAULT_VALUE) self.loadBndPositions_checkBox.setChecked(value) value = get_config_value( config, 'data/use_overscan', const.USE_OVERSCAN_DEFAULT_VALUE) self.overscan_checkBox.setChecked(value) # Get the file path from the clipboard. try: clippy = QtGui.QClipboard() text = str(clippy.text()).strip() if lib.is_valid_file_path(text): self.setFilePath(text) except Exception as e: msg = 'Could not get file path from clipboard.' LOG.warning(msg) LOG.info(str(e)) all_camera_nodes = lib.get_cameras() selected_cameras = lib.get_selected_cameras() active_camera = lib.get_active_viewport_camera() self.updateCameraList( self.camera_comboBox, self.camera_model, all_camera_nodes, selected_cameras, active_camera ) active_camera = self.getCameraData() mkr_grp_nodes = lib.get_marker_groups(active_camera) active_mkr_grp = None self.updateMarkerGroupList( self.markerGroup_comboBox, self.markerGroup_model, active_mkr_grp, mkr_grp_nodes ) value = get_config_value( config, "data/load_mode", const.LOAD_MODE_DEFAULT_VALUE ) self.populateLoadModeModel(self.loadMode_model) index = self.loadMode_model.stringList().index(value) self.loadMode_comboBox.setCurrentIndex(index) value = get_config_value( config, "data/distortion_mode", const.DISTORTION_MODE_DEFAULT_VALUE ) self.populateDistortionModeModel(self.distortionMode_model) index = self.distortionMode_model.stringList().index(value) self.distortionMode_comboBox.setCurrentIndex(index) return
def setupUi(self, Form): Form.setObjectName("Form") Form.resize(281, 96) self.horizontalLayout = QtWidgets.QHBoxLayout(Form) self.horizontalLayout.setSpacing(7) self.horizontalLayout.setContentsMargins(0, 0, 0, 0) self.horizontalLayout.setObjectName("horizontalLayout") self.gridLayout = QtWidgets.QGridLayout() self.gridLayout.setSpacing(2) self.gridLayout.setObjectName("gridLayout") self.dsbm22 = QtWidgets.QDoubleSpinBox(Form) self.dsbm22.setMaximumSize(QtCore.QSize(80, 16777215)) self.dsbm22.setSingleStep(0.1) self.dsbm22.setObjectName("dsbm22") self.gridLayout.addWidget(self.dsbm22, 1, 1, 1, 1) self.dsbm21 = QtWidgets.QDoubleSpinBox(Form) self.dsbm21.setMaximumSize(QtCore.QSize(80, 16777215)) self.dsbm21.setSingleStep(0.1) self.dsbm21.setObjectName("dsbm21") self.gridLayout.addWidget(self.dsbm21, 1, 0, 1, 1) self.dsbm31 = QtWidgets.QDoubleSpinBox(Form) self.dsbm31.setMaximumSize(QtCore.QSize(80, 16777215)) self.dsbm31.setSingleStep(0.1) self.dsbm31.setObjectName("dsbm31") self.gridLayout.addWidget(self.dsbm31, 2, 0, 1, 1) self.dsbm32 = QtWidgets.QDoubleSpinBox(Form) self.dsbm32.setMaximumSize(QtCore.QSize(80, 16777215)) self.dsbm32.setSingleStep(0.1) self.dsbm32.setObjectName("dsbm32") self.gridLayout.addWidget(self.dsbm32, 2, 1, 1, 1) self.dsbm23 = QtWidgets.QDoubleSpinBox(Form) self.dsbm23.setMaximumSize(QtCore.QSize(80, 16777215)) self.dsbm23.setSingleStep(0.1) self.dsbm23.setObjectName("dsbm23") self.gridLayout.addWidget(self.dsbm23, 1, 2, 1, 1) self.dsbm33 = QtWidgets.QDoubleSpinBox(Form) self.dsbm33.setMaximumSize(QtCore.QSize(80, 16777215)) self.dsbm33.setSingleStep(0.1) self.dsbm33.setObjectName("dsbm33") self.gridLayout.addWidget(self.dsbm33, 2, 2, 1, 1) self.dsbm12 = QtWidgets.QDoubleSpinBox(Form) self.dsbm12.setMaximumSize(QtCore.QSize(80, 16777215)) self.dsbm12.setSingleStep(0.1) self.dsbm12.setObjectName("dsbm12") self.gridLayout.addWidget(self.dsbm12, 0, 1, 1, 1) self.dsbm11 = QtWidgets.QDoubleSpinBox(Form) self.dsbm11.setMaximumSize(QtCore.QSize(80, 16777215)) self.dsbm11.setSingleStep(0.1) self.dsbm11.setObjectName("dsbm11") self.gridLayout.addWidget(self.dsbm11, 0, 0, 1, 1) self.dsbm13 = QtWidgets.QDoubleSpinBox(Form) self.dsbm13.setMaximumSize(QtCore.QSize(80, 16777215)) self.dsbm13.setSingleStep(0.1) self.dsbm13.setObjectName("dsbm13") self.gridLayout.addWidget(self.dsbm13, 0, 2, 1, 1) self.dsbm24 = QtWidgets.QDoubleSpinBox(Form) self.dsbm24.setMaximumSize(QtCore.QSize(80, 16777215)) self.dsbm24.setObjectName("dsbm24") self.gridLayout.addWidget(self.dsbm24, 1, 3, 1, 1) self.dsbm34 = QtWidgets.QDoubleSpinBox(Form) self.dsbm34.setMaximumSize(QtCore.QSize(80, 16777215)) self.dsbm34.setObjectName("dsbm34") self.gridLayout.addWidget(self.dsbm34, 2, 3, 1, 1) self.dsbm14 = QtWidgets.QDoubleSpinBox(Form) self.dsbm14.setMaximumSize(QtCore.QSize(80, 16777215)) self.dsbm14.setObjectName("dsbm14") self.gridLayout.addWidget(self.dsbm14, 0, 3, 1, 1) self.dsbm44 = QtWidgets.QDoubleSpinBox(Form) self.dsbm44.setMaximumSize(QtCore.QSize(80, 16777215)) self.dsbm44.setObjectName("dsbm44") self.gridLayout.addWidget(self.dsbm44, 3, 3, 1, 1) self.dsbm41 = QtWidgets.QDoubleSpinBox(Form) self.dsbm41.setMaximumSize(QtCore.QSize(80, 16777215)) self.dsbm41.setObjectName("dsbm41") self.gridLayout.addWidget(self.dsbm41, 3, 0, 1, 1) self.dsbm42 = QtWidgets.QDoubleSpinBox(Form) self.dsbm42.setMaximumSize(QtCore.QSize(80, 16777215)) self.dsbm42.setObjectName("dsbm42") self.gridLayout.addWidget(self.dsbm42, 3, 1, 1, 1) self.dsbm43 = QtWidgets.QDoubleSpinBox(Form) self.dsbm43.setMaximumSize(QtCore.QSize(80, 16777215)) self.dsbm43.setObjectName("dsbm43") self.gridLayout.addWidget(self.dsbm43, 3, 2, 1, 1) self.horizontalLayout.addLayout(self.gridLayout) spacerItem = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum) self.horizontalLayout.addItem(spacerItem) self.verticalLayout = QtWidgets.QVBoxLayout() self.verticalLayout.setObjectName("verticalLayout") self.pbReset = QtWidgets.QPushButton(Form) self.pbReset.setMaximumSize(QtCore.QSize(25, 25)) self.pbReset.setText("") icon = QtGui.QIcon() icon.addPixmap(QtGui.QPixmap(":/icons/resources/reset.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.pbReset.setIcon(icon) self.pbReset.setObjectName("pbReset") self.verticalLayout.addWidget(self.pbReset) spacerItem1 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) self.verticalLayout.addItem(spacerItem1) self.horizontalLayout.addLayout(self.verticalLayout) self.retranslateUi(Form) QtCore.QMetaObject.connectSlotsByName(Form)
def setType(self, porttype=None): pp, cc = None, None # polygon/circle coordinates if porttype: self.porttype = porttype if self.porttype is None: return if self.porttype == 'input': # block input pp = ((PW/2,0), (-PW/2,PW/2), (-PW/2,-PW/2)) self.label_side = 'right' elif self.porttype == 'output': # block output pp = ((-PW/2,-PW/2), (PW/2,-PW/2), (PW/2,PW/2), (-PW/2,PW/2)) self.label_side = 'left' elif self.porttype == 'inout': # block inout pp = ((-PW/2,0), (0,PW/2), (PW/2,0), (0,-PW/2)) self.label_side = 'left' elif self.porttype == 'ipin': # input terminal pp = ((PW/2,0), (0,PW/2), (-PW,PW/2), (-PW,-PW/2), (0,-PW/2)) self.label_side = 'left' elif self.porttype == 'opin': # output terminal pp = ((PW/2,0), (0,PW/2), (-PW,PW/2), (-PW/2,0), (-PW,-PW/2), (0,-PW/2)) self.label_side = 'right' elif self.porttype == 'iopin': # inout terminal pp = ((-PW,0), (-PW/2,PW/2), (PW/2,PW/2), (PW,0), (PW/2,-PW/2), (-PW/2,-PW/2)) self.label_side = 'right' elif self.porttype.startswith('node'): # node, nodeT, nodeB, nodeL, nodeR s = self.porttype[-1].upper() self.porttype = 'node' d = dict(T='top', B='bottom', L='left', R='right') if s in 'TBLR': self.label_side = d[s] else: self.label_side = 'top' cc = (-NW/2, -NW/2, NW, NW) for k in [self.porttype, 'port_'+self.porttype, self.porttype[:-1]]: if k in colors: self.lineColor, self.fillColor = colors[k] pen = QtGui.QPen(self.lineColor) pen.setWidth(1) self.setPen(pen) self.setBrush(self.fillColor) break self.p.swap(QtGui.QPainterPath()) # new painterpath if pp: polygon = QtGui.QPolygonF() for (x, y) in pp: polygon.append(QtCore.QPointF(x, y)) polygon.append(QtCore.QPointF(pp[0][0], pp[0][1])) # close polygon self.p.addPolygon(polygon) elif cc: bb = QtCore.QRectF(*cc) self.p.addEllipse(bb) else: error('unknown Port type: {}'.format(self.porttype))
def paintEvent(self, event): painter = qg.QPainter(self) option = qw.QStyleOption() option.initFrom(self) x = option.rect.x() + 1 y = option.rect.y() + 2 height = option.rect.height() - 5 width = option.rect.width() - 2 painter.setRenderHint(qg.QPainter.Antialiasing) ################################# # draw TEXT # alignment = (qc.Qt.AlignHCenter | qc.Qt.AlignVCenter) text = self.text() font = self.font() text_width = self.fontMetrics.width(text) text_height = font.pointSize() textPath = qg.QPainterPath() textPath.addText(x, y, font, text) penHover = self._pen_textHover penText = self._pen_text penpress = self._pen_pressed path = qg.QPainterPath() path.addRoundedRect(qc.QRectF(x, y, width, height), self.radius, self.radius) painter.fillPath(path, self.BRUSHPRESS) painter.setPen(self._penBorder) painter.drawPath(path) painter.fillRect(x, y, width, height, self._brushClear) penText.setCapStyle(qc.Qt.RoundCap) penText.setStyle(qc.Qt.SolidLine) painter.setPen(penText) painter.drawText(x + 1, y, width + 2, height, alignment, text) if self.isDown(): painter.fillPath(path, self.BRUSHPRESS) painter.setPen(penpress) penpress.setCapStyle(qc.Qt.RoundCap) penpress.setStyle(qc.Qt.SolidLine) painter.drawText(x + 1, y, width + 2, height, alignment, text) elif self.underMouse(): painter.setPen(penHover) penHover.setCapStyle(qc.Qt.RoundCap) penHover.setStyle(qc.Qt.SolidLine) painter.fillPath(path, self.BRUSHHOVER) painter.drawText(x + 1, y, width + 2, height, alignment, text) if not self.isEnabled(): painter.setPen(self._penDisabled) self._penDisabled.setCapStyle(qc.Qt.RoundCap) self._penDisabled.setStyle(qc.Qt.SolidLine) painter.drawRoundedRect(qc.QRectF(x, y, width, height), self.radius, self.radius) painter.setPen(self._penDisabled) painter.fillPath(path, self.BRUSHDISABLED) painter.drawText(x + 1, y, width + 2, height, alignment, text) painter.end()
class Colors: AbsoluteBlack = QtGui.QColor(0, 0, 0, 255) DarkGray = QtGui.QColor(60, 60, 60) DirtyPen = QtGui.QColor(250, 250, 250, 200) Gray = QtGui.QColor(110, 110, 110) Green = QtGui.QColor(96, 169, 23, 255) NodeBackgrounds = QtGui.QColor(40, 40, 40, 200) NodeNameRectBlue = QtGui.QColor(28, 74, 149, 200) NodeNameRectGreen = QtGui.QColor(74, 124, 39, 200) NodeNameRectOrange = QtGui.QColor(124, 94, 39, 200) NodeSelectedPenColor = QtGui.QColor(200, 200, 200, 150) Red = QtGui.QColor(255, 0, 0, 255) White = QtGui.QColor(255, 255, 255, 200) Yellow = QtGui.QColor(255, 211, 25) Orange = QtGui.QColor(209, 84, 0)
def populate(self): # first page self.p1 = QWidget() self.p1Layout = QHBoxLayout(self.p1) self.lePkgName = QLineEdit("DemoPackage") # allow only letters without spaces self.lePkgName.setValidator( QtGui.QRegExpValidator(QtCore.QRegExp("^[A-Za-z]+$"))) self.lePkgName.setAlignment(QtCore.Qt.AlignCenter) self.p1Layout.addWidget(self.lePkgName) self.addPageWidget(self.p1, "Choose a name for your new package!") # second page self.p2 = QWidget() self.p2Layout = QVBoxLayout(self.p2) self.goToDocsWidget = QWidget() self.goToDocsLayout = QHBoxLayout(self.goToDocsWidget) spacer = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Maximum) self.goToDocsLayout.addItem(spacer) self.bpGotoComponentsDocs = QPushButton("?") self.bpGotoComponentsDocs.setToolTip("Go to docs") self.bpGotoComponentsDocs.clicked.connect(self.onGotoComponentsDocs) self.goToDocsLayout.addWidget(self.bpGotoComponentsDocs) self.p2Layout.addWidget(self.goToDocsWidget) self.cbIncludeClassNode = QCheckBox("Class node") self.cbIncludeClassNode.stateChanged.connect( self.checkIncludeUINodeFactory) self.cbIncludeFooLib = QCheckBox("Function library") self.cbIncludePin = QCheckBox("Pin") self.cbIncludePin.stateChanged.connect(self.checkUIPinFactories) self.cbIncludeTool = QCheckBox("Tool") self.cbIncludeExporter = QCheckBox("Exporter") self.classNodeLayout = QHBoxLayout() self.classNodeLayout.setSpacing(1) self.classNodeLayout.setContentsMargins(0, 0, 0, 0) self.cbIncludeUINodeFactory = QCheckBox("Include ui node factory") self.cbIncludeUINodeFactory.setEnabled(False) self.classNodeLayout.addWidget(self.cbIncludeClassNode) self.classNodeLayout.addWidget(self.cbIncludeUINodeFactory) self.p2Layout.addLayout(self.classNodeLayout) self.p2Layout.addWidget(self.cbIncludeFooLib) self.pinLayout = QHBoxLayout() self.pinLayout.setSpacing(1) self.pinLayout.setContentsMargins(0, 0, 0, 0) self.cbUIPinFactory = QCheckBox("Include ui pin factory") self.cbUIPinFactory.setEnabled(False) self.pinLayout.addWidget(self.cbIncludePin) self.pinLayout.addWidget(self.cbUIPinFactory) self.p2Layout.addLayout(self.pinLayout) self.toolLayout = QHBoxLayout() self.toolLayout.setSpacing(1) self.toolLayout.setContentsMargins(0, 0, 0, 0) self.cbPinInputWidgetFactory = QCheckBox( "Include pin input widget factory") self.cbPinInputWidgetFactory.setEnabled(False) self.toolLayout.addWidget(self.cbIncludeTool) self.toolLayout.addWidget(self.cbPinInputWidgetFactory) self.p2Layout.addLayout(self.toolLayout) self.p2Layout.addWidget(self.cbIncludeExporter) self.addPageWidget( self.p2, "What components should be included?", "Please select at least one component to include to package!", self.isPackaeModuleSelected) # third page self.p3 = QWidget() self.p3Layout = QHBoxLayout(self.p3) self.pbOutPathSelect = QPushButton("...") self.p3Layout.addWidget(self.pbOutPathSelect) self.pbOutPathSelect.clicked.connect(self.onSelectPackageDirectory) self.addPageWidget( self.p3, "Select output directory for your new package!" + "\n\n**Note**: Output directory should be writable.", pageEnterCallback=self.onSelectPackageRootEntered)
def __init__(self, appInstance=None): self.appInstance = appInstance self.TextColor = QtGui.QColor(228, 228, 228) self.MainColor = QtGui.QColor(215, 128, 26) self.BgColor = QtGui.QColor(53, 53, 53) self.BgColorDarker = QtGui.QColor(50, 50, 50) self.BgColorBright = QtGui.QColor(82, 82, 82) self.BorderColor = QtGui.QColor(10, 10, 10) self.LoggerBgColor = QtGui.QColor(35, 35, 35) self.InputFieldColor = QtGui.QColor(32, 32, 32) self.TextSelectedColor = QtGui.QColor(255, 255, 255) self.ButtonsColor = QtGui.QColor(60, 60, 60) self.CanvasBgColor = QtGui.QColor(35, 35, 35) self.CanvasGridColor = QtGui.QColor(20, 20, 20, 100) self.CanvasGridColorDarker = QtGui.QColor(20, 20, 20) self.DrawGrid = [1] self.GridSizeFine = [10] self.GridSizeHuge = [100] self.DrawNumbers = [0] self.SetAppStyleSheet = [1] self.LOD_Number = [4] self.NodeSwitch = [3] self.ConnectionSwitch = [3] self.PinSwitch = [3] self.CanvasSwitch = [3] self.ConnectionMode = [ConnectionTypes.Circuit] self.ConnectionRoundness = [5] self.ConnectionOffset = [20] self.storeDeffaults() self.presets = {} self.loadPresets(THEMES_PATH) try: themeName = ConfigManager().getPrefsValue("PREFS", "Theme/Theme_Name") if themeName: self.loadFromData(self.presets[themeName]) else: if len(self.presets) > 0: self.loadFromData(self.presets[list( self.presets.keys())[0]]) except: pass
def paint(self, painter, option, index): """Paint checkbox and text _______________________________________________ | | label | duration |arrow| |toggle |_____________________| | to | | | families | |persp| |_______|_____________________|___________|_____| """ # Layout spacing = 10 body_rect = QtCore.QRectF(option.rect).adjusted(2, 2, -8, -2) content_rect = body_rect.adjusted(5, 5, -5, -5) perspective_rect = QtCore.QRectF(body_rect) perspective_rect.setWidth(35) perspective_rect.setHeight(35) perspective_rect.translate( content_rect.width() - (perspective_rect.width() / 2) + 10, (content_rect.height() / 2) - (perspective_rect.height() / 2)) toggle_rect = QtCore.QRectF(body_rect) toggle_rect.setWidth(7) toggle_rect.adjust(1, 1, 0, -1) icon_rect = QtCore.QRectF(content_rect) icon_rect.translate(toggle_rect.width() + spacing, 3) icon_rect.setWidth(35) icon_rect.setHeight(35) duration_rect = QtCore.QRectF(content_rect) duration_rect.translate(content_rect.width() - 50, 0) # Colors check_color = colors["idle"] publish_states = index.data(Roles.PublishFlagsRole) if publish_states is None: return if publish_states & InstanceStates.InProgress: check_color = colors["active"] elif publish_states & InstanceStates.HasError: check_color = colors["error"] elif publish_states & InstanceStates.HasWarning: check_color = colors["warning"] elif publish_states & InstanceStates.HasFinished: check_color = colors["ok"] elif not index.data(Roles.IsEnabledRole): check_color = colors["inactive"] perspective_icon = icons["angle-right"] if not index.data(QtCore.Qt.CheckStateRole): font_color = colors["inactive"] else: font_color = colors["idle"] if (option.state & (QtWidgets.QStyle.State_MouseOver or QtWidgets.QStyle.State_Selected)): perspective_color = colors["idle"] else: perspective_color = colors["inactive"] # Maintan reference to state, so we can restore it once we're done painter.save() # Draw background painter.fillRect(body_rect, colors["hover"]) # Draw icon icon = index.data(QtCore.Qt.DecorationRole) painter.setFont(fonts["largeAwesome"]) painter.setPen(QtGui.QPen(font_color)) painter.drawText(icon_rect, icon) # Draw label painter.setFont(fonts["h3"]) label_rect = QtCore.QRectF(content_rect) label_x_offset = icon_rect.width() + spacing label_rect.translate(label_x_offset, 0) metrics = painter.fontMetrics() label_rect.setHeight(metrics.lineSpacing()) label_rect.setWidth(content_rect.width() - label_x_offset - perspective_rect.width()) # Elide label label = index.data(QtCore.Qt.DisplayRole) label = metrics.elidedText(label, QtCore.Qt.ElideRight, label_rect.width()) painter.drawText(label_rect, label) # Draw families painter.setFont(fonts["h5"]) painter.setPen(QtGui.QPen(colors["inactive"])) families = ", ".join(index.data(Roles.FamiliesRole)) families = painter.fontMetrics().elidedText(families, QtCore.Qt.ElideRight, label_rect.width()) families_rect = QtCore.QRectF(label_rect) families_rect.translate(0, label_rect.height() + spacing) painter.drawText(families_rect, families) painter.setFont(fonts["largeAwesome"]) painter.setPen(QtGui.QPen(perspective_color)) painter.drawText(perspective_rect, perspective_icon) # Draw checkbox pen = QtGui.QPen(check_color, 1) painter.setPen(pen) if index.data(Roles.IsOptionalRole): painter.drawRect(toggle_rect) if index.data(QtCore.Qt.CheckStateRole): painter.fillRect(toggle_rect, check_color) elif (index.data(QtCore.Qt.CheckStateRole)): painter.fillRect(toggle_rect, check_color) if option.state & QtWidgets.QStyle.State_MouseOver: painter.fillRect(body_rect, colors["hover"]) if option.state & QtWidgets.QStyle.State_Selected: painter.fillRect(body_rect, colors["selected"]) painter.setPen(colors["outline"]) painter.drawRect(body_rect) # Ok, we're done, tidy up. painter.restore()
def __buildAction(self, item, name, parent): label = name with IECore.IgnoredExceptions(AttributeError): label = item.label qtAction = QtWidgets.QAction(label, parent) qtAction.__item = item if item.checkBox is not None: qtAction.setCheckable(True) checked = self.__evaluateItemValue(item.checkBox) qtAction.setChecked(checked) if item.divider: qtAction.setSeparator(True) if item.command: if item.checkBox: signal = qtAction.toggled[bool] else: signal = qtAction.triggered[bool] if self.__searchable: signal.connect( IECore.curry(Gaffer.WeakMethod(self.__menuActionTriggered), qtAction)) signal.connect( IECore.curry(Gaffer.WeakMethod(self.__actionTriggered), weakref.ref(qtAction))) active = self.__evaluateItemValue(item.active) qtAction.setEnabled(active) shortCut = getattr(item, "shortCut", None) if shortCut is not None: qtAction.setShortcuts( [QtGui.QKeySequence(s.strip()) for s in shortCut.split(",")]) # If we allow shortcuts to be created at the window level (the default), # then we can easily get into a situation where our shortcuts conflict # with those of the host when embedding our MenuBars in an application like Maya. # Here we're limiting the scope so that conflicts don't occur, deferring # to the code in MenuBar to manage triggering of the action with manual # shortcut processing. qtAction.setShortcutContext(QtCore.Qt.WidgetShortcut) # when an icon file path is defined in the menu definition icon = getattr(item, "icon", None) if icon is not None: if isinstance(icon, basestring): image = GafferUI.Image(icon) else: assert (isinstance(icon, GafferUI.Image)) image = icon qtAction.setIcon(QtGui.QIcon(image._qtPixmap())) if item.description: qtAction.setStatusTip(item.description) return qtAction
Parameters ---------- button : QPushButton Icon Button color : QColor, optional set the Icon color, by default QtGui.QColor("red") """ self.color = color self._setColor() def _setColor(self): if not self.color: return icon = self.bar.icon() pixmap = icon.pixmap(35) image = pixmap.toImage() pcolor = image.pixelColor(8, 35) for x in range(image.width()): for y in range(image.height()): pcolor = image.pixelColor(x, y) if pcolor.alpha() > 0: self.color.setAlpha(pcolor.alpha()) image.setPixelColor(x, y, self.color) self.bar.setIcon(QtGui.QIcon(QtGui.QPixmap.fromImage(image))) if __name__ == "__main__": widget = CollapsibleSperator() widget.show() widget.setButtonColor(QtGui.QColor("rgb(0,255,0)"))
def add_items(self): for row, task_status in enumerate(self.list_task_status): self.addItem(str(task_status["short_name"]).upper(), userData=task_status) color = QtGui.QColor(task_status["color"]).darker(180) self.model().item(row).setBackground(color)
def getIcon(): return QtGui.QIcon( str((Path(__file__).parent / Path('res/export.png')).resolve().absolute()))
super(ExtendedCombo, self).setModelColumn( column ) def view( self ): return self.completer.popup() def index( self ): return self.currentIndex() def setTextIfCompleterIsClicked(self, text): if text: index = self.findText(text) self.setCurrentIndex(index) if __name__ == "__main__": app = QtWidgets.QApplication(sys.argv) model = QtGui.QStandardItemModel() for i,word in enumerate( ['hola', 'adios', 'hello', 'good bye'] ): item = QtGui.QStandardItem(word) model.setItem(i, item) combo = ExtendedCombo() combo.setModel(model) combo.setModelColumn(0) combo.show() sys.exit(app.exec_())
def getIcon(): return QtGui.QIcon(":brick.png")
def changeLockIcon(self, checked): if checked: self.lockCheckBox.setIcon(QtGui.QIcon(':/locked.png')) else: self.lockCheckBox.setIcon(QtGui.QIcon(':/unlocked.png'))
def draw_title(self, painter): """Draw title of the node. Called exclusively in paint. :param painter: painter from paint. :type painter: QtGui.QPainter """ # draw bg painter.setPen(QtCore.Qt.NoPen) bg = painter.background() bgm = painter.backgroundMode() if self.is_real: painter.setBackgroundMode(QtCore.Qt.OpaqueMode) else: painter.setBackgroundMode(QtCore.Qt.TransparentMode) [c.setAlphaF(self.color_alpha) for c in self.colors] color_count = len(self.colors) color_band_width = 10 for i in range(color_count): color = self.colors[i] if self.is_proxy: painter.setBackground(color.darker(self.dim_factor)) brush = QtGui.QBrush(color.darker(self.dim_factor * 2), QtCore.Qt.FDiagPattern) painter.setBrush(brush) else: painter.setBrush(color.darker(self.dim_factor)) # Top Opinion if i + 1 == color_count: remaining_width = self.max_width - (i * color_band_width) painter.drawRect(0, 0, remaining_width, self.title_rect_height) # Lower Opinions else: x_pos = self.max_width - (i + 1) * color_band_width painter.drawRect(x_pos, 0, color_band_width, self.title_rect_height) painter.setBackground(bg) painter.setBackgroundMode(bgm) # draw exec plugs exec_attr = nxt_node.INTERNAL_ATTRS.EXECUTE_IN exec_in_pos = self.get_attr_in_pos(exec_attr, scene=False) exec_radius = self.EXEC_PLUG_RADIUS if nxt_path.get_parent_path(self.node_path) == nxt_path.WORLD: if self.is_start: color = self.start_color elif self.is_break: color = QtCore.Qt.red else: color = QtCore.Qt.white if not self.exec_in_plug: is_break = self.is_break if self.is_start: is_break = False self.exec_in_plug = NodeGraphicsPlug(pos=exec_in_pos, radius=exec_radius, color=color, is_exec=True, is_input=True, is_break=is_break, is_start=self.is_start) self.exec_in_plug.setParentItem(self) else: self.exec_in_plug.color = QtGui.QColor(color) self.exec_in_plug.is_break = self.is_break self.exec_in_plug.is_start = self.is_start self.exec_in_plug.setPos(exec_in_pos) self.exec_in_plug.update() out_pos = self.get_attr_out_pos(exec_attr, scene=False) if not self.exec_out_plug: self.exec_out_plug = NodeGraphicsPlug(pos=out_pos, radius=exec_radius, color=QtCore.Qt.white, is_exec=True, is_input=False) self.exec_out_plug.setParentItem(self) else: self.exec_out_plug.setPos(out_pos) else: if not self.exec_in_plug and self.is_break: self.exec_in_plug = NodeGraphicsPlug(pos=exec_in_pos, radius=exec_radius, color=QtCore.Qt.red, is_exec=True, is_input=True, is_break=self.is_break) self.exec_in_plug.setParentItem(self) elif self.exec_in_plug and not self.is_break: self.scene().removeItem(self.exec_in_plug) self.exec_in_plug = None if self.exec_out_plug: self.scene().removeItem(self.exec_out_plug) self.exec_out_plug = None # draw attr dots offset = -6 for fill in self.attr_dots: painter.setBrush(QtCore.Qt.white) if fill: painter.setBrush(QtCore.Qt.white) else: painter.setBrush(QtCore.Qt.NoBrush) dots_color = QtGui.QColor(QtCore.Qt.white).darker(self.dim_factor) painter.setPen(QtGui.QPen(dots_color, 0.5)) dot_x = self.max_width - 15 dot_y = (self.title_rect_height / 2) + offset painter.drawEllipse(QtCore.QPointF(dot_x, dot_y), 2, 2) offset += 6 # draw title painter.setPen(QtGui.QColor(QtCore.Qt.white).darker(self.dim_factor)) if not self.node_enabled: painter.setPen(QtGui.QColor(QtCore.Qt.white).darker(150)) painter.setFont(self.title_font) title_str = nxt_path.node_name_from_node_path(self.node_path) font_metrics = QtGui.QFontMetrics(self.title_font) width = self.max_width - 40 if self.error_list: width -= 20 title = font_metrics.elidedText(title_str, QtCore.Qt.ElideRight, width) painter.drawText(15, 0, self.max_width - 15, self.title_rect_height, QtCore.Qt.AlignVCenter, title) # draw error if self.error_list: pos = QtCore.QPointF(self.max_width - 45, self.title_rect_height / 4) error_item = ErrorItem(font=QtGui.QFont('Roboto', 16, 75), pos=pos, text='!') error_item.setParentItem(self) error_item.setZValue(50) self.error_item = error_item else: if self.error_item: self.scene().removeItem(self.error_item) self.error_item.deleteLater() self.error_item = None for arrow in self.collapse_arrows: self.scene().removeItem(arrow) self.collapse_arrows = [] # TODO calculation needed arrows should be done outside drawing # draw collapse state arrow if self.collapse_state: des_colors = self.model.get_descendant_colors(self.node_path) filled = self.model.has_children(self.node_path) if not filled: des_colors = [QtCore.Qt.white] elif not des_colors: disp = self.model.comp_layer des_colors = [self.model.get_node_color(self.node_path, disp)] i = 0 num = len(des_colors) for c in des_colors: arrow = CollapseArrow(self, filled=filled, color=c) arrow_width = arrow.width * 1.1 center_offset = (arrow_width * (num * .5) - arrow_width * .5) cur_offset = (i * arrow_width) pos = ((self.max_width * .5) + center_offset - cur_offset) arrow.setPos(pos, self.title_rect_height) self.collapse_arrows += [arrow] i += 1
import platform from Qt import QtWidgets, QtGui, QtCore from . import model from .awesome import tags as awesome from .constants import (PluginStates, InstanceStates, PluginActionStates, Roles, EXPANDER_WIDTH) colors = { "error": QtGui.QColor("#ff4a4a"), "warning": QtGui.QColor("#ff9900"), "ok": QtGui.QColor("#77AE24"), "active": QtGui.QColor("#99CEEE"), "idle": QtCore.Qt.white, "inactive": QtGui.QColor("#888"), "hover": QtGui.QColor(255, 255, 255, 10), "selected": QtGui.QColor(255, 255, 255, 20), "outline": QtGui.QColor("#333"), "group": QtGui.QColor("#333"), "group-hover": QtGui.QColor("#3c3c3c"), "group-selected-hover": QtGui.QColor("#555555"), "expander-bg": QtGui.QColor("#222"), "expander-hover": QtGui.QColor("#2d6c9f"), "expander-selected-hover": QtGui.QColor("#3784c5") } scale_factors = {"darwin": 1.5} scale_factor = scale_factors.get(platform.system().lower(), 1.0) fonts = { "h3": QtGui.QFont("Open Sans", 10 * scale_factor, QtGui.QFont.Normal),
def calculate_attribute_draw_details(self): """Calculate position of all known attr names. Details stored in self._attribute_draw_details. Public interface to get details is split into two functions, get_attr_in_pos and get_attr_out_pos. """ self._attribute_draw_details = OrderedDict() index = -1 comp_layer = self.model.comp_layer for attr_name in self.user_attr_names: index += 1 draw_details = {} # sizes rect_y = self.title_rect_height + index * self.attr_rect_height rect_midpoint = rect_y + (self.attr_rect_height / 2) draw_details['text_height'] = rect_y draw_details['bg_rect'] = QtCore.QRectF(0, rect_y, self.max_width, self.attr_rect_height) # positions draw_details['in_pos'] = QtCore.QPointF(self.attr_plug_side_margin, rect_midpoint) out_x = self.max_width - self.attr_plug_side_margin draw_details['out_pos'] = QtCore.QPointF(out_x, rect_midpoint) # background color color = self.model.get_node_attr_color(self.node_path, attr_name, comp_layer) bg_color = QtGui.QColor(color).darker(150).darker(self.dim_factor) bg_color.setAlphaF(self.attr_rect_opacity) draw_details['bg_color'] = bg_color # plug color type_ = self.model.get_node_attr_type(self.node_path, attr_name, comp_layer) draw_details['plug_color'] = colors.ATTR_COLORS.get( type_, QtCore.Qt.gray) # title color attr_is_instance = self.model.node_attr_is_instance( self.node_path, attr_name, comp_layer) dim_title = 150 if attr_is_instance else self.dim_factor white = QtGui.QColor(QtCore.Qt.white) draw_details['title_color'] = white.darker(dim_title) # font font = QtGui.QFont(self.attr_font.family(), self.attr_font.pointSize(), italic=attr_is_instance) draw_details['title_font'] = font self._attribute_draw_details[attr_name] = draw_details # Internal Attrs # Exec draw_details = {} in_pos = QtCore.QPointF(0, self.title_bounding_rect.height() / 3) draw_details['in_pos'] = in_pos out_pos = QtCore.QPointF(self.max_width, self.title_bounding_rect.height() / 3) draw_details['out_pos'] = out_pos draw_details['plug_color'] = QtGui.QColor(QtCore.Qt.white) exec_attr = nxt_node.INTERNAL_ATTRS.EXECUTE_IN self._attribute_draw_details[exec_attr] = draw_details # Inst draw_details = {} in_pos = QtCore.QPointF(0, (self.title_bounding_rect.height() / 3) * 2) draw_details['in_pos'] = in_pos out_pos = QtCore.QPointF(self.max_width, (self.title_bounding_rect.height() / 3) * 2) draw_details['out_pos'] = out_pos draw_details['plug_color'] = QtGui.QColor(QtCore.Qt.gray) inst_attr = nxt_node.INTERNAL_ATTRS.INSTANCE_PATH self._attribute_draw_details[inst_attr] = draw_details
def group_item_paint(self, painter, option, index): """Paint text _ My label """ body_rect = QtCore.QRectF(option.rect) bg_rect = QtCore.QRectF(body_rect.left(), body_rect.top() + 1, body_rect.width() - 5, body_rect.height() - 2) expander_rect = QtCore.QRectF(bg_rect) expander_rect.setWidth(EXPANDER_WIDTH) remainder_rect = QtCore.QRectF( expander_rect.x() + expander_rect.width(), expander_rect.y(), bg_rect.width() - expander_rect.width(), expander_rect.height()) width = float(expander_rect.width()) height = float(expander_rect.height()) x_pos = expander_rect.x() y_pos = expander_rect.y() x_radius = min(self.radius, width / 2) y_radius = min(self.radius, height / 2) x_radius2 = x_radius * 2 y_radius2 = y_radius * 2 expander_path = QtGui.QPainterPath() expander_path.moveTo(x_pos, y_pos + y_radius) expander_path.arcTo(x_pos, y_pos, x_radius2, y_radius2, 180.0, -90.0) expander_path.lineTo(x_pos + width, y_pos) expander_path.lineTo(x_pos + width, y_pos + height) expander_path.lineTo(x_pos + x_radius, y_pos + height) expander_path.arcTo(x_pos, y_pos + height - y_radius2, x_radius2, y_radius2, 270.0, -90.0) expander_path.closeSubpath() width = float(remainder_rect.width()) height = float(remainder_rect.height()) x_pos = remainder_rect.x() y_pos = remainder_rect.y() x_radius = min(self.radius, width / 2) y_radius = min(self.radius, height / 2) x_radius2 = x_radius * 2 y_radius2 = y_radius * 2 remainder_path = QtGui.QPainterPath() remainder_path.moveTo(x_pos + width, y_pos + height - y_radius) remainder_path.arcTo(x_pos + width - x_radius2, y_pos + height - y_radius2, x_radius2, y_radius2, 0.0, -90.0) remainder_path.lineTo(x_pos, y_pos + height) remainder_path.lineTo(x_pos, y_pos) remainder_path.lineTo(x_pos + width - x_radius, y_pos) remainder_path.arcTo(x_pos + width - x_radius2, y_pos, x_radius2, y_radius2, 90.0, -90.0) remainder_path.closeSubpath() painter.fillPath(expander_path, colors["expander-bg"]) painter.fillPath(remainder_path, colors["group"]) mouse_pos = option.widget.mapFromGlobal(QtGui.QCursor.pos()) selected = option.state & QtWidgets.QStyle.State_Selected hovered = option.state & QtWidgets.QStyle.State_MouseOver if selected and hovered: if expander_rect.contains(mouse_pos): painter.fillPath(expander_path, colors["expander-selected-hover"]) else: painter.fillPath(remainder_path, colors["group-selected-hover"]) elif hovered: if expander_rect.contains(mouse_pos): painter.fillPath(expander_path, colors["expander-hover"]) else: painter.fillPath(remainder_path, colors["group-hover"]) text_height = font_metrics["awesome6"].height() adjust_value = (expander_rect.height() - text_height) / 2 expander_rect.adjust(adjust_value + 1.5, adjust_value - 0.5, -adjust_value + 1.5, -adjust_value - 0.5) offset = (remainder_rect.height() - font_metrics["h5"].height()) / 2 label_rect = QtCore.QRectF(remainder_rect.adjusted( 5, offset - 1, 0, 0)) expander_icon = icons["plus-sign"] expanded = self.parent().isExpanded(index) if expanded: expander_icon = icons["minus-sign"] label = index.data(QtCore.Qt.DisplayRole) label = font_metrics["h5"].elidedText(label, QtCore.Qt.ElideRight, label_rect.width()) # Maintain reference to state, so we can restore it once we're done painter.save() painter.setFont(fonts["awesome6"]) painter.setPen(QtGui.QPen(colors["idle"])) painter.drawText(expander_rect, QtCore.Qt.AlignCenter, expander_icon) # Draw label painter.setFont(fonts["h5"]) painter.drawText(label_rect, label) # Ok, we're done, tidy up. painter.restore()
def paint_close_button(self): """ Let's draw a tiny little x on the right that's our new close button. It's just two little lines! x Notes: - it's probably faster if we only iterate over visible tabs. - How can this be used to write italic text? - we could change the x to a o like sublime - ANTIALIASING PLEASEEEEEEEEEEEEEEEEEEEEEEEEEEEEE """ #print 1 #print dir(e) #e.accept() #paint_rect = e.rect() for i in range(self.count()): rect = self.tabRect(i) if not self.rect().contains(rect): continue # would be nice to optimise #print 'tab: ', rect x, y, r, t = rect.getCoords() #print rect.getCoords() #rqt = QtCore.QRect(x+(r/2),y,r+1,t+1) rqt = self.tab_close_button_rect(i) #QtCore.QRect.right() #QtCore.QRect.adjust() #print 'rt side:', rqt #print e.region() p = QtGui.QPainter() #p.setRenderHint(QtGui.QPainter.Antialiasing) p.begin(self) p.setBrush(self.brush) if i == self.over_button and self.mouse_over_rect: brush = QtGui.QBrush(QtCore.Qt.gray) p.setBrush(brush) p.setPen(None) p.setRenderHint(QtGui.QPainter.Antialiasing) #p.drawEllipse(rqt) p.setPen(self.pen) self.pen.setWidth(2) if i == self.over_button and self.mouse_over_rect: pen = QtGui.QPen(QtCore.Qt.white) pen.setWidth(2) p.setPen(pen) #p.save() #p.drawText(rect, QtCore.Qt.AlignCenter, 'tab') #x,y,r,t = rqt.x, rqt.y, rqt.right(), rqt.top() #bl = rqt.bottomLeft() #tr = rqt.topRight() #p.drawLine(bl, tr) a = 2 rqt.adjust(a, a, -a, -a) p.drawLine(rqt.bottomLeft(), rqt.topRight()) p.drawLine(rqt.topLeft(), rqt.bottomRight()) #p.restore() # print rqt p.end()